Add files using upload-large-folder tool

testbed/open-mmlab__mmengine/.gitignore

@@ -0,0 +1,123 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+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/en/api/generated/
+docs/zh_cn/_build/
+docs/zh_cn/api/generated/
+src/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+.vscode
+.idea
+.DS_Store
+
+# custom
+*.pkl
+*.pkl.json
+*.log.json
+docs/modelzoo_statistics.md
+work_dirs/
+
+# Pytorch
+*.pth
+*.py~
+*.sh~

testbed/open-mmlab__mmengine/.owners.yml

@@ -0,0 +1,12 @@
+assign:
+  strategy:
+    # random
+    daily-shift-based
+  scedule:
+    '*/1 * * * *'
+  assignees:
+    - HAOCHENYE
+    - zhouzaida
+    - C1rN09
+    - ice-tong
+    - HAOCHENYE

testbed/open-mmlab__mmengine/.pre-commit-config-zh-cn.yaml

@@ -0,0 +1,61 @@
+exclude: ^tests/data/
+repos:
+  - repo: https://gitee.com/openmmlab/mirrors-flake8
+    rev: 5.0.4
+    hooks:
+      - id: flake8
+  - repo: https://gitee.com/openmmlab/mirrors-isort
+    rev: 5.10.1
+    hooks:
+      - id: isort
+  - repo: https://gitee.com/openmmlab/mirrors-yapf
+    rev: v0.32.0
+    hooks:
+      - id: yapf
+  - repo: https://gitee.com/openmmlab/mirrors-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://gitee.com/openmmlab/mirrors-mdformat
+    rev: 0.7.9
+    hooks:
+      - id: mdformat
+        args: ["--number"]
+        additional_dependencies:
+          - mdformat-openmmlab
+          - mdformat_frontmatter
+          - linkify-it-py
+  - repo: https://gitee.com/openmmlab/mirrors-codespell
+    rev: v2.2.1
+    hooks:
+      - id: codespell
+  - repo: https://gitee.com/openmmlab/mirrors-docformatter
+    rev: v1.3.1
+    hooks:
+      - id: docformatter
+        args: ["--in-place", "--wrap-descriptions", "79"]
+  - repo: https://gitee.com/openmmlab/mirrors-pyupgrade
+    rev: v3.0.0
+    hooks:
+      - id: pyupgrade
+        args: ["--py36-plus"]
+  - repo: https://gitee.com/openmmlab/pre-commit-hooks
+    rev: v0.4.0
+    hooks:
+      - id: check-copyright
+        args: ["mmengine", "tests"]
+      - id: remove-improper-eol-in-cn-docs
+  - repo: https://gitee.com/openmmlab/mirrors-mypy
+    rev: v0.812
+    hooks:
+      - id: mypy
+        exclude: "docs"

testbed/open-mmlab__mmengine/.pre-commit-config.yaml

@@ -0,0 +1,61 @@
+exclude: ^tests/data/
+repos:
+  - repo: https://github.com/PyCQA/flake8
+    rev: 5.0.4
+    hooks:
+      - id: flake8
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.10.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
+  - repo: https://github.com/myint/docformatter
+    rev: v1.3.1
+    hooks:
+      - id: docformatter
+        args: ["--in-place", "--wrap-descriptions", "79"]
+  - 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.4.0
+    hooks:
+      - id: check-copyright
+        args: ["mmengine", "tests"]
+      - id: remove-improper-eol-in-cn-docs
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.812
+    hooks:
+      - id: mypy
+        exclude: "docs"

testbed/open-mmlab__mmengine/.readthedocs.yml

@@ -0,0 +1,9 @@
+version: 2
+
+formats: all
+
+python:
+  version: 3.7
+  install:
+    - requirements: requirements/runtime.txt
+    - requirements: requirements/docs.txt

testbed/open-mmlab__mmengine/CODEOWNERS

@@ -0,0 +1,84 @@
+# IMPORTANT:
+# This file is ONLY used to subscribe for notifications for PRs
+# related to a specific file path, and each line is a file pattern followed by
+# one or more owners.
+
+# Order is important; the last matching pattern takes the most
+# precedence.
+
+# These owners will be the default owners for everything in
+# the repo. Unless a later match takes precedence,
+# @global-owner1 and @global-owner2 will be requested for
+# review when someone opens a pull request.
+* @zhouzaida @HAOCHENYE
+
+# Docs
+/docs/ @C1rN09
+*.rst @zhouzaida @HAOCHENYE
+
+# mmengine file
+# config
+/mmengine/config/ @HAOCHENYE
+
+# dataset
+/mmengine/dataset/ @HAOCHENYE
+
+# device
+/mmengine/device/ @zhouzaida
+
+# dist
+/mmengine/dist/ @zhouzaida @C1rN09
+
+# evaluator
+/mmengine/evaluator/ @RangiLyu @ice-tong
+
+# fileio
+/mmengine/fileio/ @zhouzaida
+
+# hooks
+/mmengine/hooks/ @zhouzaida @HAOCHENYE
+/mmengine/hooks/ema_hook.py @RangiLyu
+
+# hub
+/mmengine/hub/ @HAOCHENYE @zhouzaida
+
+# logging
+/mmengine/logging/ @HAOCHENYE
+
+# model
+/mmengine/model/ @HAOCHENYE @C1rN09
+/mmengine/model/averaged_model.py @RangiLyu
+/mmengine/model/wrappers/fully_sharded_distributed.py @C1rN09
+
+# optim
+/mmengine/optim/ @HAOCHENYE
+/mmengine/optim/scheduler/ @RangiLyu
+
+# registry
+/mmengine/registry/ @C1rN09 @HAOCHENYE
+
+# runner
+/mmengine/runner/ @zhouzaida @RangiLyu @HAOCHENYE
+/mmengine/runner/amp.py @HAOCHENYE
+/mmengine/runner/log_processor.py @HAOCHENYE
+/mmengine/runner/checkpoint.py @zhouzaida @C1rN09
+/mmengine/runner/priority.py @zhouzaida
+/mmengine/runner/utils.py @zhouzaida @HAOCHENYE
+
+# structure
+/mmengine/structures/ @Harold-lkk @HAOCHENYE
+
+# testing
+/mmengine/testing/ @zhouzaida
+
+# utils
+/mmengine/utils/ @HAOCHENYE @zhouzaida
+
+# visualization
+/mmengine/visualization/ @Harold-lkk @HAOCHENYE
+
+# version
+/mmengine/__version__.py @zhouzaida
+
+# unit test
+/tests/ @zhouzaida @HAOCHENYE

testbed/open-mmlab__mmengine/CONTRIBUTING.md

@@ -0,0 +1,240 @@
+## Contributing to OpenMMLab
+
+Welcome to the MMEngine community, we are committed to building a cutting-edge computer vision foundational library and all kinds of contributions are welcomed, including but not limited to
+
+**Fix bug**
+
+You can directly post a Pull Request to fix typo in code or documents
+
+The steps to fix the bug of code implementation are as follows.
+
+1. If the modification involve significant changes, you should create an issue first and describe the error information and how to trigger the bug. Other developers will discuss with you and propose an proper solution.
+
+2. Posting a pull request after fixing the bug and adding corresponding unit test.
+
+**New Feature or Enhancement**
+
+1. If the modification involve significant changes, you should create an issue to discuss with our developers to propose an proper design.
+2. Post a Pull Request after implementing the new feature or enhancement and add corresponding unit test.
+
+**Document**
+
+You can directly post a pull request to fix documents. If you want to add a document, you should first create an issue to check if it is reasonable.
+
+### Pull Request Workflow
+
+If you're not familiar with Pull Request, don't worry! The following guidance will tell you how to create a Pull Request step by step. If you want to dive into the develop mode of Pull Request, you can refer to the [official documents](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests)
+
+#### 1. Fork and clone
+
+If you are posting a pull request for the first time, you should fork the OpenMMLab repositories by clicking the **Fork** button in the top right corner of the GitHub page, and the forked repositories will appear under your GitHub profile.
+
+<img src="https://user-images.githubusercontent.com/57566630/167305749-43c7f4e9-449b-4e98-ade5-0c9276d5c9ce.png" width="1200">
+
+Then, you can clone the repositories to local:
+
+```shell
+git clone git@github.com:{username}/mmengine.git
+```
+
+After that, you should ddd official repository as the upstream repository
+
+```bash
+git remote add upstream git@github.com:open-mmlab/mmengine
+```
+
+Check whether remote repository has been added successfully by `git remote -v`
+
+```bash
+origin	git@github.com:{username}/mmengine.git (fetch)
+origin	git@github.com:{username}/mmengine.git (push)
+upstream	git@github.com:open-mmlab/mmengine (fetch)
+upstream	git@github.com:open-mmlab/mmengine (push)
+```
+
+> Here's a brief introduction to origin and upstream. When we use "git clone", we create an "origin" remote by default, which points to the repository cloned from. As for "upstream", we add it ourselves to point to the target repository. Of course, if you don't like the name "upstream", you could name it as you wish. Usually, we'll push the code to "origin". If the pushed code conflicts with the latest code in official("upstream"), we should pull the latest code from upstream to resolve the conflicts, and then push to "origin" again. The posted Pull Request will be updated automatically.
+
+#### 2. Configure pre-commit
+
+You should configure [pre-commit](https://pre-commit.com/#intro) in the local development environment to make sure the code style matches that of OpenMMLab. **Note**: The following code should be executed under the mmengine directory.
+
+```shell
+pip install -U pre-commit
+pre-commit install
+```
+
+Check that pre-commit is configured successfully, and install the hooks defined in `.pre-commit-config.yaml`.
+
+```shell
+pre-commit run --all-files
+```
+
+<img src="https://user-images.githubusercontent.com/57566630/173660750-3df20a63-cb66-4d33-a986-1f643f1d8aaf.png" width="1200">
+
+<img src="https://user-images.githubusercontent.com/57566630/202368856-0465a90d-8fce-4345-918e-67b8b9c82614.png" width="1200">
+
+If the installation process is interrupted, you can repeatedly run `pre-commit run ... ` to continue the installation.
+
+If the code does not conform to the code style specification, pre-commit will raise a warning and  fixes some of the errors automatically.
+
+<img src="https://user-images.githubusercontent.com/57566630/202369176-67642454-0025-4023-a095-263529107aa3.png" width="1200">
+
+If we want to commit our code bypassing the pre-commit hook, we can use the `--no-verify` option(**only for temporarily commit**).
+
+```shell
+git commit -m "xxx" --no-verify
+```
+
+#### 3. Create a development branch
+
+After configuring the pre-commit, we should create a branch based on the master branch to develop the new feature or fix the bug. The proposed branch name is `username/pr_name`
+
+```shell
+git checkout -b yhc/refactor_contributing_doc
+```
+
+In subsequent development, if the master branch of the local repository is behind the master branch of "upstream", we need to pull the upstream for synchronization, and then execute the above command:
+
+```shell
+git pull upstream master
+```
+
+#### 4. Commit the code and pass the unit test
+
+- MMEngine introduces mypy to do static type checking to increase the robustness of the code. Therefore, we need to add Type Hints to our code and pass the mypy check. If you are not familiar with Type Hints, you can refer to [this tutorial](https://docs.python.org/3/library/typing.html).
+
+- The committed code should pass through the unit test
+
+  ```shell
+  # Pass all unit tests
+  pytest tests
+
+  # Pass the unit test of runner
+  pytest tests/test_runner/test_runner.py
+  ```
+
+  If the unit test fails for lack of dependencies, you can install the dependencies referring to the [guidance](#unit-test)
+
+- If the documents are modified/added, we should check the rendering result referring to [guidance](#document-rendering)
+
+#### 5. Push the code to remote
+
+We could push the local commits to remote after passing through the check of unit test and pre-commit. You can associate the local branch with remote branch by adding `-u` option.
+
+```shell
+git push -u origin {branch_name}
+```
+
+This will allow you to use the `git push` command to push code directly next time without specifying a branch or the remote repository.
+
+#### 6. Create a Pull Request
+
+(1) Create a pull request in GitHub's Pull request interface
+
+<img src="https://user-images.githubusercontent.com/57566630/201533288-516f7ac4-0b14-4dc8-afbd-912475c368b5.png" width="1200">
+
+(2) Modify the PR description according to the guidelines so that other developers can better understand your changes
+
+<img src="https://user-images.githubusercontent.com/57566630/202242953-c91a18ff-e388-4ff9-8591-5fae0ead6c1e.png" width="1200">
+
+Find more details about Pull Request description in [pull request guidelines](#pr-specs).
+
+**note**
+
+(a) The Pull Request description should contain the reason for the change, the content of the change, and the impact of the change, and be associated with the relevant Issue (see [documentation](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)
+
+(b) If it is your first contribution, please sign the CLA
+
+<img src="https://user-images.githubusercontent.com/57566630/167307569-a794b967-6e28-4eac-a942-00deb657815f.png" width="1200">
+
+(c) Check whether the Pull Request pass through the CI
+
+<img src="https://user-images.githubusercontent.com/57566630/167307490-f9ebf9fa-63c0-4d83-8ba1-081ea169eb3a.png" width="1200">
+
+MMEngine will run unit test for the posted Pull Request on different platforms (Linux, Window, Mac), based on different versions of Python, PyTorch, CUDA to make sure the code is correct. We can see the specific test information by clicking `Details` in the above image so that we can modify the code.
+
+(3) If the Pull Request passes the CI, then you can wait for the review from other developers. You'll modify the code based on the reviewer's comments, and repeat the steps [4](#4-commit-the-code-and-pass-the-unit-test)-[5](#5-push-the-code-to-remote) until all reviewers approve it. Then, we will merge it ASAP.
+
+<img src="https://user-images.githubusercontent.com/57566630/202145400-cc2cd8c4-10b0-472f-ba37-07e6f50acc67.png" width="1200">
+
+#### 7. Resolve conflicts
+
+If your local branch conflicts with the latest master branch of "upstream", you'll need to resolove them. There are two ways to do this:
+
+```shell
+git fetch --all --prune
+git rebase upstream/master
+```
+
+or
+
+```shell
+git fetch --all --prune
+git merge upstream/master
+```
+
+If you are very good at handling conflicts, then you can use rebase to resolve conflicts, as this will keep your commit logs tidy. If you are not familiar with `rebase`, then you can use `merge` to resolve conflicts.
+
+### Guidance
+
+#### Unit test
+
+We should also make sure the committed code will not decrease the coverage of unit test, we could run the following command to check the coverage of unit test:
+
+```shell
+python -m coverage run -m pytest /path/to/test_file
+python -m coverage html
+# check file in htmlcov/index.html
+```
+
+#### Document rendering
+
+If the documents are modified/added, we should check the rendering result. We could install the dependencies and run the following command to render the documents and check the results:
+
+```shell
+pip install -r requirements/docs.txt
+cd docs/zh_cn/
+# or docs/en
+make html
+# check file in ./docs/zh_cn/_build/html/index.html
+```
+
+### Python Code style
+
+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).
+
+### PR Specs
+
+1. Use [pre-commit](https://pre-commit.com) hook to avoid issues of code style
+
+2. One short-time branch should be matched with only one PR
+
+3. Accomplish a detailed change in one PR. Avoid large PR
+
+   - Bad: Support Faster R-CNN
+   - Acceptable: Add a box head to Faster R-CNN
+   - Good: Add a parameter to box head to support custom conv-layer number
+
+4. Provide clear and significant commit message
+
+5. Provide clear and meaningful PR description
+
+   - Task name should be clarified in title. The general format is: \[Prefix\] Short description of the PR (Suffix)
+   - Prefix: add new feature \[Feature\], fix bug \[Fix\], related to documents \[Docs\], in developing \[WIP\] (which will not be reviewed temporarily)
+   - Introduce main changes, results and influences on other modules in short description
+   - Associate related issues and pull requests with a milestone

testbed/open-mmlab__mmengine/CONTRIBUTING_zh-CN.md

@@ -0,0 +1,255 @@
+## 贡献代码
+
+欢迎加入 MMEngine 社区，我们致力于打造最前沿的深度学习模型训练的基础库，我们欢迎任何类型的贡献，包括但不限于
+
+**修复错误**
+
+修复代码实现错误的步骤如下：
+
+1. 如果提交的代码改动较大，建议先提交 issue，并正确描述 issue 的现象、原因和复现方式，讨论后确认修复方案。
+2. 修复错误并补充相应的单元测试，提交拉取请求。
+
+**新增功能或组件**
+
+1. 如果新功能或模块涉及较大的代码改动，建议先提交 issue，确认功能的必要性。
+2. 实现新增功能并添单元测试，提交拉取请求。
+
+**文档补充**
+
+修复文档可以直接提交拉取请求
+
+添加文档或将文档翻译成其他语言步骤如下
+
+1. 提交 issue，确认添加文档的必要性。
+2. 添加文档，提交拉取请求。
+
+### 拉取请求工作流
+
+如果你对拉取请求不了解，没关系，接下来的内容将会从零开始，一步一步地指引你如何创建一个拉取请求。如果你想深入了解拉取请求的开发模式，可以参考 github [官方文档](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests)
+
+#### 1. 复刻仓库
+
+当你第一次提交拉取请求时，先复刻 OpenMMLab 原代码库，点击 GitHub 页面右上角的 **Fork** 按钮，复刻后的代码库将会出现在你的 GitHub 个人主页下。
+
+<img src="https://user-images.githubusercontent.com/57566630/167305749-43c7f4e9-449b-4e98-ade5-0c9276d5c9ce.png" width="1200">
+
+将代码克隆到本地
+
+```shell
+git clone git@github.com:{username}/mmengine.git
+```
+
+添加原代码库为上游代码库
+
+```bash
+git remote add upstream git@github.com:open-mmlab/mmengine
+```
+
+检查 remote 是否添加成功，在终端输入 `git remote -v`
+
+```bash
+origin	git@github.com:{username}/mmengine.git (fetch)
+origin	git@github.com:{username}/mmengine.git (push)
+upstream	git@github.com:open-mmlab/mmengine (fetch)
+upstream	git@github.com:open-mmlab/mmengine (push)
+```
+
+> 这里对 origin 和 upstream 进行一个简单的介绍，当我们使用 git clone 来克隆代码时，会默认创建一个 origin 的 remote，它指向我们克隆的代码库地址，而 upstream 则是我们自己添加的，用来指向原始代码库地址。当然如果你不喜欢他叫 upstream，也可以自己修改，比如叫 open-mmlab。我们通常向 origin 提交代码（即 fork 下来的远程仓库），然后向 upstream 提交一个 pull request。如果提交的代码和最新的代码发生冲突，再从 upstream 拉取最新的代码，和本地分支解决冲突，再提交到 origin。
+
+#### 2. 配置 pre-commit
+
+在本地开发环境中，我们使用 [pre-commit](https://pre-commit.com/#intro) 来检查代码风格，以确保代码风格的统一。在提交代码，需要先安装 pre-commit（需要在 mmengine 目录下执行）:
+
+```shell
+pip install -U pre-commit
+pre-commit install
+```
+
+检查 pre-commit 是否配置成功，并安装 `.pre-commit-config.yaml` 中的钩子：
+
+```shell
+pre-commit run --all-files
+```
+
+<img src="https://user-images.githubusercontent.com/57566630/173660750-3df20a63-cb66-4d33-a986-1f643f1d8aaf.png" width="1200">
+
+<img src="https://user-images.githubusercontent.com/57566630/202368856-0465a90d-8fce-4345-918e-67b8b9c82614.png" width="1200">
+
+> 如果你是中国用户，由于网络原因，可能会出现安装失败的情况，这时可以使用国内源
+
+> pre-commit install -c .pre-commit-config-zh-cn.yaml
+
+> pre-commit run --all-files -c .pre-commit-config-zh-cn.yaml
+
+如果安装过程被中断，可以重复执行 `pre-commit run ...` 继续安装。
+
+如果提交的代码不符合代码风格规范，pre-commit 会发出警告，并自动修复部分错误。
+
+<img src="https://user-images.githubusercontent.com/57566630/202369176-67642454-0025-4023-a095-263529107aa3.png" width="1200">
+
+如果我们想临时绕开 pre-commit 的检查提交一次代码，可以在 `git commit` 时加上 `--no-verify`（需要保证最后推送至远程仓库的代码能够通过 pre-commit 检查）。
+
+```shell
+git commit -m "xxx" --no-verify
+```
+
+#### 3. 创建开发分支
+
+安装完 pre-commit 之后，我们需要基于 master 创建开发分支，建议的分支命名规则为 `username/pr_name`。
+
+```shell
+git checkout -b yhc/refactor_contributing_doc
+```
+
+在后续的开发中，如果本地仓库的 master 分支落后于 upstream 的 master 分支，我们需要先拉取 upstream 的代码进行同步，再执行上面的命令
+
+```shell
+git pull upstream master
+```
+
+#### 4. 提交代码并在本地通过单元测试
+
+- MMEngine 引入了 mypy 来做静态类型检查，以增加代码的鲁棒性。因此我们在提交代码时，需要补充 Type Hints。具体规则可以参考[教程](https://zhuanlan.zhihu.com/p/519335398)。
+
+- 提交的代码同样需要通过单元测试
+
+  ```shell
+  # 通过全量单元测试
+  pytest tests
+
+  # 我们需要保证提交的代码能够通过修改模块的单元测试，以 runner 为例
+  pytest tests/test_runner/test_runner.py
+  ```
+
+  如果你由于缺少依赖无法运行修改模块的单元测试，可以参考[指引-单元测试](#单元测试)
+
+- 如果修改/添加了文档，参考[指引](#文档渲染)确认文档渲染正常。
+
+#### 5. 推送代码到远程
+
+代码通过单元测试和 pre-commit 检查后，将代码推送到远程仓库，如果是第一次推送，可以在 `git push` 后加上 `-u` 参数以关联远程分支
+
+```shell
+git push -u origin {branch_name}
+```
+
+这样下次就可以直接使用 `git push` 命令推送代码了，而无需指定分支和远程仓库。
+
+#### 6. 提交拉取请求（PR）
+
+(1) 在 GitHub 的 Pull request 界面创建拉取请求
+<img src="https://user-images.githubusercontent.com/57566630/201533288-516f7ac4-0b14-4dc8-afbd-912475c368b5.png" width="1200">
+
+(2) 根据指引修改 PR 描述，以便于其他开发者更好地理解你的修改
+
+<img src="https://user-images.githubusercontent.com/57566630/202242953-c91a18ff-e388-4ff9-8591-5fae0ead6c1e.png" width="1200">
+
+描述规范详见[拉取请求规范](#拉取请求规范)
+
+&#160;
+
+**注意事项**
+
+(a) PR 描述应该包含修改理由、修改内容以及修改后带来的影响，并关联相关 Issue（具体方式见[文档](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)）
+
+(b) 如果是第一次为 OpenMMLab 做贡献，需要签署 CLA
+
+<img src="https://user-images.githubusercontent.com/57566630/167307569-a794b967-6e28-4eac-a942-00deb657815f.png" width="1200">
+
+(c) 检查提交的 PR 是否通过 CI（集成测试）
+
+<img src="https://user-images.githubusercontent.com/57566630/167307490-f9ebf9fa-63c0-4d83-8ba1-081ea169eb3a.png" width="1200">
+
+MMEngine 会在不同的平台（Linux、Window、Mac），基于不同版本的 Python、PyTorch、CUDA 对提交的代码进行单元测试，以保证代码的正确性，如果有任何一个没有通过，我们可点击上图中的 `Details` 来查看具体的测试信息，以便于我们修改代码。
+
+(3) 如果 PR 通过了 CI，那么就可以等待其他开发者的 review，并根据 reviewer 的意见，修改代码，并重复 [4](#4-提交代码并本地通过单元测试)-[5](#5-推送代码到远程) 步骤，直到 reviewer 同意合入 PR。
+
+<img src="https://user-images.githubusercontent.com/57566630/202145400-cc2cd8c4-10b0-472f-ba37-07e6f50acc67.png" width="1200">
+
+所有 reviewer 同意合入 PR 后，我们会尽快将 PR 合并到主分支。
+
+#### 7. 解决冲突
+
+随着时间的推移，我们的代码库会不断更新，这时候，如果你的 PR 与主分支存在冲突，你需要解决冲突，解决冲突的方式有两种：
+
+```shell
+git fetch --all --prune
+git rebase upstream/master
+```
+
+或者
+
+```shell
+git fetch --all --prune
+git merge upstream/master
+```
+
+如果你非常善于处理冲突，那么可以使用 rebase 的方式来解决冲突，因为这能够保证你的 commit log 的整洁。如果你不太熟悉 `rebase` 的使用，那么可以使用 `merge` 的方式来解决冲突。
+
+### 指引
+
+#### 单元测试
+
+在提交修复代码错误或新增特性的拉取请求时，我们应该尽可能的让单元测试覆盖所有提交的代码，计算单元测试覆盖率的方法如下
+
+```shell
+python -m coverage run -m pytest /path/to/test_file
+python -m coverage html
+# check file in htmlcov/index.html
+```
+
+#### 文档渲染
+
+在提交修复代码错误或新增特性的拉取请求时，可能会需要修改/新增模块的 docstring。我们需要确认渲染后的文档样式是正确的。
+本地生成渲染后的文档的方法如下
+
+```shell
+pip install -r requirements/docs.txt
+cd docs/zh_cn/
+# or docs/en
+make html
+# check file in ./docs/zh_cn/_build/html/index.html
+```
+
+### Python 代码风格
+
+[PEP8](https://www.python.org/dev/peps/pep-0008/) 作为 OpenMMLab 算法库首选的代码规范，我们使用以下工具检查和格式化代码
+
+- [flake8](https://github.com/PyCQA/flake8): Python 官方发布的代码规范检查工具，是多个检查工具的封装
+- [isort](https://github.com/timothycrosley/isort): 自动调整模块导入顺序的工具
+- [yapf](https://github.com/google/yapf): Google 发布的代码规范检查工具
+- [codespell](https://github.com/codespell-project/codespell): 检查单词拼写是否有误
+- [mdformat](https://github.com/executablebooks/mdformat): 检查 markdown 文件的工具
+- [docformatter](https://github.com/myint/docformatter): 格式化 docstring 的工具
+
+yapf 和 isort 的配置可以在 [setup.cfg](./setup.cfg) 找到
+
+通过配置 [pre-commit hook](https://pre-commit.com/) ，我们可以在提交代码时自动检查和格式化 `flake8`、`yapf`、`isort`、`trailing whitespaces`、`markdown files`，修复 `end-of-files`、`double-quoted-strings`、`python-encoding-pragma`、`mixed-line-ending`，调整 `requirments.txt` 的包顺序。
+pre-commit 钩子的配置可以在 [.pre-commit-config](./.pre-commit-config.yaml) 找到。
+
+pre-commit 具体的安装使用方式见[拉取请求](#2-配置-pre-commit)。
+
+更具体的规范请参考 [OpenMMLab 代码规范](code_style.md)。
+
+### 拉取请求规范
+
+1. 使用 [pre-commit hook](https://pre-commit.com)，尽量减少代码风格相关问题
+
+2. 一个`拉取请求`对应一个短期分支
+
+3. 粒度要细，一个`拉取请求`只做一件事情，避免超大的`拉取请求`
+
+   - Bad：实现 Faster R-CNN
+   - Acceptable：给 Faster R-CNN 添加一个 box head
+   - Good：给 box head 增加一个参数来支持自定义的 conv 层数
+
+4. 每次 Commit 时需要提供清晰且有意义 commit 信息
+
+5. 提供清晰且有意义的`拉取请求`描述
+
+   - 标题写明白任务名称，一般格式:\[Prefix\] Short description of the pull request (Suffix)
+   - prefix: 新增功能 \[Feature\], 修 bug \[Fix\], 文档相关 \[Docs\], 开发中 \[WIP\] (暂时不会被review)
+   - 描述里介绍`拉取请求`的主要修改内容，结果，以及对其他部分的影响, 参考`拉取请求`模板
+   - 关联相关的`议题` (issue) 和其他`拉取请求`
+
+6. 如果引入了其他三方库，或借鉴了三方库的代码，请确认他们的许可证和 MMEngine 兼容，并在借鉴的代码上补充 `This code is inspired from http://`

testbed/open-mmlab__mmengine/LICENSE

@@ -0,0 +1,203 @@
+Copyright 2018-2023 OpenMMLab. 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 2018-2023 OpenMMLab.
+
+   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.

testbed/open-mmlab__mmengine/MANIFEST.in

@@ -0,0 +1 @@
+include mmengine/hub/openmmlab.json mmengine/hub/deprecated.json mmengine/hub/mmcls.json mmengine/hub/torchvision_0.12.json

testbed/open-mmlab__mmengine/README.md

@@ -0,0 +1,306 @@
+<div align="center">
+  <img src="https://user-images.githubusercontent.com/58739961/187154444-fce76639-ac8d-429b-9354-c6fac64b7ef8.jpg" height="100"/>
+  <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/mmengine)](https://pypi.org/project/mmengine/)
+[![PyPI](https://img.shields.io/pypi/v/mmengine)](https://pypi.org/project/mmengine)
+[![license](https://img.shields.io/github/license/open-mmlab/mmengine.svg)](https://github.com/open-mmlab/mmengine/blob/main/LICENSE)
+[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmengine.svg)](https://github.com/open-mmlab/mmengine/issues)
+[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmengine.svg)](https://github.com/open-mmlab/mmengine/issues)
+
+[🤔Reporting Issues](https://github.com/open-mmlab/mmengine/issues/new/choose)
+
+</div>
+
+<div align="center">
+
+English | [简体中文](README_zh-CN.md)
+
+</div>
+
+## Introduction
+
+MMEngine is a foundational library for training deep learning models based on PyTorch. It provides a solid engineering foundation and frees developers from writing redundant codes on workflows. It serves as the training engine of all OpenMMLab codebases, which support hundreds of algorithms in various research areas. Moreover, MMEngine is also generic to be applied to non-OpenMMLab projects.
+
+Major features:
+
+1. **A universal and powerful runner**:
+
+   - Supports training different tasks with a small amount of code, e.g., ImageNet can be trained with only 80 lines of code (400 lines of the original PyTorch example)
+   - Easily compatible with models from popular algorithm libraries such as TIMM, TorchVision, and Detectron2
+
+2. **Open architecture with unified interfaces**:
+
+   - Handles different algorithm tasks with unified APIs, e.g., implement a method and apply it to all compatible models.
+   - Provides a unified abstraction for upper-level algorithm libraries, which supports various back-end devices such as Nvidia CUDA, Mac MPS, AMD, MLU, and more for model training.
+
+3. **Customizable training process**:
+
+   - Defines the training process just like playing with Legos.
+   - Provides rich components and strategies.
+   - Complete controls on the training process with different levels of APIs.
+
+## What's New
+
+v0.3.2 was released in 2022-11-24.
+
+Read [Changelog](./docs/en/notes/changelog.md#v032-11242022) for more details.
+
+## Installation
+
+Before installing MMEngine, please ensure that PyTorch has been successfully installed following the [official guide](https://pytorch.org/get-started/locally/).
+
+Install MMEngine
+
+```bash
+pip install -U openmim
+mim install mmengine
+```
+
+Verify the installation
+
+```bash
+python -c 'from mmengine.utils.dl_utils import collect_env;print(collect_env())'
+```
+
+## Get Started
+
+Taking the training of a ResNet-50 model on the CIFAR-10 dataset as an example, we will use MMEngine to build a complete, configurable training and validation process in less than 80 lines of code.
+
+<details>
+<summary>Build Models</summary>
+
+First, we need to define a **model** which 1) inherits from `BaseModel` and 2) accepts an additional argument `mode` in the `forward` method, in addition to those arguments related to the dataset.
+
+- During training, the value of `mode` is "loss," and the `forward` method should return a   `dict` containing the key "loss".
+- During validation, the value of `mode` is "predict", and the forward method should return results containing both predictions and labels.
+
+```python
+import torch.nn.functional as F
+import torchvision
+from mmengine.model import BaseModel
+
+class MMResNet50(BaseModel):
+    def __init__(self):
+        super().__init__()
+        self.resnet = torchvision.models.resnet50()
+
+    def forward(self, imgs, labels, mode):
+        x = self.resnet(imgs)
+        if mode == 'loss':
+            return {'loss': F.cross_entropy(x, labels)}
+        elif mode == 'predict':
+            return x, labels
+```
+
+</details>
+
+<details>
+<summary>Build Datasets</summary>
+
+Next, we need to create **Dataset**s and **DataLoader**s for training and validation.
+In this case, we simply use built-in datasets supported in TorchVision.
+
+```python
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader
+
+norm_cfg = dict(mean=[0.491, 0.482, 0.447], std=[0.202, 0.199, 0.201])
+train_dataloader = DataLoader(batch_size=32,
+                              shuffle=True,
+                              dataset=torchvision.datasets.CIFAR10(
+                                  'data/cifar10',
+                                  train=True,
+                                  download=True,
+                                  transform=transforms.Compose([
+                                      transforms.RandomCrop(32, padding=4),
+                                      transforms.RandomHorizontalFlip(),
+                                      transforms.ToTensor(),
+                                      transforms.Normalize(**norm_cfg)
+                                  ])))
+val_dataloader = DataLoader(batch_size=32,
+                            shuffle=False,
+                            dataset=torchvision.datasets.CIFAR10(
+                                'data/cifar10',
+                                train=False,
+                                download=True,
+                                transform=transforms.Compose([
+                                    transforms.ToTensor(),
+                                    transforms.Normalize(**norm_cfg)
+                                ])))
+```
+
+</details>
+
+<details>
+<summary>Build Metrics</summary>
+
+To validate and test the model, we need to define a **Metric** called accuracy to evaluate the model. This metric needs to inherit from `BaseMetric` and implements the `process` and `compute_metrics` methods.
+
+```python
+from mmengine.evaluator import BaseMetric
+
+class Accuracy(BaseMetric):
+    def process(self, data_batch, data_samples):
+        score, gt = data_samples
+        # Save the results of a batch to `self.results`
+        self.results.append({
+            'batch_size': len(gt),
+            'correct': (score.argmax(dim=1) == gt).sum().cpu(),
+        })
+    def compute_metrics(self, results):
+        total_correct = sum(item['correct'] for item in results)
+        total_size = sum(item['batch_size'] for item in results)
+        # Returns a dictionary with the results of the evaluated metrics,
+        # where the key is the name of the metric
+        return dict(accuracy=100 * total_correct / total_size)
+```
+
+</details>
+
+<details>
+<summary>Build a Runner</summary>
+
+Finally, we can construct a **Runner** with previously defined `Model`, `DataLoader`, and `Metrics`, with some other configs, as shown below.
+
+```python
+from torch.optim import SGD
+from mmengine.runner import Runner
+
+runner = Runner(
+    model=MMResNet50(),
+    work_dir='./work_dir',
+    train_dataloader=train_dataloader,
+    # a wapper to execute back propagation and gradient update, etc.
+    optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+    # set some training configs like epochs
+    train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+    val_dataloader=val_dataloader,
+    val_cfg=dict(),
+    val_evaluator=dict(type=Accuracy),
+)
+```
+
+</details>
+
+<details>
+<summary>Launch Training</summary>
+
+```python
+runner.train()
+```
+
+</details>
+
+## Learn More
+
+<details>
+<summary>Tutorials</summary>
+
+- [Runner](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html)
+- [Dataset and DataLoader](https://mmengine.readthedocs.io/en/latest/tutorials/dataset.html)
+- [Model](https://mmengine.readthedocs.io/en/latest/tutorials/model.html)
+- [Evaluation](https://mmengine.readthedocs.io/en/latest/tutorials/evaluation.html)
+- [OptimWrapper](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html)
+- [Parameter Scheduler](https://mmengine.readthedocs.io/en/latest/tutorials/param_scheduler.html)
+- [Hook](https://mmengine.readthedocs.io/en/latest/tutorials/hook.html)
+
+</details>
+
+<details>
+<summary>Advanced tutorials</summary>
+
+- [Registry](https://mmengine.readthedocs.io/en/latest/tutorials/registry.html)
+- [Config](https://mmengine.readthedocs.io/en/latest/tutorials/config.html)
+- [BaseDataset](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/basedataset.html)
+- [Data Transform](https://mmengine.readthedocs.io/en/latest/tutorials/data_transform.html)
+- [Initialization](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/initialize.html)
+- [Visualization](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/visualization.html)
+- [Abstract Data Element](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/data_element.html)
+- [Distribution Communication](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/distributed.html)
+- [Logging](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/logging.html)
+- [File IO](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/fileio.html)
+- [Global manager (ManagerMixin)](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/manager_mixin.html)
+- [Use modules from other libraries](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/cross_library.html)
+
+</details>
+
+<details>
+<summary>Examples</summary>
+
+- [Resume Training](https://mmengine.readthedocs.io/en/latest/examples/resume_training.html)
+- [Speed up Training](https://mmengine.readthedocs.io/en/latest/examples/speed_up_training.html)
+- [Save Memory on GPU](https://mmengine.readthedocs.io/en/latest/examples/save_gpu_memory.html)
+- [Train a GAN](https://mmengine.readthedocs.io/en/latest/examples/train_a_gan.html)
+
+</details>
+
+<details>
+<summary>Design</summary>
+
+- [Hook](https://mmengine.readthedocs.io/en/latest/design/hook.html)
+- [Runner](https://mmengine.readthedocs.io/en/latest/design/runner.html)
+- [Evaluation](https://mmengine.readthedocs.io/en/latest/design/evaluation.html)
+- [Visualization](https://mmengine.readthedocs.io/en/latest/design/visualization.html)
+- [Logging](https://mmengine.readthedocs.io/en/latest/design/logging.html)
+
+</details>
+
+<details>
+<summary>Migration guide</summary>
+
+- [Migrate Runner from MMCV to MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html)
+- [Migrate Hook from MMCV to MMEngine](https://mmengine.readthedocs.io/en/latest/migration/hook.html)
+- [Migrate Model from MMCV to MMEngine](https://mmengine.readthedocs.io/en/latest/migration/model.html)
+- [Migrate Parameter Scheduler from MMCV to MMEngine](https://mmengine.readthedocs.io/en/latest/migration/param_scheduler.html)
+- [Migrate Data Transform to OpenMMLab 2.0](https://mmengine.readthedocs.io/en/latest/migration/transform.html)
+
+</details>
+
+## Contributing
+
+We appreciate all contributions to improve MMEngine. Please refer to [CONTRIBUTING.md](CONTRIBUTING.md) for the contributing guideline.
+
+## License
+
+This project is released under the [Apache 2.0 license](LICENSE).
+
+## Projects in OpenMMLab
+
+- [MIM](https://github.com/open-mmlab/mim): MIM installs OpenMMLab packages.
+- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab foundational library for computer vision.
+- [MMEval](https://github.com/open-mmlab/mmeval): A unified evaluation library for multiple machine learning libraries.
+- [MMClassification](https://github.com/open-mmlab/mmclassification): OpenMMLab image classification toolbox and benchmark.
+- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab detection 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.
+- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO series 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.
+- [MMSelfSup](https://github.com/open-mmlab/mmselfsup): OpenMMLab self-supervised learning toolbox and benchmark.
+- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab model compression 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.
+- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab video perception toolbox and benchmark.
+- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab optical flow toolbox and benchmark.
+- [MMEditing](https://github.com/open-mmlab/mmediting): OpenMMLab image and video editing toolbox.
+- [MMGeneration](https://github.com/open-mmlab/mmgeneration): OpenMMLab image and video generative models toolbox.
+- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab model deployment framework.

testbed/open-mmlab__mmengine/README_zh-CN.md

@@ -0,0 +1,333 @@
+<div align="center">
+  <img src="https://user-images.githubusercontent.com/58739961/187154444-fce76639-ac8d-429b-9354-c6fac64b7ef8.jpg" 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/mmengine)](https://pypi.org/project/mmengine/)
+[![PyPI](https://img.shields.io/pypi/v/mmengine)](https://pypi.org/project/mmengine)
+[![license](https://img.shields.io/github/license/open-mmlab/mmengine.svg)](https://github.com/open-mmlab/mmengine/blob/main/LICENSE)
+[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmengine.svg)](https://github.com/open-mmlab/mmengine/issues)
+[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmengine.svg)](https://github.com/open-mmlab/mmengine/issues)
+
+[📘使用文档](https://mmengine.readthedocs.io/zh_CN/latest/) |
+[🛠️安装教程](https://mmengine.readthedocs.io/zh_CN/latest/get_started/installation.html) |
+[🤔报告问题](https://github.com/open-mmlab/mmengine/issues/new/choose)
+
+</div>
+
+<div align="center">
+
+[English](README.md) | 简体中文
+
+</div>
+
+## 简介
+
+MMEngine 是一个基于 PyTorch 用于深度学习模型训练的基础库，支持在 Linux、Windows、macOS 上运行。它具有如下三个亮点：
+
+1. 通用：MMEngine 实现了一个高级的通用训练器，它能够：
+
+   - 支持用少量代码训练不同的任务，例如仅使用 80 行代码就可以训练 imagenet（原始pytorch example 400 行）
+   - 轻松兼容流行的算法库 (如 TIMM、TorchVision 和 Detectron2 ) 中的模型
+
+2. 统一：MMEngine 设计了一个接口统一的开放架构，使得:
+
+   - 用户可以仅依赖一份代码实现所有任务的轻量化，例如 MMRazor 1.x 相比 MMRazor 0.x 优化了 40% 的代码量
+   - 上下游的对接更加统一便捷，在为上层算法库提供统一抽象的同时，支持多种后端设备。目前 MMEngine 支持 Nvidia CUDA、Mac MPS、AMD、MLU 等设备进行模型训练。
+
+3. 灵活：MMEngine 实现了“乐高”式的训练流程，支持了:
+
+   - 根据迭代数、 loss 和评测结果等动态调整的训练流程、优化策略和数据增强策略，例如早停（early stopping）机制等
+   - 任意形式的模型权重平均，如 Exponential Momentum Average (EMA) 和 Stochastic Weight Averaging (SWA)
+   - 训练过程中针对任意数据和任意节点的灵活可视化和日志控制
+   - 对神经网络模型中各个层的优化配置进行细粒度调整
+   - 混合精度训练的灵活控制
+
+## 最近进展
+
+最新版本 v0.3.2 在 2022.11.24 发布。
+
+如果想了解更多版本更新细节和历史信息，请阅读[更新日志](./docs/en/notes/changelog.md#v032-11242022)
+
+## 安装
+
+在安装 MMengine 之前，请确保 PyTorch 已成功安装在环境中，可以参考 [PyTorch 官方安装文档](https://pytorch.org/get-started/locally/)。
+
+安装 MMEngine
+
+```bash
+pip install -U openmim
+mim install mmengine
+```
+
+验证是否安装成功
+
+```bash
+python -c 'from mmengine.utils.dl_utils import collect_env;print(collect_env())'
+```
+
+更多安装方式请阅读[安装文档](https://mmengine.readthedocs.io/zh_CN/latest/get_started/installation.html)
+
+## 快速上手
+
+以在 CIFAR-10 数据集上训练一个 ResNet-50 模型为例，我们将使用 80 行以内的代码，利用 MMEngine 构建一个完整的、可配置的训练和验证流程。
+
+<details>
+<summary>构建模型</summary>
+
+首先，我们需要构建一个**模型**，在 MMEngine 中，我们约定这个模型应当继承 `BaseModel`，并且其 `forward` 方法除了接受来自数据集的若干参数外，还需要接受额外的参数 `mode`：对于训练，我们需要 `mode` 接受字符串 "loss"，并返回一个包含 "loss" 字段的字典；对于验证，我们需要 `mode` 接受字符串 "predict"，并返回同时包含预测信息和真实信息的结果。
+
+```python
+import torch.nn.functional as F
+import torchvision
+from mmengine.model import BaseModel
+
+class MMResNet50(BaseModel):
+    def __init__(self):
+        super().__init__()
+        self.resnet = torchvision.models.resnet50()
+
+    def forward(self, imgs, labels, mode):
+        x = self.resnet(imgs)
+        if mode == 'loss':
+            return {'loss': F.cross_entropy(x, labels)}
+        elif mode == 'predict':
+            return x, labels
+```
+
+</details>
+
+<details>
+<summary>构建数据集</summary>
+
+其次，我们需要构建训练和验证所需要的**数据集 (Dataset)**和**数据加载器 (DataLoader)**。
+对于基��的训练和验证功能，我们可以直接使用符合 PyTorch 标准的数据加载器和数据集。
+
+```python
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader
+
+norm_cfg = dict(mean=[0.491, 0.482, 0.447], std=[0.202, 0.199, 0.201])
+train_dataloader = DataLoader(batch_size=32,
+                              shuffle=True,
+                              dataset=torchvision.datasets.CIFAR10(
+                                  'data/cifar10',
+                                  train=True,
+                                  download=True,
+                                  transform=transforms.Compose([
+                                      transforms.RandomCrop(32, padding=4),
+                                      transforms.RandomHorizontalFlip(),
+                                      transforms.ToTensor(),
+                                      transforms.Normalize(**norm_cfg)
+                                  ])))
+val_dataloader = DataLoader(batch_size=32,
+                            shuffle=False,
+                            dataset=torchvision.datasets.CIFAR10(
+                                'data/cifar10',
+                                train=False,
+                                download=True,
+                                transform=transforms.Compose([
+                                    transforms.ToTensor(),
+                                    transforms.Normalize(**norm_cfg)
+                                ])))
+```
+
+</details>
+
+<details>
+<summary>构建评测指标</summary>
+
+为了进行验证和测试，我们需要定义模型推理结果的**评测指标**。我们约定这一评测指标需要继承 `BaseMetric`，并实现 `process` 和 `compute_metrics` 方法。
+
+```python
+from mmengine.evaluator import BaseMetric
+
+class Accuracy(BaseMetric):
+    def process(self, data_batch, data_samples):
+        score, gt = data_samples
+        # 将一个批次的中间结果保存至 `self.results`
+        self.results.append({
+            'batch_size': len(gt),
+            'correct': (score.argmax(dim=1) == gt).sum().cpu(),
+        })
+    def compute_metrics(self, results):
+        total_correct = sum(item['correct'] for item in results)
+        total_size = sum(item['batch_size'] for item in results)
+        # 返回保存有评测指标结果的字典，其中键为指标名称
+        return dict(accuracy=100 * total_correct / total_size)
+```
+
+</details>
+
+<details>
+<summary>构建执行器</summary>
+
+最后，我们利用构建好的**模型**，**数据加载器**，**评测指标**构建一个**执行器 (Runner)**，同时在其中配置
+**优化器**、**工作路径**、**训练与验证配置**等选项
+
+```python
+from torch.optim import SGD
+from mmengine.runner import Runner
+
+runner = Runner(
+    # 用以训练和验证的模型，需要满足特定的接口需求
+    model=MMResNet50(),
+    # 工作路径，用以保存训练日志、权重文件信息
+    work_dir='./work_dir',
+    # 训练数据加载器，需要满足 PyTorch 数据加载器协议
+    train_dataloader=train_dataloader,
+    # 优化器包装，用于模型优化，并提供 AMP、梯度累积等附加功能
+    optim_wrapper=dict(optimizer=dict(type=SGD, lr=0.001, momentum=0.9)),
+    # 训练配置，用于指定训练周期、验证间隔等信息
+    train_cfg=dict(by_epoch=True, max_epochs=5, val_interval=1),
+    # 验证数据加载器，需要满足 PyTorch 数据加载器协议
+    val_dataloader=val_dataloader,
+    # 验证配置，用于指定验证所需要的额外参数
+    val_cfg=dict(),
+    # 用于验证的评测器，这里使用默认评测器，并评测指标
+    val_evaluator=dict(type=Accuracy),
+)
+```
+
+</details>
+
+<details>
+<summary>开始训练</summary>
+
+```python
+runner.train()
+```
+
+</details>
+
+## 了解更多
+
+<details>
+<summary>入门教程</summary>
+
+- [注册器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/registry.html)
+- [配置](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/config.html)
+- [执行器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)
+- [钩子](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/hook.html)
+- [数据集与数据加载器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/dataset.html)
+- [模型](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/model.html)
+- [评测指标和评测器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/evaluation.html)
+- [优化器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html)
+- [优化器参数调整策略](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/param_scheduler.html)
+- [数据变换](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/data_transform.html)
+- [钩子](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/hook.html)
+
+</details>
+
+<details>
+<summary>进阶教程</summary>
+
+- [注册器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/registry.html)
+- [配置](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/config.html)
+- [数据集基类](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/basedataset.html)
+- [抽象数据接口](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)
+- [可视化](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html)
+- [数据变换](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/data_transform.html)
+- [初始化](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/initialize.html)
+- [可视化](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html)
+- [抽象数据接口](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/data_element.html)
+- [分布式通信原语](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/distributed.html)
+- [记录日志](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/logging.html)
+- [文件读写](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/fileio.html)
+- [辅助类](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/utils.html)
+- [全局管理器](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/manager_mixin.html)
+- [跨库调用模块](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/cross_library.html)
+
+</details>
+
+<details>
+<summary>示例</summary>
+- [恢复训练](https://mmengine.readthedocs.io/zh_CN/latest/examples/resume_training.html)
+- [加速训练](https://mmengine.readthedocs.io/zh_CN/latest/examples/speed_up_training.html)
+- [节省显存](https://mmengine.readthedocs.io/zh_CN/latest/examples/save_gpu_memory.html)
+- [跨库调用模块](https://mmengine.readthedocs.io/zh_CN/latest/examples/cross_library.html)
+- [训练生成对抗网络](https://mmengine.readthedocs.io/zh_CN/latest/examples/train_a_gan.html)
+
+</details>
+<details>
+<summary>架构设计</summary>
+- [钩子的设计](https://mmengine.readthedocs.io/zh_CN/latest/design/hook.html)
+- [执行器的设计](https://mmengine.readthedocs.io/zh_CN/latest/design/runner.html)
+- [模型精度评测的设计](https://mmengine.readthedocs.io/zh_CN/latest/design/evaluation.html)
+- [可视化的设计](https://mmengine.readthedocs.io/zh_CN/latest/design/visualization.html)
+- [日志系统的设计](https://mmengine.readthedocs.io/zh_CN/latest/design/logging.html)
+</details>
+<details>
+<summary>迁移指南</summary>
+- [迁移 MMCV 执行器到 MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/migration/runner.html)
+- [迁移 MMCV 钩子到 MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/migration/hook.html)
+- [迁移 MMCV 模型到 MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/migration/model.html)
+- [迁移 MMCV 参数调度器到 MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/migration/param_scheduler.html)
+- [数据变换类的迁移](https://mmengine.readthedocs.io/zh_CN/latest/migration/transform.html)
+</details>
+
+## 贡献指南
+
+我们感谢所有的贡献者为改进和提升 MMEngine 所作出的努力。请参考[贡献指南](CONTRIBUTING_zh-CN.md)来了解参与项目贡献的相关指引。
+
+## 开源许可证
+
+该项目采用 [Apache 2.0 license](LICENSE) 开源许可证。
+
+## OpenMMLab 的其他项目
+
+- [MIM](https://github.com/open-mmlab/mim): MIM 是 OpenMMLab 项目、算法、模型的统一入口
+- [MMCV](https://github.com/open-mmlab/mmcv/tree/dev-2.x): OpenMMLab 计算机视觉基础库
+- [MMEval](https://github.com/open-mmlab/mmeval): 统一开放的跨框架算法评测库
+- [MMClassification](https://github.com/open-mmlab/mmclassification/tree/dev-1.x): OpenMMLab 图像分类工具箱
+- [MMDetection](https://github.com/open-mmlab/mmdetection/tree/dev-3.x): OpenMMLab 目标检测工具箱
+- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d/tree/dev-1.x): OpenMMLab 新一代通用 3D 目标检测平台
+- [MMRotate](https://github.com/open-mmlab/mmrotate/tree/dev-1.x): OpenMMLab 旋转框检测工具箱与测试基准
+- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO 系列工具箱与测试基准
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x): OpenMMLab 语义分割工具箱
+- [MMOCR](https://github.com/open-mmlab/mmocr/tree/dev-1.x): OpenMMLab 全流程文字检测识别理解工具包
+- [MMPose](https://github.com/open-mmlab/mmpose/tree/dev-1.x): OpenMMLab 姿态估计工具箱
+- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 人体参数化模型工具箱与测试基准
+- [MMSelfSup](https://github.com/open-mmlab/mmselfsup/tree/dev-1.x): OpenMMLab 自监督学习工具箱与测试基准
+- [MMRazor](https://github.com/open-mmlab/mmrazor/tree/dev-1.x): OpenMMLab 模型压缩工具箱与测试基准
+- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab 少样本学习工具箱与测试基准
+- [MMAction2](https://github.com/open-mmlab/mmaction2/tree/dev-1.x): OpenMMLab 新一代视频理解工具箱
+- [MMTracking](https://github.com/open-mmlab/mmtracking/tree/dev-1.x): OpenMMLab 一体化视频目标感知平台
+- [MMFlow](https://github.com/open-mmlab/mmflow/tree/dev-1.x): OpenMMLab 光流估计工具箱与测试基准
+- [MMEditing](https://github.com/open-mmlab/mmediting/tree/dev-1.x): OpenMMLab 图像视频编辑工具箱
+- [MMGeneration](https://github.com/open-mmlab/mmgeneration/tree/dev-1.x): OpenMMLab 图片视频生成模型工具箱
+- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab 模型部署框架
+
+## 欢迎加入 OpenMMLab 社区
+
+扫描下方的二维码可关注 OpenMMLab 团队的 [知乎官方账号](https://www.zhihu.com/people/openmmlab)，加入 OpenMMLab 团队的 [官方交流 QQ 群](https://jq.qq.com/?_wv=1027&k=K0QI8ByU)，或通过添加微信“Open小喵Lab”加入官方交流微信群。
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/58739961/187154320-f3312cdf-31f2-4316-9dbb-8d7b0e1b7e08.jpg" height="400" />  <img src="https://user-images.githubusercontent.com/25839884/203904835-62392033-02d4-4c73-a68c-c9e4c1e2b07f.jpg" height="400" />  <img src="https://user-images.githubusercontent.com/58739961/187151778-d17c1368-125f-4fde-adbe-38cc6eb3be98.jpg" height="400" />
+</div>
+
+我们会在 OpenMMLab 社区为大家
+
+- 📢 分享 AI 框架的前沿核心技术
+- 💻 解读 PyTorch 常用模块源码
+- 📰 发布 OpenMMLab 的相关新闻
+- 🚀 介绍 OpenMMLab 开发的前沿算法
+- 🏃 获取更高效的问题答疑和意见反馈
+- 🔥 提供与各行各业开发者充分交流的平台
+
+干货满满 📘，等你来撩 💗，OpenMMLab 社区期待您的加入 👬

testbed/open-mmlab__mmengine/docs/README.md

@@ -0,0 +1,28 @@
+## Build Documentation
+
+1. Clone MMEngine
+
+   ```bash
+   git clone https://github.com/open-mmlab/mmengine.git
+   cd mmengine
+   ```
+
+2. Install the building dependencies of documentation
+
+   ```bash
+   pip install -r requirements/docs.txt
+   ```
+
+3. Change directory to `docs/en` or `docs/zh_cn`
+
+   ```bash
+   cd docs/en  # or docs/zh_cn
+   ```
+
+4. Build documentation
+
+   ```bash
+   make html
+   ```
+
+5. Open `_build/html/index.html` with browser

testbed/open-mmlab__mmengine/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)

testbed/open-mmlab__mmengine/docs/en/conf.py

@@ -0,0 +1,100 @@
+# 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 sys
+
+import pytorch_sphinx_theme
+
+sys.path.insert(0, os.path.abspath('../..'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'mmengine'
+copyright = '2022, mmengine contributors'
+author = 'mmengine contributors'
+
+version_file = '../../mmengine/version.py'
+with open(version_file) as f:
+    exec(compile(f.read(), version_file, 'exec'))
+__version__ = locals()['__version__']
+# The short X.Y version
+version = __version__
+# The full version, including alpha/beta/rc tags
+release = __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.autosummary',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.autosectionlabel',
+    'myst_parser',
+    'sphinx_copybutton',
+    'sphinx.ext.autodoc.typehints',
+]  # yapf: disable
+autodoc_typehints = 'description'
+myst_heading_anchors = 4
+myst_enable_extensions = ['colon_fence']
+
+# Configuration for intersphinx
+intersphinx_mapping = {
+    'python': ('https://docs.python.org/3', None),
+    'numpy': ('https://numpy.org/doc/stable', None),
+    'torch': ('https://pytorch.org/docs/stable/', None),
+    'mmcv': ('https://mmcv.readthedocs.io/en/2.x/', None),
+}
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# 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 = 'pytorch_sphinx_theme'
+html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
+
+html_theme_options = {
+    'menu': [
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/open-mmlab/mmengine'
+        },
+    ],
+    # 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']
+
+# -- Extension configuration -------------------------------------------------
+# Ignore >>> when copying code
+copybutton_prompt_text = r'>>> |\.\.\. '
+copybutton_prompt_is_regexp = True

testbed/open-mmlab__mmengine/docs/en/docutils.conf

@@ -0,0 +1,2 @@
+[html writers]
+table_style: colwidths-auto

testbed/open-mmlab__mmengine/docs/en/get_started/installation.md

@@ -0,0 +1,75 @@
+# Installation
+
+## Prerequisites
+
+- Python 3.6+
+- PyTorch 1.6+
+- CUDA 9.2+
+- GCC 5.4+
+
+## Prepare the Environment
+
+1. Use conda and activate the environment:
+
+   ```bash
+   conda create -n open-mmlab python=3.7 -y
+   conda activate open-mmlab
+   ```
+
+2. Install PyTorch
+
+   Before installing `MMEngine`, please make sure that PyTorch has been successfully installed in the environment. You can refer to [PyTorch official installation documentation](https://pytorch.org/get-started/locally/#start-locally). Verify the installation with the following command:
+
+   ```bash
+   python -c 'import torch;print(torch.__version__)'
+   ```
+
+## Install MMEngine
+
+### Install with mim
+
+[mim](https://github.com/open-mmlab/mim) is a package management tool for OpenMMLab projects, which can be used to install the OpenMMLab project easily.
+
+```bash
+pip install -U openmim
+mim install mmengine
+```
+
+### Install with pip
+
+```bash
+pip install mmengine
+```
+
+### Use docker images
+
+1. Build the image
+
+   ```bash
+   docker build -t mmengine https://github.com/open-mmlab/mmengine.git#main:docker/release
+   ```
+
+   More information can be referred from [mmengine/docker](https://github.com/open-mmlab/mmengine/tree/main/docker).
+
+2. Run the image
+
+   ```bash
+   docker run --gpus all --shm-size=8g -it mmengine
+   ```
+
+#### Build from source
+
+```bash
+# if cloning speed is too slow, you can switch the source to https://gitee.com/open-mmlab/mmengine.git
+git clone https://github.com/open-mmlab/mmengine.git
+cd mmengine
+pip install -e . -v
+```
+
+### Verify the Installation
+
+To verify if `MMEngine` and the necessary environment are successfully installed, we can run this command:
+
+```bash
+python -c 'import mmengine;print(mmengine.__version__)'
+```

testbed/open-mmlab__mmengine/docs/en/index.rst

@@ -0,0 +1,110 @@
+Welcome to MMEngine's documentation!
+=========================================
+You can switch between Chinese and English documents in the lower-left corner of the layout.
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Get Started
+
+   get_started/introduction.md
+   get_started/installation.md
+   get_started/15_minutes.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Common Usage
+
+   examples/resume_training.md
+   examples/speed_up_training.md
+   examples/save_gpu_memory.md
+   examples/train_a_gan.md
+
+.. toctree::
+   :maxdepth: 3
+   :caption: Tutorials
+
+   tutorials/runner.md
+   tutorials/dataset.md
+   tutorials/model.md
+   tutorials/evaluation.md
+   tutorials/optim_wrapper.md
+   tutorials/param_scheduler.md
+   tutorials/hook.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Advanced tutorials
+
+   advanced_tutorials/registry.md
+   advanced_tutorials/config.md
+   advanced_tutorials/basedataset.md
+   advanced_tutorials/data_transform.md
+   advanced_tutorials/initialize.md
+   advanced_tutorials/visualization.md
+   advanced_tutorials/data_element.md
+   advanced_tutorials/distributed.md
+   advanced_tutorials/logging.md
+   advanced_tutorials/fileio.md
+   advanced_tutorials/manager_mixin.md
+   advanced_tutorials/cross_library.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Design
+
+   design/hook.md
+   design/runner.md
+   design/evaluation.md
+   design/visualization.md
+   design/logging.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Migration guide
+
+   migration/runner.md
+   migration/hook.md
+   migration/model.md
+   migration/param_scheduler.md
+   migration/transform.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API Reference
+
+   mmengine.registry <api/registry>
+   mmengine.config <api/config>
+   mmengine.runner <api/runner>
+   mmengine.hooks <api/hooks>
+   mmengine.model <api/model>
+   mmengine.optim <api/optim>
+   mmengine.evaluator <api/evaluator>
+   mmengine.structures <api/structures>
+   mmengine.dataset <api/dataset>
+   mmengine.device <api/device>
+   mmengine.hub <api/hub>
+   mmengine.logging <api/logging>
+   mmengine.visualization <api/visualization>
+   mmengine.fileio <api/fileio>
+   mmengine.dist <api/dist>
+   mmengine.utils <api/utils>
+   mmengine.utils.dl_utils <api/utils.dl_utils>
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Notes
+
+   notes/changelog.md
+   notes/contributing.md
+
+.. toctree::
+   :caption: Switch Language
+
+   switch_language.md
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

testbed/open-mmlab__mmengine/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

testbed/open-mmlab__mmengine/docs/en/migration/hook.md

@@ -0,0 +1,3 @@
+# Migrate Hook from MMCV to MMEngine
+
+Coming soon. Please refer to [chinese documentation](https://mmengine.readthedocs.io/zh_CN/latest/migration/hook.html).

testbed/open-mmlab__mmengine/docs/en/notes/contributing.md

@@ -0,0 +1,242 @@
+## Contributing to OpenMMLab
+
+Welcome to the MMEngine community, we are committed to building a cutting-edge computer vision foundational library and all kinds of contributions are welcomed, including but not limited to
+
+**Fix bug**
+
+You can directly post a Pull Request to fix typos in code or documents
+
+The steps to fix the bug of code implementation are as follows.
+
+1. If the modification involves significant changes, you should create an issue first and describe the error information and how to trigger the bug. Other developers will discuss it with you and propose a proper solution.
+
+2. Posting a pull request after fixing the bug and adding the corresponding unit test.
+
+**New Feature or Enhancement**
+
+1. If the modification involves significant changes, you should create an issue to discuss with our developers to propose a proper design.
+2. Post a Pull Request after implementing the new feature or enhancement and add the corresponding unit test.
+
+**Document**
+
+You can directly post a pull request to fix documents. If you want to add a document, you should first create an issue to check if it is reasonable.
+
+### Pull Request Workflow
+
+If you're not familiar with Pull Request, don't worry! The following guidance will tell you how to create a Pull Request step by step. If you want to dive into the development mode of Pull Request, you can refer to the [official documents](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests).
+
+#### 1. Fork and clone
+
+If you are posting a pull request for the first time, you should fork the OpenMMLab repositories by clicking the **Fork** button in the top right corner of the GitHub page, and the forked repositories will appear under your GitHub profile.
+
+<img src="https://user-images.githubusercontent.com/57566630/167305749-43c7f4e9-449b-4e98-ade5-0c9276d5c9ce.png" width="1200">
+
+Then, you can clone the repositories to local:
+
+```shell
+git clone git@github.com:{username}/mmengine.git
+```
+
+After that, you should add the official repository as the upstream repository.
+
+```bash
+git remote add upstream git@github.com:open-mmlab/mmengine
+```
+
+Check whether the remote repository has been added successfully by `git remote -v`.
+
+```bash
+origin	git@github.com:{username}/mmengine.git (fetch)
+origin	git@github.com:{username}/mmengine.git (push)
+upstream	git@github.com:open-mmlab/mmengine (fetch)
+upstream	git@github.com:open-mmlab/mmengine (push)
+```
+
+```{note}
+Here's a brief introduction to origin and upstream. When we use "git clone", we create an "origin" remote by default, which points to the repository cloned from. As for "upstream", we add it ourselves to point to the target repository. Of course, if you don't like the name "upstream", you could name it as you wish. Usually, we'll push the code to "origin". If the pushed code conflicts with the latest code in official("upstream"), we should pull the latest code from upstream to resolve the conflicts, and then push to "origin" again. The posted Pull Request will be updated automatically.
+```
+
+#### 2. Configure pre-commit
+
+You should configure [pre-commit](https://pre-commit.com/#intro) in the local development environment to make sure the code style matches that of OpenMMLab. **Note**: The following code should be executed under the mmengine directory.
+
+```shell
+pip install -U pre-commit
+pre-commit install
+```
+
+Check that pre-commit is configured successfully, and install the hooks defined in `.pre-commit-config.yaml`.
+
+```shell
+pre-commit run --all-files
+```
+
+<img src="https://user-images.githubusercontent.com/57566630/173660750-3df20a63-cb66-4d33-a986-1f643f1d8aaf.png" width="1200">
+
+<img src="https://user-images.githubusercontent.com/57566630/202368856-0465a90d-8fce-4345-918e-67b8b9c82614.png" width="1200">
+
+If the installation process is interrupted, you can repeatedly run `pre-commit run ... ` to continue the installation.
+
+If the code does not conform to the code style specification, pre-commit will raise a warning and  fixes some of the errors automatically.
+
+<img src="https://user-images.githubusercontent.com/57566630/202369176-67642454-0025-4023-a095-263529107aa3.png" width="1200">
+
+If we want to commit our code bypassing the pre-commit hook, we can use the `--no-verify` option(**only for temporary committing**).
+
+```shell
+git commit -m "xxx" --no-verify
+```
+
+#### 3. Create a development branch
+
+After configuring the pre-commit, we should create a branch based on the master branch to develop the new feature or fix the bug. The proposed branch name is `username/pr_name`
+
+```shell
+git checkout -b yhc/refactor_contributing_doc
+```
+
+In subsequent development, if the master branch of the local repository is behind the master branch of "upstream", we need to pull the upstream for synchronization, and then execute the above command:
+
+```shell
+git pull upstream master
+```
+
+#### 4. Commit the code and pass the unit test
+
+- MMEngine introduces mypy to do static type checking to increase the robustness of the code. Therefore, we need to add Type Hints to our code and pass the mypy check. If you are not familiar with Type Hints, you can refer to [this tutorial](https://docs.python.org/3/library/typing.html).
+
+- The committed code should pass through the unit test
+
+  ```shell
+  # Pass all unit tests
+  pytest tests
+
+  # Pass the unit test of runner
+  pytest tests/test_runner/test_runner.py
+  ```
+
+  If the unit test fails for lack of dependencies, you can install the dependencies referring to the [guidance](#unit-test)
+
+- If the documents are modified/added, we should check the rendering result referring to [guidance](#document-rendering)
+
+#### 5. Push the code to remote
+
+We could push the local commits to remote after passing through the check of unit test and pre-commit. You can associate the local branch with remote branch by adding `-u` option.
+
+```shell
+git push -u origin {branch_name}
+```
+
+This will allow you to use the `git push` command to push code directly next time, without having to specify a branch or the remote repository.
+
+#### 6. Create a Pull Request
+
+(1) Create a pull request in GitHub's Pull request interface
+
+<img src="https://user-images.githubusercontent.com/57566630/201533288-516f7ac4-0b14-4dc8-afbd-912475c368b5.png" width="1200">
+
+(2) Modify the PR description according to the guidelines so that other developers can better understand your changes
+
+<img src="https://user-images.githubusercontent.com/57566630/202242953-c91a18ff-e388-4ff9-8591-5fae0ead6c1e.png" width="1200">
+
+Find more details about Pull Request description in [pull request guidelines](#pr-specs).
+
+**note**
+
+(a) The Pull Request description should contain the reason for the change, the content of the change, and the impact of the change, and be associated with the relevant Issue (see [documentation](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)
+
+(b) If it is your first contribution, please sign the CLA
+
+<img src="https://user-images.githubusercontent.com/57566630/167307569-a794b967-6e28-4eac-a942-00deb657815f.png" width="1200">
+
+(c) Check whether the Pull Request pass through the CI
+
+<img src="https://user-images.githubusercontent.com/57566630/167307490-f9ebf9fa-63c0-4d83-8ba1-081ea169eb3a.png" width="1200">
+
+MMEngine will run unit test for the posted Pull Request on different platforms (Linux, Window, Mac), based on different versions of Python, PyTorch, CUDA to make sure the code is correct. We can see the specific test information by clicking `Details` in the above image so that we can modify the code.
+
+(3) If the Pull Request passes the CI, then you can wait for the review from other developers. You'll modify the code based on the reviewer's comments, and repeat the steps [4](#4-commit-the-code-and-pass-the-unit-test)-[5](#5-push-the-code-to-remote) until all reviewers approve it. Then, we will merge it ASAP.
+
+<img src="https://user-images.githubusercontent.com/57566630/202145400-cc2cd8c4-10b0-472f-ba37-07e6f50acc67.png" width="1200">
+
+#### 7. Resolve conflicts
+
+If your local branch conflicts with the latest master branch of "upstream", you'll need to resolove them. There are two ways to do this:
+
+```shell
+git fetch --all --prune
+git rebase upstream/master
+```
+
+or
+
+```shell
+git fetch --all --prune
+git merge upstream/master
+```
+
+If you are very good at handling conflicts, then you can use rebase to resolve conflicts, as this will keep your commit logs tidy. If you are not familiar with `rebase`, then you can use `merge` to resolve conflicts.
+
+### Guidance
+
+#### Unit test
+
+We should also make sure the committed code will not decrease the coverage of unit test, we could run the following command to check the coverage of unit test:
+
+```shell
+python -m coverage run -m pytest /path/to/test_file
+python -m coverage html
+# check file in htmlcov/index.html
+```
+
+#### Document rendering
+
+If the documents are modified/added, we should check the rendering result. We could install the dependencies and run the following command to render the documents and check the results:
+
+```shell
+pip install -r requirements/docs.txt
+cd docs/zh_cn/
+# or docs/en
+make html
+# check file in ./docs/zh_cn/_build/html/index.html
+```
+
+### Python Code style
+
+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).
+
+### PR Specs
+
+1. Use [pre-commit](https://pre-commit.com) hook to avoid issues of code style
+
+2. One short-time branch should be matched with only one PR
+
+3. Accomplish a detailed change in one PR. Avoid large PR
+
+   - Bad: Support Faster R-CNN
+   - Acceptable: Add a box head to Faster R-CNN
+   - Good: Add a parameter to box head to support custom conv-layer number
+
+4. Provide clear and significant commit message
+
+5. Provide clear and meaningful PR description
+
+   - Task name should be clarified in title. The general format is: \[Prefix\] Short description of the PR (Suffix)
+   - Prefix: add new feature \[Feature\], fix bug \[Fix\], related to documents \[Docs\], in developing \[WIP\] (which will not be reviewed temporarily)
+   - Introduce main changes, results and influences on other modules in short description
+   - Associate related issues and pull requests with a milestone

testbed/open-mmlab__mmengine/docs/en/switch_language.md

@@ -0,0 +1,3 @@
+## <a href='https://mmengine.readthedocs.io/en/latest/'>English</a>
+
+## <a href='https://mmengine.readthedocs.io/zh_CN/latest/'>简体中文</a>

testbed/open-mmlab__mmengine/docs/en/tutorials/dataset.md

@@ -0,0 +1,200 @@
+# Dataset and DataLoader
+
+```{hint}
+If you have never been exposed to PyTorch's Dataset and DataLoader classes, you are recommended to read through [PyTorch official tutorial](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html) to get familiar with some basic concepts.
+```
+
+Datasets and DataLoaders are necessary components in MMEngine's training pipeline. They are conceptually derived from and consistent with PyTorch. Typically, a dataset defines the quantity, parsing, and pre-processing of the data, while a dataloader iteratively loads data according to settings such as `batch_size`, `shuffle`, `num_workers`, etc. Datasets are encapsulated with dataloaders and they together constitute the data source.
+
+In this tutorial, we will step through their usage in MMEngine runner from the outside (dataloader) to the inside (dataset) and give some practical examples. After reading through this tutorial, you will be able to:
+
+- Master the configuration of dataloaders in MMEngine
+- Learn to use existing datasets (e.g. those from `torchvision`) from config files
+- Know about building and using your own dataset
+
+## Details on dataloader
+
+Dataloaders can be configured in MMEngine's `Runner` with 3 arguments:
+
+- `train_dataloader`: Used in `Runner.train()` to provide training data for models
+- `val_dataloader`: Used in `Runner.val()` or in `Runner.train()` at regular intervals for model evaluation
+- `test_dataloader`: Used in `Runner.test()` for the final test
+
+MMEngine has full support for PyTorch native `DataLoader` objects. Therefore, you can simply pass your valid, already built dataloaders to the runner, as shown in [getting started in 15 minutes](../get_started/15_minutes.md). Meanwhile, thanks to the [Registry Mechanism](../advanced_tutorials/registry.md) of MMEngine, those arguments also accept `dict`s as inputs, as illustrated in the following example (referred to as example 1). The keys in the dictionary correspond to arguments in DataLoader's init function.
+
+```python
+runner = Runner(
+    train_dataloader=dict(
+        batch_size=32,
+        sampler=dict(
+            type='DefaultSampler',
+            shuffle=True),
+        dataset=torchvision.datasets.CIFAR10(...),
+        collate_fn=dict(type='default_collate')
+    )
+)
+```
+
+When passed to the runner in the form of a dict, the dataloader will be lazily built in the runner when actually needed.
+
+```{note}
+For more configurable arguments of the `DataLoader`, please refer to [PyTorch API documentation](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)
+```
+
+```{note}
+If you are interested in the details of the building procedure, you may refer to [build_dataloader](mmengine.runner.Runner.build_dataloader)
+```
+
+You may find example 1 differs from that in [getting started in 15 minutes](../get_started/15_minutes.md) in some arguments. Indeed, due to some obscure conventions in MMEngine, you can't seamlessly switch it to a dict by simply replacing `DataLoader` with `dict`. We will discuss the differences between our convention and PyTorch's in the following sections, in case you run into trouble when using config files.
+
+### sampler and shuffle
+
+One obvious difference is that we add a `sampler` argument to the dict. This is because we **require `sampler` to be explicitly specified** when using a dict as a dataloader. Meanwhile, `shuffle` is also removed from `DataLoader` arguments, because it conflicts with `sampler` in PyTorch, as referred to in [PyTorch DataLoader API documentation](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader).
+
+```{note}
+In fact, `shuffle` is just a notation for convenience in PyTorch implementation. If `shuffle` is set to `True`, the dataloader will automatically switch to `RandomSampler`
+```
+
+With a `sampler` argument, codes in example 1 is **nearly** equivalent to code block below
+
+```python
+from mmengine.dataset import DefaultSampler
+
+dataset = torchvision.datasets.CIFAR10(...)
+sampler = DefaultSampler(dataset, shuffle=True)
+
+runner = Runner(
+    train_dataloader=DataLoader(
+        batch_size=32,
+        sampler=sampler,
+        dataset=dataset,
+        collate_fn=default_collate
+    )
+)
+```
+
+```{warning}
+The equivalence of the above codes holds only if: 1) you are training with a single process, and 2) no `randomness` argument is passed to the runner. This is due to the fact that `sampler` should be built after distributed environment setup to be correct. The runner will guarantee the correct order and proper random seed by applying lazy initialization techniques, which is only possible for dict inputs. Instead, when building a sampler manually, it requires extra work and is highly error-prone. Therefore, the code block above is just for illustration and definitely not recommended. We **strongly suggest passing `sampler` as a `dict`** to avoid potential problems.
+```
+
+### DefaultSampler
+
+The above example may make you wonder what a `DefaultSampler` is, why use it and whether there are other options. In fact, `DefaultSampler` is a built-in sampler in MMEngine which eliminates the gap between distributed and non-distributed training and thus enabling a seamless conversion between them. If you have the experience of using `DistributedDataParallel` in PyTorch, you may be impressed by having to change the `sampler` argument to make it correct. However, in MMEngine, you don't need to bother with this `DefaultSampler`.
+
+`DefaultSampler` accepts the following arguments:
+
+- `shuffle`: Set to `True` to load data in the dataset in random order
+- `seed`: Random seed used to shuffle the dataset. Typically it doesn't require manual configuration here because the runner will handle it with `randomness` configuration
+- `round_up`: When set this to `True`, this is the same behavior as setting `drop_last=False` in PyTorch `DataLoader`. You should take care of it when doing migration from PyTorch.
+
+```{note}
+For more details about `DefaultSampler`, please refer to [its API docs](mmengine.dataset.DefaultSampler)
+```
+
+`DefaultSampler` handles most of the cases. We ensure that error-prone details such as random seeds are handled properly when you are using it in a runner. This prevents you from getting into troubles with distributed training. Apart from `DefaultSampler`, you may also be interested in [InfiniteSampler](mmengine.dataset.InfiniteSampler) for iteration-based training pipelines. If you have more advanced demands, you may want to refer to the codes of these two built-in samplers to implement your own one and register it to `DATA_SAMPLERS` registry.
+
+```python
+@DATA_SAMPLERS.register_module()
+class MySampler(Sampler):
+    pass
+
+runner = Runner(
+    train_dataloader=dict(
+        sampler=dict(type='MySampler'),
+        ...
+    )
+)
+```
+
+### The obscure collate_fn
+
+Among the arguments of PyTorch `DataLoader`, `collate_fn` is often ignored by users, but in MMEngine you must pay special attention to it. When you pass the dataloader argument as a dict, MMEngine will use the built-in [pseudo_collate](mmengine.dataset.pseudo_collate) by default, which is significantly different from that, [default_collate](https://pytorch.org/docs/stable/data.html#torch.utils.data.default_collate), in PyTorch. Therefore, when doing a migration from PyTorch, you have to explicitly specify the `collate_fn` in config files to be consistent in behavior.
+
+```{note}
+MMEngine uses `pseudo_collate` as default value is mainly due to historical compatibility reasons. You don't have to look deeply into it. You can just know about it and avoid potential errors.
+```
+
+MMEngine provides 2 built-in `collate_fn`:
+
+- `pseudo_collate`: Default value in MMEngine. It won't concatenate data through `batch` index. Detailed explanations can be found in [pseudo_collate API doc](mmengine.dataset.pseudo_collate)
+- `default_collate`: It behaves almost identically to PyTorch's `default_collate`. It will transfer data into `Tensor` and concatenate them through `batch` index. More details and slight differences from PyTorch can be found in [default_collate API doc](mmengine.dataset.default_collate)
+
+If you want to use a custom `collate_fn`, you can register it to `COLLATE_FUNCTIONS` registry.
+
+```python
+@COLLATE_FUNCTIONS.register_module()
+def my_collate_func(data_batch: Sequence) -> Any:
+    pass
+
+runner = Runner(
+    train_dataloader=dict(
+        ...
+        collate_fn=dict(type='my_collate_func')
+    )
+)
+```
+
+## Details on dataset
+
+Typically, datasets define the quantity, parsing, and pre-processing of the data. It is encapsulated in dataloader, allowing the latter to load data in batches. Since we fully support PyTorch `DataLoader`, the dataset is also compatible. Meanwhile, thanks to the registry mechanism, when a dataloader is given as a dict, its `dataset` argument can also be given as a dict, which enables lazy initialization in the runner. This mechanism allows for writing config files.
+
+### Use torchvision datasets
+
+`torchvision` provides various open datasets. They can be directly used in MMEngine as shown in [getting started in 15 minutes](../get_started/15_minutes.md), where a `CIFAR10` dataset is used together with torchvision's built-in data transforms.
+
+However, if you want to use the dataset in config files, registration is needed. What's more, if you also require data transforms in torchvision, some more registrations are required. The following example illustrates how to do it.
+
+```python
+import torchvision.transforms as tvt
+from mmengine.registry import DATASETS, TRANSFORMS
+from mmengine.dataset.base_dataset import Compose
+
+# register CIFAR10 dataset in torchvision
+# data transforms should also be built here
+@DATASETS.register_module(name='Cifar10', force=False)
+def build_torchvision_cifar10(transform=None, **kwargs):
+    if isinstance(transform, dict):
+        transform = [transform]
+    if isinstance(transform, (list, tuple)):
+        transform = Compose(transform)
+    return torchvision.datasets.CIFAR10(**kwargs, transform=transform)
+
+# register data transforms in torchvision
+DATA_TRANSFORMS.register_module('RandomCrop', module=tvt.RandomCrop)
+DATA_TRANSFORMS.register_module('RandomHorizontalFlip', module=tvt.RandomHorizontalFlip)
+DATA_TRANSFORMS.register_module('ToTensor', module=tvt.ToTensor)
+DATA_TRANSFORMS.register_module('Normalize', module=tvt.Normalize)
+
+# specify in runner
+runner = Runner(
+    train_dataloader=dict(
+        batch_size=32,
+        sampler=dict(
+            type='DefaultSampler',
+            shuffle=True),
+        dataset=dict(type='Cifar10',
+            root='data/cifar10',
+            train=True,
+            download=True,
+            transform=[
+                dict(type='RandomCrop', size=32, padding=4),
+                dict(type='RandomHorizontalFlip'),
+                dict(type='ToTensor'),
+                dict(type='Normalize', **norm_cfg)])
+    )
+)
+```
+
+```{note}
+The above example makes extensive use of the registry mechanism and borrows the [Compose](mmengine.dataset.Compose) module from MMEngine. If you urge to use torchvision dataset in your config files, you can refer to it and make some slight modifications. However, we recommend you borrow datasets from downstream repos such as [MMDet](https://github.com/open-mmlab/mmdetection), [MMCls](https://github.com/open-mmlab/mmclassification), etc. This may give you a better experience.
+```
+
+### Customize your dataset
+
+You are free to customize your own datasets, as you would with PyTorch. You can also copy existing datasets from your previous PyTorch projects. If you want to learn how to customize your dataset, please refer to [PyTorch official tutorials](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html#creating-a-custom-dataset-for-your-files)
+
+### Use MMEngine BaseDataset
+
+Apart from directly using PyTorch native `Dataset` class, you can also use MMEngine's built-in class `BaseDataset` to customize your own one, as referred to [BaseDataset tutorial](../advanced_tutorials/basedataset.md). It makes some conventions on the format of annotation files, which makes the data interface more unified and multi-task training more convenient. Meanwhile, `BaseDataset` can easily cooperate with built-in [data transforms](../advanced_tutorials/data_element.md) in MMEngine, which releases you from writing one from scratch.
+
+Currently, `BaseDataset` has been widely used in downstream repos of OpenMMLab 2.0 projects.

testbed/open-mmlab__mmengine/docs/en/tutorials/evaluation.md

@@ -0,0 +1,3 @@
+# Evaluation
+
+Coming soon. Please refer to [chinese documentation](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/evaluation.html).

testbed/open-mmlab__mmengine/docs/en/tutorials/param_scheduler.md

@@ -0,0 +1,229 @@
+# Parameter Scheduler
+
+During neural network training, optimization hyperparameters (e.g. learning rate) are usually adjusted along with the training process.
+One of the simplest and most common learning rate adjustment strategies is multi-step learning rate decay, which reduces the learning rate to a fraction at regular intervals.
+PyTorch provides LRScheduler to implement various learning rate adjustment strategies. In MMEngine, we have extended it and implemented a more general [ParamScheduler](mmengine.optim._ParamScheduler).
+It can adjust optimization hyperparameters such as learning rate and momentum. It also supports the combination of multiple schedulers to create more complex scheduling strategies.
+
+## Usage
+
+We first introduce how to use PyTorch's `torch.optim.lr_scheduler` to adjust learning rate.
+
+<details>
+<summary>How to use PyTorch's builtin learning rate scheduler?</summary>
+
+Here is an example which refers from [PyTorch official documentation](https://pytorch.org/docs/stable/optim.html):
+
+Initialize an ExponentialLR object, and call the `step` method after each training epoch.
+
+```python
+import torch
+from torch.optim import SGD
+from torch.optim.lr_scheduler import ExponentialLR
+
+model = torch.nn.Linear(1, 1)
+dataset = [torch.randn((1, 1, 1)) for _ in range(20)]
+optimizer = SGD(model, 0.1)
+scheduler = ExponentialLR(optimizer, gamma=0.9)
+
+for epoch in range(10):
+    for data in dataset:
+        optimizer.zero_grad()
+        output = model(data)
+        loss = 1 - output
+        loss.backward()
+        optimizer.step()
+    scheduler.step()
+```
+
+</details>
+
+`mmengine.optim.scheduler` supports most of PyTorch's learning rate schedulers such as `ExponentialLR`, `LinearLR`, `StepLR`, `MultiStepLR`, etc. Please refer to [parameter scheduler API documentation](https://mmengine.readthedocs.io/en/latest/api/optim.html#scheduler) for all of the supported schedulers.
+
+MMEngine also supports adjusting momentum with parameter schedulers. To use momentum schedulers, replace `LR` in the class name to `Momentum`, such as `ExponentialMomentum`，`LinearMomentum`. Further, we implement the general parameter scheduler ParamScheduler, which is used to adjust the specified hyperparameters in the optimizer, such as weight_decay, etc. This feature makes it easier to apply some complex hyperparameter tuning strategies.
+
+Different from the above example, MMEngine usually does not need to manually implement the training loop and call `optimizer.step()`. The runner will automatically manage the training progress and control the execution of the parameter scheduler through `ParamSchedulerHook`.
+
+### Use a single LRScheduler
+
+If only one scheduler needs to be used for the entire training process, there is no difference with PyTorch's learning rate scheduler.
+
+```python
+# build the scheduler manually
+from torch.optim import SGD
+from mmengine.runner import Runner
+from mmengine.optim.scheduler import MultiStepLR
+
+optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
+param_scheduler = MultiStepLR(optimizer, milestones=[8, 11], gamma=0.1)
+
+runner = Runner(
+    model=model,
+    optim_wrapper=dict(
+        optimizer=optimizer),
+    param_scheduler=param_scheduler,
+    ...
+    )
+```
+
+![image](https://user-images.githubusercontent.com/12907710/185112707-356e1c20-d104-45b6-954c-55d552aab7ac.png)
+
+If using the runner with the registry and config file, we can specify the scheduler by setting the `param_scheduler` field in the config. The runner will automatically build a parameter scheduler based on this field:
+
+```python
+# build the scheduler with config file
+param_scheduler = dict(type='MultiStepLR', by_epoch=True, milestones=[8, 11], gamma=0.1)
+```
+
+Note that the parameter `by_epoch` is added here, which controls the frequency of learning rate adjustment. When set to True, it means adjusting by epoch. When set to False, it means adjusting by iteration. The default value is True.
+
+In the above example, it means to adjust according to epochs. At this time, the unit of the parameters is epoch. For example, \[8, 11\] in `milestones` means that the learning rate will be multiplied by 0.1 at the end of the 8 and 11 epoch.
+
+When the frequency is modified, the meaning of the count-related settings of the scheduler will be changed accordingly. When `by_epoch=True`, the numbers in milestones indicate at which epoch the learning rate decay is performed, and when `by_epoch=False` it indicates at which iteration the learning rate decay is performed.
+
+Here is an example of adjusting by iterations: At the end of the 600th and 800th iterations, the learning rate will be multiplied by 0.1 times.
+
+```python
+param_scheduler = dict(type='MultiStepLR', by_epoch=False, milestones=[600, 800], gamma=0.1)
+```
+
+![image](https://user-images.githubusercontent.com/12907710/185112891-381b9fb6-cf00-42b8-8dcd-6fb636450c4d.png)
+
+If users want to use the iteration-based frequency while filling the scheduler config settings by epoch, MMEngine's scheduler also provides an automatic conversion method. Users can call the `build_iter_from_epoch` method and provide the number of iterations for each training epoch to construct a scheduler object updated by iterations:
+
+```python
+epoch_length = len(train_dataloader)
+param_scheduler = MultiStepLR.build_iter_from_epoch(optimizer, milestones=[8, 11], gamma=0.1, epoch_length=epoch_length)
+```
+
+If using config to build a scheduler, just add `convert_to_iter_based=True` to the field. The runner will automatically call `build_iter_from_epoch` to convert the epoch-based config to an iteration-based scheduler object:
+
+```python
+param_scheduler = dict(type='MultiStepLR', by_epoch=True, milestones=[8, 11], gamma=0.1, convert_to_iter_based=True)
+```
+
+Below is a Cosine Annealing learning rate scheduler that is updated by epoch, where the learning rate is only modified after each epoch:
+
+```python
+param_scheduler = dict(type='CosineAnnealingLR', by_epoch=True, T_max=12)
+```
+
+![image](https://user-images.githubusercontent.com/12907710/185115307-69e75a6e-0712-4770-bd41-b0290b03480c.png)
+
+After automatically conversion, the learning rate is updated by iteration. As you can see from the graph below, the learning rate changes more smoothly.
+
+```python
+param_scheduler = dict(type='CosineAnnealingLR', by_epoch=True, T_max=12, convert_to_iter_based=True)
+```
+
+![image](https://user-images.githubusercontent.com/12907710/185115509-d4f2156a-d940-44b7-801f-3023ab76a2d3.png)
+
+### Combine multiple LRSchedulers (e.g. learning rate warm-up)
+
+In the training process of some algorithms, the learning rate is not adjusted according to a certain scheduling strategy from beginning to end. The most common example is learning rate warm-up.
+
+For example, in the first few iterations, a linear strategy is used to increase the learning rate from a small value to normal, and then another strategy is applied.
+
+MMEngine supports combining multiple schedulers together. Just modify the `param_scheduler` field in the config file to a list of scheduler config, and the ParamSchedulerHook can automatically process the scheduler list. The following example implements learning rate warm-up.
+
+```python
+param_scheduler = [
+    # Linear learning rate warm-up scheduler
+    dict(type='LinearLR',
+         start_factor=0.001,
+         by_epoch=False,  # Updated by iterations
+         begin=0,
+         end=50),  # Warm up for the first 50 iterations
+    # The main LRScheduler
+    dict(type='MultiStepLR',
+         by_epoch=True,  # Updated by epochs
+         milestones=[8, 11],
+         gamma=0.1)
+]
+```
+
+![image](https://user-images.githubusercontent.com/12907710/185116161-0822f605-e7f5-4917-8432-5d6c398e2f31.png)
+
+Note that the `begin` and `end` parameters are added here. These two parameters specify the **valid interval** of the scheduler. The valid interval usually only needs to be set when multiple schedulers are combined, and can be ignored when using a single scheduler. When the `begin` and `end` parameters are specified, it means that the scheduler only takes effect in the \[begin, end) interval, and the unit is determined by the `by_epoch` parameter.
+
+In the above example, the `by_epoch` of `LinearLR` in the warm-up phase is False, which means that the scheduler only takes effect in the first 50 iterations. After more than 50 iterations, the scheduler will no longer take effect, and the second scheduler, which is `MultiStepLR`, will control the learning rate. When combining different schedulers, the `by_epoch` parameter does not have to be the same for each scheduler.
+
+Here is another example：
+
+```python
+param_scheduler = [
+    # Use a linear warm-up at [0, 100) iterations
+    dict(type='LinearLR',
+         start_factor=0.001,
+         by_epoch=False,
+         begin=0,
+         end=100),
+    # Use a cosine learning rate at [100, 900) iterations
+    dict(type='CosineAnnealingLR',
+         T_max=800,
+         by_epoch=False,
+         begin=100,
+         end=900)
+]
+```
+
+![image](https://user-images.githubusercontent.com/12907710/185116507-660aa0f5-448f-4d9c-a136-0cd647c58564.png)
+
+The above example uses a linear learning rate warm-up for the first 100 iterations, and then uses a cosine annealing learning rate scheduler with a period of 800 from the 100th to the 900th iteration.
+
+Users can combine any number of schedulers. If the valid intervals of two schedulers are not connected to each other which leads to an interval that is not covered, the learning rate of this interval remains unchanged. If the valid intervals of the two schedulers overlap, the adjustment of the learning rate will be triggered in the order of the scheduler config (similar with [`ChainedScheduler`](https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.ChainedScheduler.html#chainedscheduler)).
+
+We recommend using different learning rate scheduling strategies in different stages of training to avoid overlapping of the valid intervals. Be careful If you really need to stack two schedulers overlapped. We recommend using [learning rate visualization tool](TODO) to visualize the learning rate after stacking, to avoid the adjustment not as expected.
+
+## How to adjust other hyperparameters
+
+### Momentum
+
+Like learning rate, momentum is a schedulable hyperparameter in the optimizer's parameter group. The momentum scheduler is used in exactly the same way as the learning rate scheduler. Just add the momentum scheduler config to the list in the `param_scheduler` field.
+
+Example:
+
+```python
+param_scheduler = [
+    # the lr scheduler
+    dict(type='LinearLR', ...),
+    # the momentum scheduler
+    dict(type='LinearMomentum',
+         start_factor=0.001,
+         by_epoch=False,
+         begin=0,
+         end=1000)
+]
+```
+
+### Generic parameter scheduler
+
+MMEngine also provides a set of generic parameter schedulers for scheduling other hyperparameters in the `param_groups` of the optimizer. Change `LR` in the class name of the learning rate scheduler to `Param`, such as `LinearParamScheduler`. Users can schedule the specific hyperparameters by setting the `param_name` variable of the scheduler.
+
+Here is an example：
+
+```python
+param_scheduler = [
+    dict(type='LinearParamScheduler',
+         param_name='lr',  # adjust the 'lr' in `optimizer.param_groups`
+         start_factor=0.001,
+         by_epoch=False,
+         begin=0,
+         end=1000)
+]
+```
+
+By setting the `param_name` to `'lr'`, this parameter scheduler is equivalent to `LinearLRScheduler`.
+
+In addition to learning rate and momentum, users can also schedule other parameters in `optimizer.param_groups`. The schedulable parameters depend on the optimizer used. For example, when using the SGD optimizer with `weight_decay`, the `weight_decay` can be adjusted as follows:
+
+```python
+param_scheduler = [
+    dict(type='LinearParamScheduler',
+         param_name='weight_decay',  # adjust 'weight_decay' in `optimizer.param_groups`
+         start_factor=0.001,
+         by_epoch=False,
+         begin=0,
+         end=1000)
+]
+```

testbed/open-mmlab__mmengine/docs/en/tutorials/runner.md

@@ -0,0 +1,523 @@
+# Runner
+
+Welcome to the tutorial of runner, the core of MMEngine's user interface!
+
+The runner, as an "integrator" in MMEngine, covers all aspects of the framework and shoulders the responsibility of organizing and scheduling nearly all modules. Therefore, the code logic in it has to take into account various situations, making it relatively hard to understand. But **don't worry**! In this tutorial, we will leave out some messy details and have a quick overview of commonly used APIs, functionalities, and examples. Hopefully, this should provide you with a clear and easy-to-understand user interface. After reading through this tutorial, you will be able to:
+
+- Master the common usage and configuration of the runner
+- Learn the best practice - writing config files - of the runner
+- Know about the basic dataflow and execution order
+- Feel by yourself the advantages of using runner (perhaps)
+
+## Example codes of the runner
+
+To build your training pipeline with a runner, there are typically two ways to get started:
+
+- Refer to runner's [API documentation](mmengine.runner.Runner) for argument-by-argument configuration
+- Make your custom modifications based on some existing configurations, such as [Getting started in 15 minutes](../get_started/15_minutes.md) and downstream repositories like [MMDet](https://github.com/open-mmlab/mmdetection)
+
+Pros and cons lie in both approaches. For the former one, beginners may be lost in a vast number of configurable arguments. For the latter one, beginners may find it hard to get a good reference, since neither an over-simplified nor an over-detailed reference is conducive to them.
+
+We argue that the key to learning runner is using it as a memo. You should remember its most commonly used arguments and only focus on those less used when in need, since default values usually work fine. In the following, we will provide a beginner-friendly example to illustrate the most commonly used arguments of the runner, along with advanced guidelines for those less used.
+
+### A beginer-friendly example
+
+```{hint}
+In this tutorial, we hope you can focus more on overall architecture instead of implementation details. This "top-down" way of thinking is exactly what we advocate. Don't worry, you will definitely have plenty of opportunities and guidance afterward to focus on modules you want to improve.
+```
+
+<details>
+<summary>Before running the actual example below, you should first run this piece of code for the preparation of the model, dataset, and metric. However, these implementations are not important in this tutorial and you can simply look through</summary>
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+
+from mmengine.model import BaseModel
+from mmengine.evaluator import BaseMetric
+from mmengine.registry import MODELS, DATASETS, METRICS
+
+
+@MODELS.register_module()
+class MyAwesomeModel(BaseModel):
+    def __init__(self, layers=4, activation='relu') -> None:
+        super().__init__()
+        if activation == 'relu':
+            act_type = nn.ReLU
+        elif activation == 'silu':
+            act_type = nn.SiLU
+        elif activation == 'none':
+            act_type = nn.Identity
+        else:
+            raise NotImplementedError
+        sequence = [nn.Linear(2, 64), act_type()]
+        for _ in range(layers-1):
+            sequence.extend([nn.Linear(64, 64), act_type()])
+        self.mlp = nn.Sequential(*sequence)
+        self.classifier = nn.Linear(64, 2)
+
+    def forward(self, data, labels, mode):
+        x = self.mlp(data)
+        x = self.classifier(x)
+        if mode == 'tensor':
+            return x
+        elif mode == 'predict':
+            return F.softmax(x, dim=1), labels
+        elif mode == 'loss':
+            return {'loss': F.cross_entropy(x, labels)}
+
+
+@DATASETS.register_module()
+class MyDataset(Dataset):
+    def __init__(self, is_train, size):
+        self.is_train = is_train
+        if self.is_train:
+            torch.manual_seed(0)
+            self.labels = torch.randint(0, 2, (size,))
+        else:
+            torch.manual_seed(3407)
+            self.labels = torch.randint(0, 2, (size,))
+        r = 3 * (self.labels+1) + torch.randn(self.labels.shape)
+        theta = torch.rand(self.labels.shape) * 2 * torch.pi
+        self.data = torch.vstack([r*torch.cos(theta), r*torch.sin(theta)]).T
+
+    def __getitem__(self, index):
+        return self.data[index], self.labels[index]
+
+    def __len__(self):
+        return len(self.data)
+
+
+@METRICS.register_module()
+class Accuracy(BaseMetric):
+    def __init__(self):
+        super().__init__()
+
+    def process(self, data_batch, data_samples):
+        score, gt = data_samples
+        self.results.append({
+            'batch_size': len(gt),
+            'correct': (score.argmax(dim=1) == gt).sum().cpu(),
+        })
+
+    def compute_metrics(self, results):
+        total_correct = sum(r['correct'] for r in results)
+        total_size = sum(r['batch_size'] for r in results)
+        return dict(accuracy=100*total_correct/total_size)
+```
+
+</details>
+
+<details>
+<summary>Click to show a long example. Be well prepared</summary>
+
+```python
+from torch.utils.data import DataLoader, default_collate
+from torch.optim import Adam
+from mmengine.runner import Runner
+
+
+runner = Runner(
+    # your model
+    model=MyAwesomeModel(
+        layers=2,
+        activation='relu'),
+    # work directory for saving checkpoints and logs
+    work_dir='exp/my_awesome_model',
+
+    # training data
+    train_dataloader=DataLoader(
+        dataset=MyDataset(
+            is_train=True,
+            size=10000),
+        shuffle=True,
+        collate_fn=default_collate,
+        batch_size=64,
+        pin_memory=True,
+        num_workers=2),
+    # training configurations
+    train_cfg=dict(
+        by_epoch=True,   # display in epoch number instead of iterations
+        max_epochs=10,
+        val_begin=2,     # start validation from the 2nd epoch
+        val_interval=1), # do validation every 1 epoch
+
+    # OptimizerWrapper, new concept in MMEngine for richer optimization options
+    # Default value works fine for most cases. You may check our documentations
+    # for more details, e.g. 'AmpOptimWrapper' for enabling mixed precision
+    # training.
+    optim_wrapper=dict(
+        optimizer=dict(
+            type=Adam,
+            lr=0.001)),
+    # ParamScheduler to adjust learning rates or momentums during training
+    param_scheduler=dict(
+        type='MultiStepLR',
+        by_epoch=True,
+        milestones=[4, 8],
+        gamma=0.1),
+
+    # validation data
+    val_dataloader=DataLoader(
+        dataset=MyDataset(
+            is_train=False,
+            size=1000),
+        shuffle=False,
+        collate_fn=default_collate,
+        batch_size=1000,
+        pin_memory=True,
+        num_workers=2),
+    # validation configurations, usually leave it an empty dict
+    val_cfg=dict(),
+    # evaluation metrics and evaluator
+    val_evaluator=dict(type=Accuracy),
+
+    # following are advanced configurations, try to default when not in need
+    # hooks are advanced usage, try to default when not in need
+    default_hooks=dict(
+        # the most commonly used hook for modifying checkpoint saving interval
+        checkpoint=dict(type='CheckpointHook', interval=1)),
+
+    # `luancher` and `env_cfg` responsible for distributed environment
+    launcher='none',
+    env_cfg=dict(
+        cudnn_benchmark=False,   # whether enable cudnn_benchmark
+        backend='nccl',   # distributed communication backend
+        mp_cfg=dict(mp_start_method='fork')),  # multiprocessing configs
+    log_level='INFO',
+
+    # load model weights from given path. None for no loading.
+    load_from=None
+    # resume training from the given path
+    resume=False
+)
+
+# start training your model
+runner.train()
+```
+
+</details>
+
+### Explanations on example codes
+
+Really a long piece of code, isn't it! However, if you read through the above example, you may have already understood the training process in general even without knowing any implementation details, thanks to the compactness and readability of runner codes (probably). This is what MMEngine expects: a structured, modular, and standardized training process that allows for more reliable reproductions and clearer comparisons.
+
+The above example may lead you to the following confusion:
+
+<details>
+<summary>There are too many arguments!</summary>
+
+Don't worry. As we mentioned before, **use runner as a memo**. The runner covers all aspects just to ensure you won't miss something important. You don't actually need to configure everything. The simple example in [15 minutes](../get_started/15_minutes.md) still works fine, and it can be even more simplified by removing `val_evaluator`, `val_dataloader`, and `val_cfg` without breaking down. All configurable arguments are driven by your demands. Those not in your focus usually work fine by default.
+
+</details>
+
+<details>
+<summary>Why are some arguments passed as dicts?</summary>
+
+Well, this is related to MMEngine's style. In MMEngine, we provide 2 different styles of runner construction: a) manual construction and b) construction via registry. If you are confused, the following example will give a good illustration:
+
+```python
+from mmengine.model import BaseModel
+from mmengine.runner import Runner
+from mmengine.registry import MODELS # root registry for your custom model
+
+@MODELS.register_module() # decorator for registration
+class MyAwesomeModel(BaseModel): # your custom model
+    def __init__(self, layers=18, activation='silu'):
+        ...
+
+# An example of manual construction
+runner = Runner(
+    model=dict(
+        type='MyAwesomeModel',
+        layers=50,
+        activation='relu'),
+    ...
+)
+
+# An example of construction via registry
+model = MyAwesomeModel(layers=18, activation='relu')
+runner = Runner(
+    model=model,
+    ...
+)
+```
+
+Similar to the above example, most arguments in the runner accept both 2 types of inputs. They are conceptually equivalent. The difference is, in the former style, the module (passed in as a `dict`) will be built **in the runner when actually needed**, while in the latter style, the module has been built before being passed to the runner. The following figure illustrates the core idea of registry: it maintains the mapping between a module's **build method** and its **registry name**. If you want to learn more about the full usage of the registry, you are recommended to read [Registry](../advanced_tutorials/registry.md) tutorial.
+
+![Runner Registry Illustration](https://user-images.githubusercontent.com/112053249/199191651-44174d17-0fc5-4443-8d15-76f561ec0585.png)
+
+You might still be confused after the explanation. Why should we let the Runner build modules from dicts? What are the benefits? If you have such questions, then we are proud to answer: "Absolutely - no benefits!" In fact, module construction via registry only works to its best advantage when combined with a configuration file. It is still far from the best practice to write as the above example. We provide it here just to make sure you can read and get used to this writing style, which may facilitate your understanding of the actual best practice we will soon talk about - the configuration file. Stay tuned!
+
+If you as a beginner do not immediately understand, it doesn't matter too much, because **manual construction** is still a good choice, especially for small-scale development and trial-and-error due to its being IDE friendly. However, you are still expected to read and get used to the writing style via registry, so that you can avoid being unnecessarily confused and puzzled in subsequent tutorials.
+
+</details>
+
+<details>
+<summary>Where can I find the possible configuration options for the xxx argument?</summary>
+
+You will find extensive instructions and examples in those tutorials of the corresponding modules. You can also find all possible arguments in [Runner's API documentation](mmengine.runner.Runner). If neither of the above resolves your query, you are always encouraged to start a topic in our [discussion forum](https://github.com/open-mmlab/mmengine/discussions). It also helps us improve documentations.
+
+</details>
+
+<details>
+<summary>I come from repositoried like MMDet/MMCls... Why does this example differ from what I've been exposed to?</summary>
+
+Downstream repositories in OpenMMLab have widely adopted the writing style of config files. In the following chapter, we will show the usage of config files, the best practice of the runner in MMEngine, based on the above example with a slight variation.
+
+</details>
+
+## Best practice of the Runner - config files
+
+MMEngine provides a powerful config file system that supports Python syntax. You can **almost seamlessly** (which we will illustrate below) convert from the previous sample code to a config file. Here is an example:
+
+```python
+# Save the following codes in example_config.py
+# Almost copied from the above example, with some commas removed
+model = dict(type='MyAwesomeModel',
+    layers=2,
+    activation='relu')
+work_dir = 'exp/my_awesome_model'
+
+train_dataloader = dict(
+    dataset=dict(type='MyDataset',
+        is_train=True,
+        size=10000),
+    sampler=dict(
+        type='DefaultSampler',
+        shuffle=True),
+    collate_fn=dict(type='default_collate'),
+    batch_size=64,
+    pin_memory=True,
+    num_workers=2)
+train_cfg = dict(
+    by_epoch=True,
+    max_epochs=10,
+    val_begin=2,
+    val_interval=1)
+optim_wrapper = dict(
+    optimizer=dict(
+        type='Adam',
+        lr=0.001))
+param_scheduler = dict(
+    type='MultiStepLR',
+    by_epoch=True,
+    milestones=[4, 8],
+    gamma=0.1)
+
+val_dataloader = dict(
+    dataset=dict(type='MyDataset',
+        is_train=False,
+        size=1000),
+    sampler=dict(
+        type='DefaultSampler',
+        shuffle=False),
+    collate_fn=dict(type='default_collate'),
+    batch_size=1000,
+    pin_memory=True,
+    num_workers=2)
+val_cfg = dict()
+val_evaluator = dict(type='Accuracy')
+
+default_hooks = dict(
+    checkpoint=dict(type='CheckpointHook', interval=1))
+launcher = 'none'
+env_cfg = dict(
+    cudnn_benchmark=False,
+    backend='nccl',
+    mp_cfg=dict(mp_start_method='fork'))
+log_level = 'INFO'
+load_from = None
+resume = False
+```
+
+Given the above config file, we can simply load configurations and run the training pipeline in a few lines of codes as follows:
+
+```python
+from mmengine.config import Config
+from mmengine.runner import Runner
+config = Config.fromfile('example_config.py')
+runner = Runner.from_cfg(config)
+runner.train()
+```
+
+```{note}
+Although it supports Python syntax, a valid config file needs to meet the condition that all variables must be Python built-in types such as `str`, `dict` and `int`. Therefore, the config system is highly dependent on the registry mechanism to enable construction from built-in types to other types such as `nn.Module`.
+```
+
+```{note}
+When using config files, you typically don't need to manually register every module. For instance, all optimizers in `torch.optim` including `Adam` and `SGD` have already been registered in `mmengine.optim`. The rule of thumb is, try to directly access modules provided by PyTorch, and only start to register them manually after error occurs.
+```
+
+```{note}
+When using config files, the implementations of your custom modules may be stored in separate files and thus not registered properly, which will lead to errors in the build process. You may find solutions in [Registry tutorial](./registry.md) by searching for `custom_imports`.
+```
+
+```{warnings}
+Although sharing nearly the same codes, `from_cfg` and `__init__` differs in some default values like `env_cfg`.
+```
+
+Writing config files of the runner has been widely adopted in downstream repositories in OpenMMLab projects. It has been a de facto convention and best practice. The config files are far more featured than illustrated above. You can refer to [Config tutorial](../advanced_tutorials/config.md) for more advanced features including keywords inheriting and overriding.
+
+## Basic dataflow
+
+```{hint}
+In this chapter, we'll dive deeper into the runner to illustrate dataflow and data format convention between modules managed by the runner. It may be relatively abstract and dry if you haven't built a training pipeline with MMEngine. Therefore, you are free to skip for now and read it in conjunction with practice in the future when in need.
+```
+
+Now let's dive **slightly deeper** into the runner, and illustrate the dataflow and data format convention under the hood (or, under the engine)!
+
+![Basic Dataflow](https://user-images.githubusercontent.com/112053249/199228350-5f80699e-7fd2-4b4c-ac32-0b16b1922c2e.png)
+
+The diagram above illustrates the **basic** dataflow of the runner, where 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, you can always inherit some key base classes and override their methods, so the above diagram doesn't always hold. It only holds when you are not customizing your own `Runner` or `TrainLoop`, and you are not overriding `train_step`, `val_step` or `test_step` method in your custom model. Actually, this is common for most tasks like detection and segmentation, as referred to [Model tutorial](./model.md).
+
+<details>
+<summary>Can you state the exact type of each data item shown in the diagram?</summary>
+
+Unfortunately, this is not possible. Although we did heavy type annotations in MMEngine, Python is still a highly dynamic programming language, and deep learning as a data-centric system needs to be flexible enough to deal with a wide range of complex data sources. You always have full freedom to decide when you need (and sometimes must) break type conventions. Therefore, when you are customizing your module (e.g. `val_evaluator`), you need to make sure its input is compatible with upstream (e.g. `model`) output and its output can be parsed by downstream. MMEngine puts the flexibility of handling data in the hands of the user, and thus also requires the user to ensure compatibility of dataflow, which, in fact, is not that difficult once you get started.
+
+The uniformity of data formats has always been a problem in deep learning. We are trying to improve it in MMEngine in our own way. If you are interested, you can refer to [BaseDataset](../advanced_tutorials/basedataset.md) and [BaseDataElement](../advanced_tutorials/data_element.md) - but please note that they are mainly geared towards advanced users.
+
+</details>
+
+<details>
+<summary>What's the data format convention between dataloader, model and evaluator?</summary>
+
+For the basic dataflow shown in the diagram above, the data transfer between the above three modules can be represented by the following pseudo-code:
+
+```python
+# training
+for data_batch in train_dataloader:
+    data_batch = data_preprocessor(data_batch)
+    if isinstance(data_batch, dict):
+        losses = model.forward(**data_batch, mode='loss')
+    elif isinstance(data_batch, (list, tuple)):
+        losses = model.forward(*data_batch, mode='loss')
+    else:
+        raise TypeError()
+
+# validation
+for data_batch in val_dataloader:
+    data_batch = data_preprocessor(data_batch)
+    if isinstance(data_batch, dict):
+        outputs = model.forward(**data_batch, mode='predict')
+    elif isinstance(data_batch, (list, tuple)):
+        outputs = model.forward(**data_batch, mode='predict')
+    else:
+        raise TypeError()
+    evaluator.process(data_samples=outputs, data_batch=data_batch)
+metrics = evaluator.evaluate(len(val_dataloader.dataset))
+```
+
+The key points of the above pseudo-code is:
+
+- Outputs of data_preprocessor are passed to model **after unpacking**
+- The `data_samples` argument of the evaluator receives the prediction results of the model, while the `data_batch` argument receives the raw data coming from dataloader
+
+</details>
+
+<details>
+<summary>What is data_preprocessor? Can I do image pre-processing such as crop and resize in it?</summary>
+
+Though drawn separately in the diagram, data_preprocessor is a part of the model and thus can be found in [Model tutorial](./model.md) in DataPreprocessor chapter.
+
+In most cases, data_preprocessor needs no special attention or manual configuration. The default data_preprocessor will only do data transfer between host and GPU devices. However, if your model has incompatible inputs format with dataloader's output, you can also customize you own data_preprocessor for data formatting.
+
+Image pre-processing such as crop and resize is more recommended in [data transforms module](../advanced_tutorials/data_transform.md), but for batch-related data transforms (e.g. batch-resize), it can be implemented here.
+
+</details>
+
+<details>
+<summary>Why does module produce 3 different outputs? What is the meaning of "loss", "predict" and "tensor"?</summary>
+
+As described in [get started in 15 minutes](../get_started/15_minutes.md), you need to implement 3 data paths in your custom model's `forward` function to suit different pipelines for training, validation and testing. This is further discussed in [Model tutorial](./model.md).
+
+</details>
+
+<details>
+<summary>I can see that the red line is for training process and the blue line for validation/testing, but what is the green line?</summary>
+
+Currently model outputs in "tensor" mode has not been officially used in runner. The "tensor" mode can output some intermediate results and thus facilitating debugging process.
+
+</details>
+
+<details>
+<summary>What if I override methods such as train_step? Will the diagram totally fail?</summary>
+
+The behavior of default `train_step`, `val_step` and `test_step` covers the dataflow from data_preprocessor to model outputs and optim_wrapper. The rest of the diagram will not be spoiled.
+
+</details>
+
+## Why use the runner? (Optional reading)
+
+```{hint}
+Contents in this chapter will not teach you how to use the runner and MMEngine. If you are being pushed by your employer/advisor/DDL to work out a result in a few hours, it may not help you and you can feel free to skip it. However, we highly recommend taking time to read through this chapter, since it will help you better understand the aim and style of MMEngine.
+```
+
+<details>
+<summary>Relax, time for some philosophy</summary>
+
+Congratulations for reading through the runner tutorial, a long, long but kind of interesting (hope so) tutorial! Please believe that all of these - this tutorial, the runner, MMEngine - are intended to **make things easier for you**.
+
+The runner is the "manager" of all modules in MMEngine. In the runner, all the distinct modules - whether visible ones like model and dataset, or obscure ones like logging, distributed environment and random seed - are getting organized and scheduled. The runner deals with the complex relationship between different modules and provides you with a clear, easy-to-understand and configurable interface. The benefits of this design are:
+
+1. You can modify or add your codes without spoiling your whole codebase. For example, you may start with single GPU training and you can always add a few lines of configuration codes to enable multi GPUs or even multi nodes training.
+2. You can continuously benefit from new features without worrying about backward compatibility. Mixed precision training, visualization, state of the art distributed training methods, various device backends... We will continue to absorb the best suggestions and cutting-edge technologies from the community while ensuring backward compatibility, and provide them to you in a clear interface.
+3. You can focus on your own awesome ideas without being bothered by other annoying and irrelevant details. The default values will handle most cases.
+
+So, MMEngine and the runner will truly make things easier for you. With only a little effort on migration, your code and experiments will evolve with MMEngine. With a little more effort, the config file system allows you to manage your data, model, and experiments more efficiently. Convenience and reliability are the aims we strive for.
+
+The blue one, or the red one - are you prepared to use MMEngine?
+
+</details>
+
+## Suggestions on next steps
+
+If you want to:
+
+<details>
+<summary>Write your own model structure</summary>
+
+Refer to [Model tutorial](./model.md)
+
+</details>
+
+<details>
+<summary>Use your own datasets</summary>
+
+Refer to [Dataset and DataLoader tutorial](./dataset.md)
+
+</details>
+
+<details>
+<summary>Change evaluation metrics</summary>
+
+Refer to [Evaluation tutorial](./evaluation.md)
+
+</details>
+
+<details>
+<summary>Do something related to optimizers or mixed-precision training</summary>
+
+Refer to [OptimWrapper tutorial](./optim_wrapper.md)
+
+</details>
+
+<details>
+<summary>Schedule learning rates or other parameters during training</summary>
+
+Refer to [Parameter Scheduler tutorial](./param_scheduler.md)
+
+</details>
+
+<details>
+<summary>Something not mentioned above</summary>
+
+- "Common Usage" section to the left contains more example codes
+- "Advanced tutorials" to the left consists of more contents for experienced developers to make more flexible extensions to the training pipeline
+- [Hook](./hook.md) provides some flexible modifications without spoiling your codes
+- If none of the above solves your problem, you are always welcome to start a topic in our [discussion forum](https://github.com/open-mmlab/mmengine/discussions)!
+
+</details>

testbed/open-mmlab__mmengine/docs/resources/config/cross_repo.py

@@ -0,0 +1,6 @@
+_base_ = [
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/datasets/coco_instance.py',
+    'mmdet::_base_/default_runtime.py',
+    'mmdet::_base_/models/faster-rcnn_r50_fpn.py',
+]

testbed/open-mmlab__mmengine/docs/resources/config/custom_imports.py

@@ -0,0 +1,2 @@
+custom_imports = dict(imports=['my_module'], allow_failed_imports=False)
+optimizer = dict(type='CustomOptim')

testbed/open-mmlab__mmengine/docs/resources/config/demo_train.py

@@ -0,0 +1,33 @@
+import argparse
+
+from mmengine.config import Config, DictAction
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Train a model')
+    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()

testbed/open-mmlab__mmengine/docs/resources/config/example.py

@@ -0,0 +1,2 @@
+model = dict(type='CustomModel', in_channels=[1, 2, 3])
+optimizer = dict(type='SGD', lr=0.01)

testbed/open-mmlab__mmengine/docs/resources/config/learn_read_config.py

@@ -0,0 +1,3 @@
+test_int = 1
+test_list = [1, 2, 3]
+test_dict = dict(key1='value1', key2=0.1)

testbed/open-mmlab__mmengine/docs/resources/config/my_module.py

@@ -0,0 +1,6 @@
+from mmengine.registry import OPTIMIZERS
+
+
+@OPTIMIZERS.register_module()
+class CustomOptim:
+    pass

testbed/open-mmlab__mmengine/docs/resources/config/optimizer_cfg.py

@@ -0,0 +1 @@
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)

testbed/open-mmlab__mmengine/docs/resources/config/predefined_var.py

@@ -0,0 +1 @@
+work_dir = './work_dir/{{fileBasenameNoExtension}}'

testbed/open-mmlab__mmengine/docs/resources/config/refer_base_var.py

@@ -0,0 +1,2 @@
+_base_ = ['resnet50.py']
+a = {{_base_.model}}

testbed/open-mmlab__mmengine/docs/resources/config/resnet50.py

@@ -0,0 +1,2 @@
+_base_ = ['optimizer_cfg.py']
+model = dict(type='ResNet', depth=50)

testbed/open-mmlab__mmengine/docs/resources/config/resnet50_delete_key.py

@@ -0,0 +1,3 @@
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(_delete_=True, type='SGD', lr=0.01)

testbed/open-mmlab__mmengine/docs/resources/config/resnet50_lr0.01.py

@@ -0,0 +1,3 @@
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(lr=0.01)

testbed/open-mmlab__mmengine/docs/resources/config/resnet50_runtime.py

@@ -0,0 +1,2 @@
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)

testbed/open-mmlab__mmengine/docs/resources/config/runtime_cfg.py

@@ -0,0 +1 @@
+gpu_ids = [0, 1]

testbed/open-mmlab__mmengine/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)

testbed/open-mmlab__mmengine/docs/zh_cn/_static/css/readthedocs.css

@@ -0,0 +1,20 @@
+table.colwidths-auto td {
+    width: 50%
+}
+
+.header-logo {
+    background-image: url("../image/mmengine-logo.png");
+    background-size: 130px 40px;
+    height: 40px;
+    width: 130px;
+}
+
+.two-column-table-wrapper {
+    width: 50%;
+    max-width: 300px;
+    overflow-x: auto;
+}
+
+.two-column-table-wrapper .highlight {
+    width: 1500px
+}

testbed/open-mmlab__mmengine/docs/zh_cn/_templates/classtemplate.rst

@@ -0,0 +1,14 @@
+.. role:: hidden
+    :class: hidden-section
+.. currentmodule:: {{ module }}
+
+
+{{ name | underline}}
+
+.. autoclass:: {{ name }}
+    :members:
+
+
+..
+  autogenerated from source/_templates/classtemplate.rst
+  note it does not have :inherited-members:

testbed/open-mmlab__mmengine/docs/zh_cn/advanced_tutorials/basedataset.md

@@ -0,0 +1,505 @@
+# 数据集基类（BaseDataset）
+
+## 基本介绍
+
+算法库中的数据集类负责在训练/测试过程中为模型提供输入数据，OpenMMLab 下各个算法库中的数据集有一些共同的特点和需求，比如需要高效的内部数据存储格式，需要支持数据集拼接、数据集重复采样等功能。
+
+因此 **MMEngine** 实现了一个数据集基类（BaseDataset）并定义了一些基本接口，且基于这套接口实现了一些数据集包装（DatasetWrapper）。OpenMMLab 算法库中的大部分数据集都会满足这套数据集基类定义的接口，并使用统一的数据集包装。
+
+数据集基类的基本功能是加载数据集信息，这里我们将数据集信息分成两类，一种是元信息 (meta information)，代表数据集自身相关的信息，有时需要被模型或其他外部组件获取，比如在图像分类任务中，数据集的元信息一般包含类别信息 `classes`，因为分类模型 `model` 一般需要记录数据集的类别信息；另一种为数据信息 (data information)，在数据信息中，定义了具体样本的文件路径、对应标签等的信息。除此之外，数据集基类的另一个功能为不断地将数据送入数据流水线（data pipeline）中，进行数据预处理。
+
+### 数据标注文件规范
+
+为了统一不同任务的数据集接口，便于多任务的算法模型训练，OpenMMLab 制定了 **OpenMMLab 2.0 数据集格式规范**， 数据集标注文件需符合该规范，数据集基类基于该规范去读取与解析数据标注文件。如果用户提供的数据标注文件不符合规定格式，用户可以选择将其转化为规定格式，并使用 OpenMMLab 的算法库基于该数据标注文件进行算法训练和测试。
+
+OpenMMLab 2.0 数据集格式规范规定，标注文件必须为 `json` 或 `yaml`，`yml` 或 `pickle`，`pkl` 格式；标注文件中存储的字典必须包含 `metainfo` 和 `data_list` 两个字段。其中 `metainfo` 是一个字典，里面包含数据集的元信息；`data_list` 是一个列表，列表中每个元素是一个字典，该字典定义了一个原始数据（raw data），每个原始数据包含一个或若干个训练/测试样本。
+
+以下是一个 JSON 标注文件的例子（该例子中每个原始数据只包含一个训练/测试样本）:
+
+```json
+
+{
+    'metainfo':
+        {
+            'classes': ('cat', 'dog'),
+            ...
+        },
+    'data_list':
+        [
+            {
+                'img_path': "xxx/xxx_0.jpg",
+                'img_label': 0,
+                ...
+            },
+            {
+                'img_path': "xxx/xxx_1.jpg",
+                'img_label': 1,
+                ...
+            },
+            ...
+        ]
+}
+```
+
+同时假设数据存放路径如下：
+
+```text
+data
+├── annotations
+│   ├── train.json
+├── train
+│   ├── xxx/xxx_0.jpg
+│   ├── xxx/xxx_1.jpg
+│   ├── ...
+```
+
+### 数据集基类的初始化流程
+
+数据集基类的初始化流程如下图所示：
+
+<div align="center">
+  <img src="https://user-images.githubusercontent.com/26813582/201585974-1360e2b5-f95f-4273-8cbf-6024e33204ab.png" height="500"/>
+</div>
+
+1. `load metainfo`：获取数据集的元信息，元信息有三种来源，优先级从高到低为：
+
+- `__init__()` 方法中用户传入的 `metainfo` 字典；改动频率最高，因为用户可以在实例化数据集时，传入该参数；
+
+- 类属性 `BaseDataset.METAINFO` 字典；改动频率中等，因为用户可以改动自定义数据集类中的类属性 `BaseDataset.METAINFO`；
+
+- 标注文件中包含的 `metainfo` 字典；改动频率最低，因为标注文件一般不做改动。
+
+  如果三种来源中有相同的字段，优先级最高的来源决定该字段的值，这些字段的优先级比较是：用户传入的 `metainfo` 字典里的字段 > `BaseDataset.METAINFO` 字典里的字段 > 标注文件中 `metainfo` 字典里的字段。
+
+2. `join path`：处理数据与标注文件的路径；
+
+3. `build pipeline`：构建数据流水线（data pipeline），用于数据预处理与数据准备；
+
+4. `full init`：完全初始化数据集类，该步骤主要包含以下操作：
+
+- `load data list`：读取与解析满足 OpenMMLab 2.0 数据集格式规范的标注文件，该步骤中会调用 `parse_data_info()` 方法，该方法负责解析标注文件里的每个原始数据；
+
+- `filter data` (可选)：根据 `filter_cfg` 过滤无用数据，比如不包含标注的样本等；默认不做过滤操作，下游子类可以按自身所需对其进行重写；
+
+- `get subset` (可选)：根据给定的索引或整数值采样数据，比如只取前 10 个样本参与训练/测试；默认不采样数据，即使用全部数据样本；
+
+- `serialize data` (可选)：序列化全部样本，以达到节省内存的效果，详情请参考[节省内存](#节省内存)；默认操作为序列���全部样本。
+
+数据集基类中包含的 `parse_data_info()` 方法用于将标注文件里的一个原始数据处理成一个或若干个训练/测试样本的方法。因此对于自定义数据集类，用户需要实现 `parse_data_info()` 方法。
+
+### 数据集基类提供的接口
+
+与 `torch.utils.data.Dataset` 类似，数据集初始化后，支持 `__getitem__` 方法，用来索引数据，以及 `__len__` 操作获取数据集大小，除此之外，OpenMMLab 的数据集基类主要提供了以下接口来访问具体信息：
+
+- `metainfo`：返回元信息，返回值为字典
+
+- `get_data_info(idx)`：返回指定 `idx` 的样本全量信息，返回值为字典
+
+- `__getitem__(idx)`：返回指定 `idx` 的样本经过 pipeline 之后的结果（也就是送入模型的数据），返回值为字典
+
+- `__len__()`：返回数据集长度，返回值为整数型
+
+- `get_subset_(indices)`：根据 `indices` 以 inplace 的方式**修改原数据集类**。如果 `indices` 为 `int`，则原数据集类只包含前若干个数据样本；如果 `indices` 为 `Sequence[int]`，则原数据集类包含根据 `Sequence[int]` 指定的数据样本。
+
+- `get_subset(indices)`：根据 `indices` 以**非** inplace 的方式**返回子数据集类**，即重新复制一份子数据集。如果 `indices` 为 `int`，则返回的子数据集类只包含前若干个数据样本；如果 `indices` 为 `Sequence[int]`，则返回的子数据集类包含根据 `Sequence[int]` 指定的数据样本。
+
+## 使用数据集基类自定义数据集类
+
+在了解了数据集基类的初始化流程与提供的接口之后，就可以基于数据集基类自定义数据集类。
+
+### 对于满足 OpenMMLab 2.0 数据集格式规范的标注文件
+
+如上所述，对于满足 OpenMMLab 2.0 数据集格式规范的标注文件，用户可以重载 `parse_data_info()` 来加载标签。以下是一个使用数据集基类来实现某一具体数据集的例子。
+
+```python
+import os.path as osp
+
+from mmengine.dataset import BaseDataset
+
+
+class ToyDataset(BaseDataset):
+
+    # 以上面标注文件为例，在这里 raw_data_info 代表 `data_list` 对应列表里的某个字典：
+    # {
+    #    'img_path': "xxx/xxx_0.jpg",
+    #    'img_label': 0,
+    #    ...
+    # }
+    def parse_data_info(self, raw_data_info):
+        data_info = raw_data_info
+        img_prefix = self.data_prefix.get('img_path', None)
+        if img_prefix is not None:
+            data_info['img_path'] = osp.join(
+                img_prefix, data_info['img_path'])
+        return data_info
+
+```
+
+#### 使用自定义数据集类
+
+在定义了数据集类后，就可以通过如下配置实例化 `ToyDataset`：
+
+```python
+
+class LoadImage:
+
+    def __call__(self, results):
+        results['img'] = cv2.imread(results['img_path'])
+        return results
+
+class ParseImage:
+
+    def __call__(self, results):
+        results['img_shape'] = results['img'].shape
+        return results
+
+pipeline = [
+    LoadImage(),
+    ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+    data_root='data/',
+    data_prefix=dict(img_path='train/'),
+    ann_file='annotations/train.json',
+    pipeline=pipeline)
+```
+
+同时可以使用数据集类提供的对外接口访问具体的样本信息：
+
+```python
+toy_dataset.metainfo
+# dict(classes=('cat', 'dog'))
+
+toy_dataset.get_data_info(0)
+# {
+#     'img_path': "data/train/xxx/xxx_0.jpg",
+#     'img_label': 0,
+#     ...
+# }
+
+len(toy_dataset)
+# 2
+
+toy_dataset[0]
+# {
+#     'img_path': "data/train/xxx/xxx_0.jpg",
+#     'img_label': 0,
+#     'img': a ndarray with shape (H, W, 3), which denotes the value of the image,
+#     'img_shape': (H, W, 3) ,
+#     ...
+# }
+
+# `get_subset` 接口不对原数据集类做修改，即完全复制一份新的
+sub_toy_dataset = toy_dataset.get_subset(1)
+len(toy_dataset), len(sub_toy_dataset)
+# 2, 1
+
+# `get_subset_` 接口会对原数据集类做修改，即 inplace 的方式
+toy_dataset.get_subset_(1)
+len(toy_dataset)
+# 1
+```
+
+经过以上步骤，可以了解基于数据集基类如何自定义新的数据集类，以及如何使用自定义数据集类。
+
+#### 自定义视频的数据集类
+
+在上面的例子中，标注文件的每个原始数据只包含一个训练/测试样本（通常是图像领域）。如果每个原始数据包含若干个训练/测试样本（通常是视频领域），则只需保证 `parse_data_info()` 的返回值为 `list[dict]` 即可：
+
+```python
+from mmengine.dataset import BaseDataset
+
+
+class ToyVideoDataset(BaseDataset):
+
+    # raw_data_info 仍为一个字典，但它包含了多个样本
+    def parse_data_info(self, raw_data_info):
+        data_list = []
+
+        ...
+
+        for ... :
+
+            data_info = dict()
+
+            ...
+
+            data_list.append(data_info)
+
+        return data_list
+
+```
+
+`ToyVideoDataset` 使用方法与 `ToyDataset` 类似，在此不做赘述。
+
+### 对于不满足 OpenMMLab 2.0 数���集格式规范的标注文件
+
+对于不满足 OpenMMLab 2.0 数据集格式规范的标注文件，有两种方式来使用数据集基类：
+
+1. 将不满足规范的标注文件转换成满足规范的标注文件，再通过上述方式使用数据集基类。
+
+2. 实现一个新的数据集类，继承自数据集基类，并且重载数据集基类的 `load_data_list(self):` 函数，处理不满足规范的标注文件，并保证返回值为 `list[dict]`，其中每个 `dict` 代表一个数据样本。
+
+## 数据集基类的其它特性
+
+数据集基类还包含以下特性：
+
+### 懒加载（lazy init）
+
+在数据集类实例化时，需要读取并解析标注文件，因此会消耗一定时间。然而在某些情况比如预测可视化时，往往只需要数据集类的元信息，可能并不需要读取与解析标注文件。为了节省这种情况下数据集类实例化的时间，数据集基类支持懒加载：
+
+```python
+pipeline = [
+    LoadImage(),
+    ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+    data_root='data/',
+    data_prefix=dict(img_path='train/'),
+    ann_file='annotations/train.json',
+    pipeline=pipeline,
+    # 在这里传入 lazy_init 变量
+    lazy_init=True)
+```
+
+当 `lazy_init=True` 时，`ToyDataset` 的初始化方法只执行了[数据集基类的初始化流程](#数据集基类的初始化流程)中的 1、2、3 步骤，此时 `toy_dataset` 并未被完全初始化，因为 `toy_dataset` 并不会读取与解析标注文件，只会设置数据集类的元信息（`metainfo`）。
+
+自然的，如果之后需要访问具体的数据信息，可以手动调用 `toy_dataset.full_init()` 接口来执行完整的初始化过程，在这个过程中数据标注文件将被读取与解析。调用 `get_data_info(idx)`, `__len__()`, `__getitem__(idx)`，`get_subset_(indices)`， `get_subset(indices)` 接口也会自动地调用 `full_init()` 接口来执行完整的初始化过程（仅在第一次调用时，之后调用不会重复地调用 `full_init()` 接口）：
+
+```python
+# 完整初始化
+toy_dataset.full_init()
+
+# 初始化完毕，现在可以访问具体数据
+len(toy_dataset)
+# 2
+toy_dataset[0]
+# {
+#     'img_path': "data/train/xxx/xxx_0.jpg",
+#     'img_label': 0,
+#     'img': a ndarray with shape (H, W, 3), which denotes the value the image,
+#     'img_shape': (H, W, 3) ,
+#     ...
+# }
+```
+
+**注意：**
+
+通过直接调用 `__getitem__()` 接口来执行完整初始化会带来一定风险：如果一个数据集类首先通过设置 `lazy_init=True` 未进行完全初始化，然后直接送入数据加载器（dataloader）中，在后续读取数据的过程中，不同的 worker 会同时读取与解析标注文件，虽然这样可能可以正常运行，但是会消耗大量的时间与内存。**因此，建议在需要访问具体数据之前，提前手动调用 `full_init()` 接口来执行完整的初始化过程。**
+
+以上通过设置 `lazy_init=True` 未进行完全初始化，之后根据需求再进行完整初始化的方式，称为懒加载。
+
+### 节省内存
+
+在具体的读取数据过程中，数据加载器（dataloader）通常会起多个 worker 来预取数据，多个 worker 都拥有完整的数据集类备份，因此内存中会存在多份相同的 `data_list`，为了节省这部分内存消耗，数据集基类可以提前将 `data_list` 序列化存入内存中，使得多个 worker 可以共享同一份 `data_list`，以达到节省内存的目的。
+
+数据集基类默认是将 `data_list` 序列化存入内存，也可以通过 `serialize_data` 变量（默认为 `True`）来控制是否提前将 `data_list` 序列化存入内存中：
+
+```python
+pipeline = [
+    LoadImage(),
+    ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+    data_root='data/',
+    data_prefix=dict(img_path='train/'),
+    ann_file='annotations/train.json',
+    pipeline=pipeline,
+    # 在这里传入 serialize_data 变量
+    serialize_data=False)
+```
+
+上面例子不会提前将 `data_list` 序列化存入内存中，因此不建议在使用数据加载器开多个 worker 加载数据的情况下，使用这种方式实例化数据集类。
+
+## 数据集基类包装
+
+除了数据集基类，MMEngine 也提供了若干个数据集基类包装：`ConcatDataset`, `RepeatDataset`, `ClassBalancedDataset`。这些数据集基类包装同样也支持懒加载与拥有节省内存的特性。
+
+### ConcatDataset
+
+MMEngine 提供了 `ConcatDataset` 包装来拼接多个数据集，使用方法如下：
+
+```python
+from mmengine.dataset import ConcatDataset
+
+pipeline = [
+    LoadImage(),
+    ParseImage(),
+]
+
+toy_dataset_1 = ToyDataset(
+    data_root='data/',
+    data_prefix=dict(img_path='train/'),
+    ann_file='annotations/train.json',
+    pipeline=pipeline)
+
+toy_dataset_2 = ToyDataset(
+    data_root='data/',
+    data_prefix=dict(img_path='val/'),
+    ann_file='annotations/val.json',
+    pipeline=pipeline)
+
+toy_dataset_12 = ConcatDataset(datasets=[toy_dataset_1, toy_dataset_2])
+
+```
+
+上述例子将数据集的 `train` 部分与 `val` 部分合成一个大的数据集。
+
+### RepeatDataset
+
+MMEngine 提供了 `RepeatDataset` 包装来重复采样某个数据集若干次，使用方法如下：
+
+```python
+from mmengine.dataset import RepeatDataset
+
+pipeline = [
+    LoadImage(),
+    ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+    data_root='data/',
+    data_prefix=dict(img_path='train/'),
+    ann_file='annotations/train.json',
+    pipeline=pipeline)
+
+toy_dataset_repeat = RepeatDataset(dataset=toy_dataset, times=5)
+
+```
+
+上述例子将数据集的 `train` 部分重复采样了 5 次。
+
+### ClassBalancedDataset
+
+MMEngine 提供了 `ClassBalancedDataset` 包装，来基于数据集中类别出现频率，重复采样相应样本。
+
+**注意：**
+
+`ClassBalancedDataset` 包装假设了被包装的数据集类支持 `get_cat_ids(idx)` 方法，`get_cat_ids(idx)` 方法返回一个列表，该列表包含了 `idx` 指定的 `data_info` 包含的样本类别，使用方法如下：
+
+```python
+from mmengine.dataset import BaseDataset, ClassBalancedDataset
+
+class ToyDataset(BaseDataset):
+
+    def parse_data_info(self, raw_data_info):
+        data_info = raw_data_info
+        img_prefix = self.data_prefix.get('img_path', None)
+        if img_prefix is not None:
+            data_info['img_path'] = osp.join(
+                img_prefix, data_info['img_path'])
+        return data_info
+
+    # 必须支持的方法，需要返回样本的类别
+    def get_cat_ids(self, idx):
+        data_info = self.get_data_info(idx)
+        return [int(data_info['img_label'])]
+
+pipeline = [
+    LoadImage(),
+    ParseImage(),
+]
+
+toy_dataset = ToyDataset(
+    data_root='data/',
+    data_prefix=dict(img_path='train/'),
+    ann_file='annotations/train.json',
+    pipeline=pipeline)
+
+toy_dataset_repeat = ClassBalancedDataset(dataset=toy_dataset, oversample_thr=1e-3)
+
+```
+
+上述例子将数据集的 `train` 部分以 `oversample_thr=1e-3` 重新采样，具体地，对于数据集中出现频率低于 `1e-3` 的类别，会重复采样该类别对应的样本，否则不重复采样，具体采样策略请参考 `ClassBalancedDataset` API 文档。
+
+### 自定义数据集类包装
+
+由于数据集基类实现了懒加载的功能，因此在自定义数据集类包装时，需要遵循一些规则，下面以一个例子的方式来展示如何自定义数据集类包装：
+
+```python
+from mmengine.dataset import BaseDataset
+from mmengine.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ExampleDatasetWrapper:
+
+    def __init__(self, dataset, lazy_init=False, ...):
+        # 构建原数据集（self.dataset）
+        if isinstance(dataset, dict):
+            self.dataset = DATASETS.build(dataset)
+        elif isinstance(dataset, BaseDataset):
+            self.dataset = dataset
+        else:
+            raise TypeError(
+                'elements in datasets sequence should be config or '
+                f'`BaseDataset` instance, but got {type(dataset)}')
+        # 记录原数据集的元信息
+        self._metainfo = self.dataset.metainfo
+
+        '''
+        1. 在这里实现一些代码，来记录用于包装数据集的一些超参。
+        '''
+
+        self._fully_initialized = False
+        if not lazy_init:
+            self.full_init()
+
+    def full_init(self):
+        if self._fully_initialized:
+            return
+
+        # 将原数据集完全初始化
+        self.dataset.full_init()
+
+        '''
+        2. 在这里实现一些代码，来包装原数据集。
+        '''
+
+        self._fully_initialized = True
+
+    @force_full_init
+    def _get_ori_dataset_idx(self, idx: int):
+
+        '''
+        3. 在这里实现一些代码，来将包装的索引 `idx` 映射到原数据集的索引 `ori_idx`。
+        '''
+        ori_idx = ...
+
+        return ori_idx
+
+    # 提供与 `self.dataset` 一样的对外接口。
+    @force_full_init
+    def get_data_info(self, idx):
+        sample_idx = self._get_ori_dataset_idx(idx)
+        return self.dataset.get_data_info(sample_idx)
+
+    # 提供与 `self.dataset` 一样的对外接口。
+    def __getitem__(self, idx):
+        if not self._fully_initialized:
+            warnings.warn('Please call `full_init` method manually to '
+                          'accelerate the speed.')
+            self.full_init()
+
+        sample_idx = self._get_ori_dataset_idx(idx)
+        return self.dataset[sample_idx]
+
+    # 提供与 `self.dataset` 一样的对外接口。
+    @force_full_init
+    def __len__(self):
+
+        '''
+        4. 在这里实现一些代码，来计算包装数据集之后的长度。
+        '''
+        len_wrapper = ...
+
+        return len_wrapper
+
+    # 提供与 `self.dataset` 一样的对外接口。
+    @property
+    def metainfo(self)
+        return copy.deepcopy(self._metainfo)
+```

testbed/open-mmlab__mmengine/docs/zh_cn/advanced_tutorials/config.md

@@ -0,0 +1,606 @@
+# 配置（Config）
+
+MMEngine 实现了抽象的配置类（Config），为用户提供统一的配置访问接口。配置类能够支持不同格式的配置文件，包括 `python`，`json`，`yaml`，用户可以根据需求选择自己偏好的格式。配置类提供了类似字典或者 Python 对象属性的访问接口，用户可以十分自然地进行配置字段的读取和修改。为了方便算法框架管理配置文件，配置类也实现了一些特性，例如配置文件的字段继承等。
+
+在开始教程之前，我们先将教程中需要用到的配置文件下载到本地（建议在临时目录下执行，方便后续删除示例配置文件）：
+
+```bash
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/config_sgd.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/cross_repo.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/custom_imports.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/demo_train.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/example.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/learn_read_config.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/my_module.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/optimizer_cfg.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/predefined_var.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/refer_base_var.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50_delete_key.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50_lr0.01.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50_runtime.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/resnet50.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/runtime_cfg.py
+wget https://raw.githubusercontent.com/open-mmlab/mmengine/main/docs/resources/config/modify_base_var.py
+```
+
+## 配置文件读取
+
+配置类提供了统一的接口 `Config.fromfile()`，来读取和解析配置文件。
+
+合法的配置文件应该定义一系列键值对，这里举几个不同格式配置文件的例子。
+
+Python 格式：
+
+```Python
+test_int = 1
+test_list = [1, 2, 3]
+test_dict = dict(key1='value1', key2=0.1)
+```
+
+Json 格式：
+
+```json
+{
+  "test_int": 1,
+  "test_list": [1, 2, 3],
+  "test_dict": {"key1": "value1", "key2": 0.1}
+}
+```
+
+YAML 格式：
+
+```yaml
+test_int: 1
+test_list: [1, 2, 3]
+test_dict:
+  key1: "value1"
+  key2: 0.1
+```
+
+对于以上三种格式的文件，假设文件名分别为 `config.py`，`config.json`，`config.yml`，调用 `Config.fromfile('config.xxx')` 接口加载这三个文件都会得到相同的结果，构造了包含 3 个字段的配置对象。我们以 `config.py` 为例，我们先将示例配置文件下载到本地：
+
+然后通过配置类的 `fromfile` 接口读取配置文件：
+
+```python
+from mmengine.config import Config
+
+cfg = Config.fromfile('learn_read_config.py')
+print(cfg)
+```
+
+```
+Config (path: learn_read_config.py): {'test_int': 1, 'test_list': [1, 2, 3], 'test_dict': {'key1': 'value1', 'key2': 0.1}}
+```
+
+## 配置文件的使用
+
+通过读取配置文件来初始化配置对象后，就可以像使用普通字典或者 Python 类一样来使用这个变量了。我们提供了两种访问接口，即类似字典的接口 `cfg['key']` 或者类似 Python 对象属性的接口 `cfg.key`。这两种接口都支持读写。
+
+```python
+print(cfg.test_int)
+print(cfg.test_list)
+print(cfg.test_dict)
+cfg.test_int = 2
+
+print(cfg['test_int'])
+print(cfg['test_list'])
+print(cfg['test_dict'])
+cfg['test_list'][1] = 3
+print(cfg['test_list'])
+```
+
+```
+1
+[1, 2, 3]
+{'key1': 'value1', 'key2': 0.1}
+2
+[1, 2, 3]
+{'key1': 'value1', 'key2': 0.1}
+[1, 3, 3]
+```
+
+注意，配置文件中定义的嵌套字段（即类似字典的字段），在 Config 中会将其转化为 ConfigDict 类，该类继承了 Python 内置字典类型的全部接口，同时也支持以对象属性的方式访问数据。
+
+在算法库中，可以将配置与注册器结合起来使用，达到通过配置文件来控制模块构造的目的。这里举一个在配置文件中定义优化器的例子。
+
+假设我们已经定义了一个优化器的注册器 OPTIMIZERS，包括了各种优化器。那么首先写一个 `config_sgd.py`：
+
+```python
+optimizer = dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.0001)
+```
+
+然后在算法库中可以通过如下代码构造优化器对象。
+
+```python
+from mmengine import Config, optim
+from mmengine.registry import OPTIMIZERS
+
+import torch.nn as nn
+
+cfg = Config.fromfile('config_sgd.py')
+
+model = nn.Conv2d(1, 1, 1)
+cfg.optimizer.params = model.parameters()
+optimizer = OPTIMIZERS.build(cfg.optimizer)
+print(optimizer)
+```
+
+```
+SGD (
+Parameter Group 0
+    dampening: 0
+    foreach: None
+    lr: 0.1
+    maximize: False
+    momentum: 0.9
+    nesterov: False
+    weight_decay: 0.0001
+)
+```
+
+## 配置文件的继承
+
+有时候，两个不同的配置文件之间的差异很小，可能仅仅只改了一个字段，我们就需要将所有内容复制粘贴一次，而且在后续观察的时候，不容易定位到具体差异的字段。又有些情况下，多个配置文件可能都有相同的一批字段，我们不得不在这些配置文件中进行复制粘贴，给后续的修改和维护带来了不便。
+
+为了解决这些问题，我们给配置文件增加了继承的机制，即一个配置文件 A 可以将另一个配置文件 B 作为自己的基础，直接继承了 B 中所有字段，而不必显式复制粘贴。
+
+### 继承机制概述
+
+这里我们举一个例子来说明继承机制。定义如下两个配置文件，
+
+`optimizer_cfg.py`：
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+`resnet50.py`：
+
+```python
+_base_ = ['optimizer_cfg.py']
+model = dict(type='ResNet', depth=50)
+```
+
+虽然我们在 `resnet50.py` 中没有定义 optimizer 字段，但由于我们写了 `_base_ = ['optimizer_cfg.py']`，会使这个配置文件获得 `optimizer_cfg.py` 中的所有字段。
+
+```python
+cfg = Config.fromfile('resnet50.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.02, 'momentum': 0.9, 'weight_decay': 0.0001}
+```
+
+这里 `_base_` 是配置文件的保留字段，指定了该配置文件的继承来源。支持继承多个文件，将同时获得这多个文件中的所有字段，但是要求继承的多个文件中**没有**相同名称的字段，否则会报错。
+
+`runtime_cfg.py`：
+
+```python
+gpu_ids = [0, 1]
+```
+
+`resnet50_runtime.py`：
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+```
+
+这时，读取配置文件 `resnet50_runtime.py` 会获得 3 个字段 `model`，`optimizer`，`gpu_ids`。
+
+```python
+cfg = Config.fromfile('resnet50_runtime.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.02, 'momentum': 0.9, 'weight_decay': 0.0001}
+```
+
+通过这种方式，我们可以将配置文件进行拆分，定义一些通用配置文件，在实际配置文件中继承各种通用配置文件，可以减少具体任务的配置流程。
+
+### 修改继承字段
+
+有时候，我们继承一个配置文件之后，可能需要对其中个别字段进行修改，例如继承了 `optimizer_cfg.py` 之后，想将学习率从 0.02 修改为 0.01。
+
+这时候，只需要在新的配置文件中，重新定义一下需要修改的字段即可。注意由于 optimizer 这个字段是一个字典，我们只需要重新定义这个字典里面需修改的下级字段即可。这个规则也适用于增加一些下级字段。
+
+`resnet50_lr0.01.py`：
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(lr=0.01)
+```
+
+读取这个配置文件之后，就可以得到期望的结果。
+
+```python
+cfg = Config.fromfile('resnet50_lr0.01.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.01, 'momentum': 0.9, 'weight_decay': 0.0001}
+```
+
+对于非字典类型的字段，例如整数，字符串，列表等，重新定义即可完全覆盖，例如下面的写法就将 `gpu_ids` 这个字段的值修改成了 `[0]`。
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+gpu_ids = [0]
+```
+
+### 删除字典中的 key
+
+有时候我们对于继承过来的字典类型字段，不仅仅是想修改其中某些 key，可能还需要删除其中的一些 key。这时候在重新定义这个字典时，需要指定 `_delete_=True`，表示将没有在新定义的字典中出现的 key 全部删除。
+
+`resnet50_delete_key.py`：
+
+```python
+_base_ = ['optimizer_cfg.py', 'runtime_cfg.py']
+model = dict(type='ResNet', depth=50)
+optimizer = dict(_delete_=True, type='SGD', lr=0.01)
+```
+
+这时候，`optimizer` 这个字典中就只有 `type` 和 `lr` 这两个 key，`momentum` 和 `weight_decay` 将不再被继承。
+
+```python
+cfg = Config.fromfile('resnet50_delete_key.py')
+print(cfg.optimizer)
+```
+
+```
+{'type': 'SGD', 'lr': 0.01}
+```
+
+### 引用被继承文件中的变量
+
+有时我们想重复利用 `_base_` 中定义的字段内容，就可以通过 `{{_base_.xxxx}}` 获取来获取对应变量的拷贝。例如：
+
+`refer_base_var.py`
+
+```python
+_base_ = ['resnet50.py']
+a = {{_base_.model}}
+```
+
+解析后发现，`a` 的值变成了 `resnet50.py` 中定义的 `model`
+
+```python
+cfg = Config.fromfile('refer_base_var.py')
+print(cfg.a)
+```
+
+```
+{'type': 'ResNet', 'depth': 50}
+```
+
+我们可以在 `json`、`yaml`、`python` 三种类型的配置文件中，使用这种方式来获取 `_base_` 中定义的变量。
+
+尽管这种获取 `_base_` 中定义变量的方式非常通用，但是在语法上存在一些限制，无法充分利用 `python` 类配置文件的动态特性。比如我们想在 `python` 类配置文件中，修改 `_base_` 中定义的变量：
+
+```python
+_base_ = ['resnet50.py']
+a = {{_base_.model}}
+a['type'] = 'MobileNet'
+```
+
+配置类是无法解析这样的配置文件的（解析时报错）。配置类提供了一种更 `pythonic` 的方式，让我们能够在 `python` 类配置文件中修改 `_base_` 中定义的变量（`python` 类配置文件专属特性，目前不支持在 `json`、`yaml` 配置文件中修改 `_base_` 中定义的变量）。
+
+`modify_base_var.py`：
+
+```python
+_base_ = ['resnet50.py']
+a = _base_.model
+a.type = 'MobileNet'
+```
+
+```python
+cfg = Config.fromfile('modify_base_var.py')
+print(cfg.a)
+```
+
+```
+{'type': 'MobileNet', 'depth': 50}
+```
+
+解析后发现，`a` 的 type 变成了 `MobileNet`。
+
+## 配置文件的导出
+
+在启动训练脚本时，用户可能通过传参的方式来修改配置文件的部分字段，为此我们提供了 `dump` 接口来导出更改后的配置文件。与读取配置文件类似，用户可以通过 `cfg.dump('config.xxx')` 来选择导出文件的格式。`dump` 同样可以导出有继承关系的配置文件，导出的文件可以被独立使用，不再依赖于 `_base_` 中定义的文件。
+
+基于继承一节定义的 `resnet50.py`，我们将其加载后导出：
+
+```python
+cfg = Config.fromfile('resnet50.py')
+cfg.dump('resnet50_dump.py')
+```
+
+`resnet50_dump.py`
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+model = dict(type='ResNet', depth=50)
+```
+
+类似的，我们可以导出 json、yaml 格式的配置文件
+
+`resnet50_dump.yaml`
+
+```yaml
+model:
+  depth: 50
+  type: ResNet
+optimizer:
+  lr: 0.02
+  momentum: 0.9
+  type: SGD
+  weight_decay: 0.0001
+```
+
+`resnet50_dump.json`
+
+```json
+{"optimizer": {"type": "SGD", "lr": 0.02, "momentum": 0.9, "weight_decay": 0.0001}, "model": {"type": "ResNet", "depth": 50}}
+```
+
+此外，`dump` 不仅能导出加载自文件的 `cfg`，还能导出加载自字典的 `cfg`
+
+```python
+cfg = Config(dict(a=1, b=2))
+cfg.dump('dump_dict.py')
+```
+
+`dump_dict.py`
+
+```python
+a=1
+b=2
+```
+
+## 其他进阶用法
+
+这里介绍一下配置类的进阶用法，这些小技巧可能使用户开发和使用算法库更简单方便。
+
+### 预定义字段
+
+有时候我们希望配置文件中的一些字段和当前路径或者文件名等相关，这里举一个典型使用场景的例子。在训练模型时，我们会在配置文件中定义一个工作目录，存放这组实验配置的模型和日志，那么对于不同的配置文件，我们期望定义不同的工作目录。用户的一种常见选择是，直接使用配置文件名作为工作目录名的一部分，例如对于配置文件 `predefined_var.py`，工作目录就是 `./work_dir/predefined_var`。
+
+使用预定义字段可以方便地实现这种需求，在配置文件 `predefined_var.py` 中可以这样写：
+
+```Python
+work_dir = './work_dir/{{fileBasenameNoExtension}}'
+```
+
+这里 `{{fileBasenameNoExtension}}` 表示该配置文件的文件名（不含拓展名），在配置类读取配置文件的时候，会将这种用双花括号包起来的字符串自动解析为对应的实际值。
+
+```python
+cfg = Config.fromfile('./predefined_var.py')
+print(cfg.work_dir)
+```
+
+```
+./work_dir/predefined_var
+```
+
+目前支持的预定义字段有以下四种，变量名参考自 [VS Code](https://code.visualstudio.com/docs/editor/variables-reference) 中的相关字段：
+
+- `{{fileDirname}}` - 当前文件的目录名，例如 `/home/your-username/your-project/folder`
+- `{{fileBasename}}` - 当前文件的文件名，例如 `file.py`
+- `{{fileBasenameNoExtension}}` - 当前文件不包含扩展名的文件名，例如 `file`
+- `{{fileExtname}}` - 当前文件的扩展名，例如 `.py`
+
+### 命令行修改配置
+
+有时候我们只希望修改部分配置，而不想修改配置文件本身，例如实验过程中想更换学习率，但是又不想重新写一个配置文件，常用的做法是在命令行传入参数来覆盖相关配置。考虑到我们想修改的配置通常是一些内层参数，如优化器的学习率、模型卷积层的通道数等，因此 MMEngine 提供了一套标准的流程，让我们能够在命令行里轻松修改配置文件中任意层级的参数。
+
+1. 使用 `argparse` 解析脚本运行的参数
+2. 使用 `argparse.ArgumentParser.add_argument` 方法时，让 `action` 参数的值为 [DictAction](mmengine.config.DictAction)，用它来进一步解析命令行参数中用于修改配置文件的参数
+3. 使用配置类的 `merge_from_dict` 方法来更新配置
+
+启动脚本示例如下：
+
+`demo_train.py`
+
+```python
+import argparse
+
+from mmengine.config import Config, DictAction
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Train a model')
+    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()
+```
+
+示例配置文件如下：
+
+`example.py`
+
+```python
+model = dict(type='CustomModel', in_channels=[1, 2, 3])
+optimizer = dict(type='SGD', lr=0.01)
+```
+
+我们在命令行里通过 `.` 的方式来访问配置文件中的深层配置，例如我们想修改学习率，只需要在命令行执行：
+
+```bash
+python demo_train.py ./example.py --cfg-options optimizer.lr=0.1
+```
+
+```
+Config (path: ./example.py): {'model': {'type': 'CustomModel', 'in_channels': [1, 2, 3]}, 'optimizer': {'type': 'SGD', 'lr': 0.1}}
+```
+
+我们成功地把学习率从 0.01 修改成 0.1。如果想改变列表、元组类型的配置，如上例中的 `in_channels`，则需要在命令行赋值时给 `()`，`[]` 外加上双引号：
+
+```bash
+python demo_train.py ./example.py --cfg-options model.in_channels="[1, 1, 1]"
+```
+
+```
+Config (path: ./example.py): {'model': {'type': 'CustomModel', 'in_channels': [1, 1, 1]}, 'optimizer': {'type': 'SGD', 'lr': 0.01}}
+```
+
+`model.in_channels` 已经从 \[1, 2, 3\] 修改成 \[1, 1, 1\]。
+
+```{note}
+上述流程只支持在命令行里修改字符串、整型、浮点型、布尔型、None、列表、元组类型的配置项。对于列表、元组类型的配置，里面每个元素的类型也必须为上述七种类型之一。
+```
+
+:::{note}
+`DictAction` 的行为与 `"extend"` 相似，支持多次传递，并保存在同一个列表中。如
+
+```bash
+python demo_train.py ./example.py --cfg-options optimizer.type="Adam" --cfg-options model.in_channels="[1, 1, 1]"
+```
+
+```
+Config (path: ./example.py): {'model': {'type': 'CustomModel', 'in_channels': [1, 1, 1]}, 'optimizer': {'type': 'Adam', 'lr': 0.01}}
+```
+
+:::
+
+### 导入自定义 Python 模块
+
+将配置与注册器结合起来使用时，如果我们往注册器中注册了一些自定义的类，就可能会遇到一些问题。因为读取配置文件的时候，这部分代码可能还没有被执行到，所以并未完成注册过程，从而导致构建自定义类的时候报错。
+
+例如我们新实现了一种优化器 `CustomOptim`，相应代码在 `my_module.py` 中。
+
+```python
+from mmengine.registry import OPTIMIZERS
+
+@OPTIMIZERS.register_module()
+class CustomOptim:
+    pass
+```
+
+我们为这个优化器的使用写了一个新的配置文件 `custom_imports.py`：
+
+```python
+optimizer = dict(type='CustomOptim')
+```
+
+那么就需要在读取配置文件和构造优化器之前，增加一行 `import my_module` 来保证将自定义的类 `CustomOptim` 注册到 OPTIMIZERS 注册器中：为了解决这个问题，我们给配置文件定义了一个保留字段 `custom_imports`，用于将需要提前导入的 Python 模块，直接写在配置文件中。对于上述例子，就可以将配置文件写成如下：
+
+`custom_imports.py`
+
+```python
+custom_imports = dict(imports=['my_module'], allow_failed_imports=False)
+optimizer = dict(type='CustomOptim')
+```
+
+这样我们就不用在训练代码中增加对应的 import 语句，只需要修改配置文件就可以实现非侵入式导入自定义注册模块。
+
+```python
+cfg = Config.fromfile('custom_imports.py')
+
+from mmengine.registry import OPTIMIZERS
+
+custom_optim = OPTIMIZERS.build(cfg.optimizer)
+print(custom_optim)
+```
+
+```
+<my_module.CustomOptim object at 0x7f6983a87970>
+```
+
+### 跨项目继承配置文件
+
+为了避免基于已有算法库开发新项目时需要复制大量的配置文件，MMEngine 的配置类支持配置文件的跨项目继承。例如我们基于 MMDetection 开发新的算法库，需要使用以下 MMDetection 的配置文件：
+
+```text
+configs/_base_/schedules/schedule_1x.py
+configs/_base_/datasets.coco_instance.py
+configs/_base_/default_runtime.py
+configs/_base_/models/faster-rcnn_r50_fpn.py
+```
+
+如果没有配置文件跨项目继承的功能，我们就需要把 MMDetection 的配置文件拷贝到当前项目，而我们现在只需要安装 MMDetection（如使用 `mim install mmdet`），在新项目的配置文件���按照以下方式继承 MMDetection 的配置文件：
+
+`cross_repo.py`
+
+```python
+_base_ = [
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/datasets/coco_instance.py',
+    'mmdet::_base_/default_runtime.py',
+    'mmdet::_base_/models/faster-rcnn_r50_fpn.py',
+]
+```
+
+我们可以像加载普通配置文件一样加载 `cross_repo.py`
+
+```python
+cfg = Config.fromfile('cross_repo.py')
+print(cfg.train_cfg)
+```
+
+```
+{'type': 'EpochBasedTrainLoop', 'max_epochs': 12, 'val_interval': 1, '_scope_': 'mmdet'}
+```
+
+通过指定 `mmdet::`，Config 类会去检索 mmdet 包中的配置文件目录，并继承指定的配置文件。实际上，只要算法库的 `setup.py` 文件符合 [MMEngine 安装规范](todo)，在正确安装算法库以后，新的项目就可以使用上述用法去继承已有算法库的配置文件而无需拷贝。
+
+### 跨项目获取配置文件
+
+MMEngine 还提供了 `get_config` 和 `get_model` 两个接口，支持对符合 [MMEngine 安装规范](todo) 的算法库中的模型和配置文件做索引并进行 API 调用。通过 `get_model` 接口可以获得构建好的模型。通过 `get_config` 接口可以获得配置文件。
+
+`get_model` 的使用样例如下所示，使用和跨项目继承配置文件相同的语法，指定 `mmdet::`，即可在 mmdet 包中检索对应的配置文件并构建和初始化相应模型。用户可以通过指定 `pretrained=True` 获得已经加载预训练权重的模型以进行训练或者推理。
+
+```python
+from mmengine.hub import get_model
+
+model = get_model(
+    'mmdet::faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py', pretrained=True)
+print(type(model))
+```
+
+```
+http loads checkpoint from path: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
+<class 'mmdet.models.detectors.faster_rcnn.FasterRCNN'>
+```
+
+`get_config` 的使用样例如下所示，使用和跨项目继承配置文件相同的语法，指定 `mmdet::`，即可实现去 mmdet 包中检索并加载对应的配置文件。用户可以基于这样得到的配置文件进行推理修改并自定义自己的算法模型。同时，如果用户指定 `pretrained=True`，得到的配置文件中会新增 `model_path` 字段，指定了对应模型预训练权重的路径。
+
+```python
+from mmengine.hub import get_config
+
+cfg = get_config(
+    'mmdet::faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py', pretrained=True)
+print(cfg.model_path)
+
+```
+
+```
+https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
+```

testbed/open-mmlab__mmengine/docs/zh_cn/advanced_tutorials/cross_library.md

@@ -0,0 +1,94 @@
+# 跨库调用模块
+
+通过使用 MMEngine 的[注册器（Registry）](registry.md)和[配置文件（Config）](config.md)，用户可以实现跨软件包的模块构建。
+例如，在 [MMDetection](https://github.com/open-mmlab/mmdetection) 中使用 [MMClassification](https://github.com/open-mmlab/mmclassification) 的 Backbone，或者在 [MMRotate](https://github.com/open-mmlab/mmrotate) 中使用 [MMDetection](https://github.com/open-mmlab/mmdetection) 的 Transform，或者在 [MMTracking](https://github.com/open-mmlab/mmtracking) 中使用 [MMDetection](https://github.com/open-mmlab/mmdetection) 的 Detector。
+一般来说，同类模块都可以进行跨库调用，只需要在配置文件的模块类型前加上软件包名的前缀即可。下面举几个常见的例子：
+
+## 跨库调用 Backbone:
+
+以在 MMDetection 中调用 MMClassification 的 ConvNeXt 为例，首先需要在配置中加入 `custom_imports` 字段将 MMClassification 的 Backbone 添加进注册器，然后只需要在 Backbone 的配置中的 `type` 加上 MMClassification 的软件包名 `mmcls` 作为前缀，即 `mmcls.ConvNeXt` 即可：
+
+```python
+# 使用 custom_imports 将 mmcls 的 models 添加进注册器
+custom_imports = dict(imports=['mmcls.models'], allow_failed_imports=False)
+
+model = dict(
+  type='MaskRCNN',
+  data_preprocessor=dict(...),
+  backbone=dict(
+      type='mmcls.ConvNeXt',  # 添加 mmcls 前缀完成跨库调用
+      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=
+          'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth',
+          prefix='backbone.')),
+  neck=dict(...),
+  rpn_head=dict(...))
+```
+
+## 跨库调用 Transform:
+
+与上文的跨库调用 Backbone 一样，使用 custom_imports 和添加前缀即可实现跨库调用：
+
+```python
+# 使用 custom_imports 将 mmdet 的 transforms 添加进注册器
+custom_imports = dict(imports=['mmdet.datasets.transforms'], allow_failed_imports=False)
+
+# 添加 mmdet 前缀完成跨库调用
+train_pipeline=[
+    dict(type='mmdet.LoadImageFromFile'),
+    dict(type='mmdet.LoadAnnotations', with_bbox=True, box_type='qbox'),
+    dict(type='ConvertBoxType', box_type_mapping=dict(gt_bboxes='rbox')),
+    dict(type='mmdet.Resize', scale=(1024, 2014), keep_ratio=True),
+    dict(type='mmdet.RandomFlip', prob=0.5),
+    dict(type='mmdet.PackDetInputs')
+]
+```
+
+## 跨库调用 Detector:
+
+跨库调用算法是一个比较复杂的例子，一个算法会包含多个子模块，因此每个子模块也需要在`type`中增加前缀，以在 MMTracking 中调用 MMDetection 的 YOLOX 为例：
+
+```python
+# 使用 custom_imports 将 mmdet 的 models 添加进注册器
+custom_imports = dict(imports=['mmdet.models'], allow_failed_imports=False)
+model = dict(
+    type='mmdet.YOLOX',
+    backbone=dict(type='mmdet.CSPDarknet', deepen_factor=1.33, widen_factor=1.25),
+    neck=dict(
+        type='mmdet.YOLOXPAFPN',
+        in_channels=[320, 640, 1280],
+        out_channels=320,
+        num_csp_blocks=4),
+    bbox_head=dict(
+        type='mmdet.YOLOXHead', num_classes=1, in_channels=320, feat_channels=320),
+    train_cfg=dict(assigner=dict(type='mmdet.SimOTAAssigner', center_radius=2.5)))
+```
+
+为了避免给每个子模块手动增加前缀，配置文件中引入了 `_scope_` 关键字，当某一模块的配置中添加了 `_scope_` 关键字后，该模块配置文件下面的所有子模块配置都会从该关键字所对应的软件包内去构建：
+
+```python
+# 使用 custom_imports 将 mmdet 的 models 添加进注册器
+custom_imports = dict(imports=['mmdet.models'], allow_failed_imports=False)
+model = dict(
+    _scope_='mmdet',  # 使用 _scope_ 关键字，避免给所有子模块添加前缀
+    type='YOLOX',
+    backbone=dict(type='CSPDarknet', deepen_factor=1.33, widen_factor=1.25),
+    neck=dict(
+        type='YOLOXPAFPN',
+        in_channels=[320, 640, 1280],
+        out_channels=320,
+        num_csp_blocks=4),
+    bbox_head=dict(
+        type='YOLOXHead', num_classes=1, in_channels=320, feat_channels=320),
+    train_cfg=dict(assigner=dict(type='SimOTAAssigner', center_radius=2.5)))
+```
+
+以上这两种写法互相等价。
+
+若希望了解更多关于注册器和配置文件的内容，请参考[配置文件教程](config.md)和[注册器教程](registry.md)

testbed/open-mmlab__mmengine/docs/zh_cn/advanced_tutorials/data_element.md

@@ -0,0 +1,1097 @@
+# 抽象数据接口
+
+在模型的训练/测试过程中，组件之间往往有大量的数据需要传递，不同的算法需要传递的数据经常是不一样的，例如，训练单阶段检测器需要获得数据集的标注框（ground truth bounding boxes）和标签（ground truth box labels），训练 Mask R-CNN 时还需要实例掩码（instance masks）。
+训练这些模型时的代码如下所示
+
+```python
+for img, img_metas, gt_bboxes, gt_labels in data_loader:
+    loss = retinanet(img, img_metas, gt_bboxes, gt_labels)
+```
+
+```python
+for img, img_metas, gt_bboxes, gt_masks, gt_labels in data_loader:
+    loss = mask_rcnn(img, img_metas, gt_bboxes, gt_masks, gt_labels)
+```
+
+可以发现，在不加封装的情况下，不同算法所需数据的不一致导致了不同算法模块之间接口的不一致，影响了算法库的拓展性，同时一个算法库内的模块为了保持兼容性往往在接口上存在冗余。
+上述弊端在算法库之间会体现地更加明显，导致在实现多任务（同时进行如语义分割、检测、关键点检测等多个任务）感知模型时模块难以复用，接口难以拓展。
+
+为了解决上述问题，MMEngine 定义了一套抽象的数据接口来封装模型运行过程中的各种数据。假设将上述不同的数据封装进 `data_sample` ，不同算法的训练都可以被抽象和统一成如下代码
+
+```python
+for img, data_sample in dataloader:
+    loss = model(img, data_sample)
+```
+
+通过对各种数据提供统一的封装，抽象数据接口统一并简化了算法库中各个模块的接口，可以被用于算法库中 dataset，model，visualizer，和 evaluator 组件之间，或者 model 内各个模块之间的数据传递。
+抽象数据接口实现了基本的增/删/改/查功能，同时支持不同设备之间的迁移，支持类字典和张量的操作，可以充分满足算法库对于这些数据的使用要求。
+基于 MMEngine 的算法库可以继承这套抽象数据接口并实现自己的抽象数据接口来适应不同算法中数据的特点与实际需要，在保持统一接口的同时提高了算法模块的拓展性。
+
+在实际实现过程中，算法库中的各个组件所具备的数据接口，一般为如下两个种：
+
+- 一个训练或测试样本(例如一张图像)的所有的标注信息和预测信息的集合，例如数据集的输出、模型以及可视化器的输入一般为单个训练或测试样本的所有信息。MMEngine将其定义为数据样本(DataSample)
+- 单一类型的预测或标注，一般是算法模型中某个子模块的输出, 例如二阶段检测中RPN的输出、语义分割模型的输出、关键点分支的输出， GAN中生成器的输出等。MMengine将其定义为数据元素(XXXData)
+
+下边首先介绍一下数据样本与数据元素的基类 [BaseDataElement](mmengine.structures.BaseDataElement)。
+
+## 数据基类(BaseDataElement)
+
+`BaseDataElement` 中存在两种类型的数据，一种是 `data` 类型，如标注框、框的标签、和实例掩码等；另一种是 `metainfo` 类型，包含数据的元信息以确保数据的完整性，如 `img_shape`, `img_id` 等数据所在图片的一些基本信息，方便可视化等情况下对数据进行恢复和使用。用户在创建 `BaseDataElement` 的过程中需要对这两类属性的数据进行显式地区分和声明。
+
+为了能够更加方便地使用 `BaseDataElement`，`data` 和 `metainfo` 中的数据均为 `BaseDataElement` 的属性。我们可以通过访问类属性的方式直接访问 `data` 和 `metainfo` 中的数据。此外，`BaseDataElement` 还提供了很多方法，方便我们操作 `data` 内的数据：
+
+- 增/删/改/查 `data` 中不同字段的数据
+- 将 `data` 迁移至目标设备
+- 支持像访问字典/张量一样访问 data 内的数据
+  以充分满足算法库对于这些数据的使用要求。
+
+### 1. 数据元素的创建
+
+`BaseDataElement` 的 data 参数可以直接通过 `key=value` 的方式自由添加，metainfo 的字段需要显式通过关键字 `metainfo` 指定。
+
+```python
+import torch
+from mmengine.structures import BaseDataElement
+# 可以声明一个空的 object
+data_element = BaseDataElement()
+
+bboxes = torch.rand((5, 4))  # 假定 bboxes 是一个 Nx4 维的 tensor，N 代表框的个数
+scores = torch.rand((5,))  # 假定框的分数是一个 N 维的 tensor，N 代表框的个数
+img_id = 0  # 图像的 ID
+H = 800  # 图像的高度
+W = 1333  # 图像的宽度
+
+# 直接设置 BaseDataElement 的 data 参数
+data_element = BaseDataElement(bboxes=bboxes, scores=scores)
+
+# 显式声明来设置 BaseDataElement 的参数 metainfo
+data_element = BaseDataElement(
+    bboxes=bboxes,
+    scores=scores,
+    metainfo=dict(img_id=img_id, img_shape=(H, W)))
+```
+
+### 2. `new` 与 `clone` 函数
+
+用户可以使用 `new()` 函数通过已有的数据接口创建一个具有相同状态和数据的抽象数据接口。用户可以在创��新 `BaseDataElement` 时设置 `metainfo` 和 `data`，用于创建仅 `data` 或 `metainfo` 具有相同状态和数据的抽象接口。比如 `new(metainfo=xx)` 使得新的 `BaseDataElement` 与被 clone 的 `BaseDataElement` 包含相同的 `data` 内容，但 `metainfo` 为新设置的内容。
+也可以直接使用 `clone()` 来获得一份深拷贝，`clone()` 函数的行为与 PyTorch 中 Tensor 的 `clone()` 参数保持一致。
+
+```python
+data_element = BaseDataElement(
+    bboxes=torch.rand((5, 4)),
+    scores=torch.rand((5,)),
+    metainfo=dict(img_id=1, img_shape=(640, 640)))
+
+# 可以在创建新 `BaseDataElement` 时设置 metainfo 和 data，使得新的 BaseDataElement 有相同未被设置的数据
+data_element1 = data_element.new(metainfo=dict(img_id=2, img_shape=(320, 320)))
+print('bboxes is in data_element1:', 'bboxes' in data_element1) # True
+print('bboxes in data_element1 is same as bbox in data_element', (data_element1.bboxes == data_element.bboxes).all())
+print('img_id in data_element1 is', data_element1.img_id == 2) # True
+
+data_element2 = data_element.new(label=torch.rand(5,))
+print('bboxes is not in data_element2', 'bboxes' not in data_element2) # True
+print('img_id in data_element2 is same as img_id in data_element', data_element2.img_id == data_element.img_id)
+print('label in data_element2 is', 'label' in data_element2)
+
+# 也可以通过 `clone` 构建一个新的 object，新的 object 会拥有和 data_element 相同的 data 和 metainfo 内容以及状态。
+data_element2 = data_element1.clone()
+```
+
+```
+bboxes is in data_element1: True
+bboxes in data_element1 is same as bbox in data_element tensor(True)
+img_id in data_element1 is True
+bboxes is not in data_element2 True
+img_id in data_element2 is same as img_id in data_element True
+label in data_element2 is True
+```
+
+### 3. 属性的增加与查询
+
+对增加属性而言，用户可以像增加类属性那样增加 `data` 内的属性；对`metainfo` 而言，一般储存的为一些图像的元信息，一般情况下不会修改，如果需要增加，用户应当使用 `set_metainfo` 接口显示地修改。
+
+对查询而言，用户可以可以通过 `keys`，`values`，和 `items` 来访问只存在于 data 中的键值，也可以通过 `metainfo_keys`，`metainfo_values`，和`metainfo_items` 来访问只存在于 metainfo 中的键值。
+用户还能通过 `all_keys`，`all_values`， `all_items` 来访问 `BaseDataElement` 的所有的属性并且不区分他们的类型。
+
+同时为了方便使用，用户可以像访问类属性一样访问 data 与 metainfo 内的数据，或着类字典方式通过 `get()` 接口访问数据。
+
+**注意：**
+
+1. `BaseDataElement` 不支持 metainfo 和 data 属性中有同名的字段，所以用户应当避免 metainfo 和 data 属性中设置相同的字段，否则 `BaseDataElement` 会报错。
+2. 考虑到 `InstanceData` 和 `PixelData` 支持对数据进行切片操作，为了避免 `[]` 用法的不一致，同时减少同种需求的不同方法，`BaseDataElement` 不支持像字典那样访问和设置它的属性，所以类似 `BaseDataElement[name]` 的取值赋值操作是不被支持的。
+
+```python
+data_element = BaseDataElement()
+# 通过 `set_metainfo`设置 data_element 的 metainfo 字段，
+# 同时 img_id 和 img_shape 成为 data_element 的属性
+data_element.set_metainfo(dict(img_id=9, img_shape=(100, 100)))
+# 查看 metainfo 的 key, value 和 item
+print("metainfo'keys are", data_element.metainfo_keys())
+print("metainfo'values are", data_element.metainfo_values())
+for k, v in data_element.metainfo_items():
+    print(f'{k}: {v}')
+
+print("通过类属性查看 img_id 和 img_shape")
+print('img_id:', data_element.img_id)
+print('img_shape:', data_element.img_shape)
+```
+
+```
+metainfo'keys are ['img_id', 'img_shape']
+metainfo'values are [9, (100, 100)]
+img_id: 9
+img_shape: (100, 100)
+通过类属性查看 img_id 和 img_shape
+img_id: 9
+img_shape: (100, 100)
+```
+
+```python
+
+# 通过类属性直接设置 BaseDataElement 中的 data 字段
+data_element.scores = torch.rand((5,))
+data_element.bboxes = torch.rand((5, 4))
+
+print("data's key is:", data_element.keys())
+print("data's value is:", data_element.values())
+for k, v in data_element.items():
+    print(f'{k}: {v}')
+
+print("通过类属性查看 scores 和 bboxes")
+print('scores:', data_element.scores)
+print('bboxes:', data_element.bboxes)
+
+print("通过 get() 查看 scores 和 bboxes")
+print('scores:', data_element.get('scores', None))
+print('bboxes:', data_element.get('bboxes', None))
+print('fake:', data_element.get('fake', 'not exist'))
+```
+
+```
+data's key is: ['scores', 'bboxes']
+data's value is: [tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515]), tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+        [0.7993, 0.8982, 0.5698, 0.4120],
+        [0.7085, 0.7016, 0.3069, 0.3216],
+        [0.0206, 0.5253, 0.1376, 0.9322],
+        [0.2512, 0.7683, 0.3010, 0.2672]])]
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+        [0.7993, 0.8982, 0.5698, 0.4120],
+        [0.7085, 0.7016, 0.3069, 0.3216],
+        [0.0206, 0.5253, 0.1376, 0.9322],
+        [0.2512, 0.7683, 0.3010, 0.2672]])
+通过类属性查看 scores 和 bboxes
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+        [0.7993, 0.8982, 0.5698, 0.4120],
+        [0.7085, 0.7016, 0.3069, 0.3216],
+        [0.0206, 0.5253, 0.1376, 0.9322],
+        [0.2512, 0.7683, 0.3010, 0.2672]])
+通过 get() 查看 scores 和 bboxes
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+        [0.7993, 0.8982, 0.5698, 0.4120],
+        [0.7085, 0.7016, 0.3069, 0.3216],
+        [0.0206, 0.5253, 0.1376, 0.9322],
+        [0.2512, 0.7683, 0.3010, 0.2672]])
+fake: not exist
+```
+
+```python
+
+print("All key in data_element is:", data_element.all_keys())
+print("The length of values in data_element is", len(data_element.all_values()))
+for k, v in data_element.all_items():
+    print(f'{k}: {v}')
+```
+
+```
+All key in data_element is: ['img_id', 'img_shape', 'scores', 'bboxes']
+The length of values in data_element is 4
+img_id: 9
+img_shape: (100, 100)
+scores: tensor([0.7937, 0.6307, 0.3682, 0.4425, 0.8515])
+bboxes: tensor([[0.9204, 0.2110, 0.2886, 0.7925],
+        [0.7993, 0.8982, 0.5698, 0.4120],
+        [0.7085, 0.7016, 0.3069, 0.3216],
+        [0.0206, 0.5253, 0.1376, 0.9322],
+        [0.2512, 0.7683, 0.3010, 0.2672]])
+```
+
+### 4. 属性的删改
+
+用户可以像修改实例属性一样修改 `BaseDataElement` 的 `data`, 对`metainfo` 而言 一般储存的为一些图像的元信息，一般情况下不会修改，如果需要修改，用户应当使用 `set_metainfo` 接口显示的修改。
+
+同时为了操作的便捷性，对 `data` 和 `metainfo` 中的数据可以通过 `del` 直接删除，也支持 `pop` 在访问属性后删除属性。
+
+```python
+data_element = BaseDataElement(
+    bboxes=torch.rand((6, 4)), scores=torch.rand((6,)),
+    metainfo=dict(img_id=0, img_shape=(640, 640))
+)
+for k, v in data_element.all_items():
+    print(f'{k}: {v}')
+```
+
+```
+img_id: 0
+img_shape: (640, 640)
+scores: tensor([0.8445, 0.6678, 0.8172, 0.9125, 0.7186, 0.5462])
+bboxes: tensor([[0.5773, 0.0289, 0.4793, 0.7573],
+        [0.8187, 0.8176, 0.3455, 0.3368],
+        [0.6947, 0.5592, 0.7285, 0.0281],
+        [0.7710, 0.9867, 0.7172, 0.5815],
+        [0.3999, 0.9192, 0.7817, 0.2535],
+        [0.2433, 0.0132, 0.1757, 0.6196]])
+```
+
+```python
+# 对 data 进行修改
+data_element.bboxes = data_element.bboxes * 2
+data_element.scores = data_element.scores * -1
+for k, v in data_element.items():
+    print(f'{k}: {v}')
+
+# 删除 data 中的属性
+del data_element.bboxes
+for k, v in data_element.items():
+    print(f'{k}: {v}')
+
+data_element.pop('scores', None)
+print('The keys in data is', data_element.keys())
+```
+
+```
+scores: tensor([-0.8445, -0.6678, -0.8172, -0.9125, -0.7186, -0.5462])
+bboxes: tensor([[1.1546, 0.0578, 0.9586, 1.5146],
+        [1.6374, 1.6352, 0.6911, 0.6735],
+        [1.3893, 1.1185, 1.4569, 0.0562],
+        [1.5420, 1.9734, 1.4344, 1.1630],
+        [0.7999, 1.8384, 1.5635, 0.5070],
+        [0.4867, 0.0264, 0.3514, 1.2392]])
+scores: tensor([-0.8445, -0.6678, -0.8172, -0.9125, -0.7186, -0.5462])
+The keys in data is []
+```
+
+```python
+# 对 metainfo 进行修改
+data_element.set_metainfo(dict(img_shape = (1280, 1280), img_id=10))
+print(data_element.img_shape)  # (1280, 1280)
+for k, v in data_element.metainfo_items():
+    print(f'{k}: {v}')
+
+# 提供了便捷的属性删除和访问操作 pop
+del data_element.img_shape
+for k, v in data_element.metainfo_items():
+    print(f'{k}: {v}')
+
+data_element.pop('img_id')
+print('The keys in metainfo is', data_element.metainfo_keys())
+```
+
+```
+(1280, 1280)
+img_id: 10
+img_shape: (1280, 1280)
+img_id: 10
+The keys in metainfo is []
+```
+
+### 5. 类张量操作
+
+用户可以像 torch.Tensor 那样对 `BaseDataElement` 的 data 进行状态转换，目前支持 `cuda`， `cpu`， `to`， `numpy` 等操作。
+其中，`to` 函数拥有和 `torch.Tensor.to()` 相同的接口，使得用户可以灵活地将被封装的 tensor 进行状态转换。
+**注意：** 这些接口只会处理类型为 np.array，torch.Tensor，或者数字的序列，其他属性的数据（如字符串）会被跳过处理。
+
+```python
+data_element = BaseDataElement(
+    bboxes=torch.rand((6, 4)), scores=torch.rand((6,)),
+    metainfo=dict(img_id=0, img_shape=(640, 640))
+)
+# 将所有 data 转移到 GPU 上
+cuda_element_1 = data_element.cuda()
+print('cuda_element_1 is on the device of', cuda_element_1.bboxes.device)  # cuda:0
+cuda_element_2 = data_element.to('cuda:0')
+print('cuda_element_1 is on the device of', cuda_element_2.bboxes.device)  # cuda:0
+
+# 将所有 data 转移到 cpu 上
+cpu_element_1 = cuda_element_1.cpu()
+print('cpu_element_1 is on the device of', cpu_element_1.bboxes.device)  # cpu
+cpu_element_2 = cuda_element_2.to('cpu')
+print('cpu_element_2 is on the device of', cpu_element_2.bboxes.device)  # cpu
+
+# 将所有 data 变成 FP16
+fp16_instances = cuda_element_1.to(
+    device=None, dtype=torch.float16, non_blocking=False, copy=False,
+    memory_format=torch.preserve_format)
+print('The type of bboxes in fp16_instances is', fp16_instances.bboxes.dtype)  # torch.float16
+
+# 阻断所有 data 的梯度
+cuda_element_3 = cuda_element_2.detach()
+print('The data in cuda_element_3 requires grad: ', cuda_element_3.bboxes.requires_grad)
+# 转移 data 到 numpy array
+np_instances = cpu_element_1.numpy()
+print('The type of cpu_element_1 is convert to', type(np_instances.bboxes))
+```
+
+```
+cuda_element_1 is on the device of cuda:0
+cuda_element_1 is on the device of cuda:0
+cpu_element_1 is on the device of cpu
+cpu_element_2 is on the device of cpu
+The type of bboxes in fp16_instances is torch.float16
+The data in cuda_element_3 requires grad:  False
+The type of cpu_element_1 is convert to <class 'numpy.ndarray'>
+```
+
+### 6. 属性的展示
+
+`BaseDataElement` 还实现了 `__repr__`，因此，用户可以直接通过 `print` 函数看到其中的所有数据信息。
+同时，为了便捷开发者 debug，`BaseDataElement` 中的属性都会添加进 `__dict__` 中，方便用户在 IDE 界面可以直观看到 `BaseDataElement` 中的内容。
+一个完整的属性展示如下
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = BaseDataElement(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([0, 1, 2, 3])
+instance_data.det_scores = torch.Tensor([0.01, 0.1, 0.2, 0.3])
+print(instance_data)
+```
+
+```
+<BaseDataElement(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([0, 1, 2, 3])
+    det_scores: tensor([0.0100, 0.1000, 0.2000, 0.3000])
+) at 0x7f9f339f85b0>
+```
+
+## 数据元素(xxxData)
+
+MMEngine 将数据元素情况划分为三个类别:
+
+- 实例数据(InstanceData): 主要针对的是上层任务(high-level)中，对图像中所有实例相关的数据进行封装，比如检测框(bounding boxes), 物体类别(box labels),实例掩码(instance masks), 关键点(key points), 文字边界(polygons), 跟踪id(tracking ids) 等. 所有实例相关的数据的**长度一致**，均为图像中实例的个数。
+- 像素数据(PixelData): 主要针对底层任务(low-level) 以及需要感知像素级别标签的部分上层任务。像素数据对像素级相关的数据进行封装，比如语义分割中的分割图（segmentation map）, 光流任务中的光流图（flow map）, 全景分割中的全景分割图（panoptic seg map）；底层任务中生成的各种图像，比如超分辨图，去噪图，以及生成的各种风格图。这些数据的特点是都是三维或四维数组，最后两维度为数据的高度(height)和宽度(width)，且具有相同的height和width
+- 标签数据(LabelData): 主要标签级别的数据进行封装，比如图像分类，多分类中的类别，图像生成中生成图像的类别内容，或者文字识别中的文本等。
+
+### InstanceData
+
+[`InstanceData`](mmengine.structures.InstanceData) 在 `BaseDataElement` 的基础上，对 `data` 存储的数据做了限制，即要求存储在 `data` 中的数据的长度一致。比如在目标检测中, 假设一张图像中有 N 个目标(instance)，可以将图像的所有边界框(bbox)，类别(label)等存储在 `InstanceData` 中, `InstanceData` 的 bbox 和 label 的长度相同。
+基于上述假定对 `InstanceData`进行了扩展，包括：
+
+- 对 `InstanceData` 中 data 所存储的数据进行了长度校验
+- data 部分支持类字典访问和设置它的属性
+- 支持基础索引，切片以及高级索引功能
+- 支持具有**相同的 `key`** 但是不同 `InstanceData` 的拼接功能。
+  这些扩展功能除了支持基础的数据结构， 比如`torch.tensor`, `numpy.dnarray`, `list`, `str`, `tuple`, 也可以是自定义的数据结构，只要自定义数据结构实现了 `__len__`, `__getitem__` and `cat`.
+
+#### 数据校验
+
+`InstanceData` 中 data 的数据长度要保持一致，如果传入不同长度的新数据，将会报错。
+
+```python
+from mmengine.structures import InstanceData
+import torch
+import numpy as np
+
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data.det_scores = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print('The length of instance_data is', len(instance_data))  # 2
+
+instance_data.bboxes = torch.rand((3, 4))
+```
+
+```
+The length of instance_data is 2
+AssertionError: the length of values 3 is not consistent with the length of this :obj:`InstanceData` 2
+```
+
+### 类字典访问和设置属性
+
+`InstanceData` 支持类似字典的操作访问和设置其 **data** 属性。
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data["det_labels"] = torch.LongTensor([2, 3])
+instance_data["det_scores"] = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print(instance_data)
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([2, 3])
+    det_scores: tensor([0.8000, 0.7000])
+    bboxes: tensor([[0.6576, 0.5435, 0.5253, 0.8273],
+                [0.4533, 0.6848, 0.7230, 0.9279]])
+) at 0x7f9f339f8ca0>
+```
+
+#### 索引与切片
+
+`InstanceData` 支持 Python 中类似列表的索引与切片，同时也支持类似 numpy 的高级索引操作。
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data.det_scores = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print(instance_data)
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([2, 3])
+    det_scores: tensor([0.8000, 0.7000])
+    bboxes: tensor([[0.1872, 0.1669, 0.7563, 0.8777],
+                [0.3421, 0.7104, 0.6000, 0.1518]])
+) at 0x7f9f312b4dc0>
+```
+
+1. 索引
+
+```python
+print(instance_data[1])
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([3])
+    det_scores: tensor([0.7000])
+    bboxes: tensor([[0.3421, 0.7104, 0.6000, 0.1518]])
+) at 0x7f9f312b4610>
+```
+
+2. 切片
+
+```python
+print(instance_data[0:1])
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([2])
+    det_scores: tensor([0.8000])
+    bboxes: tensor([[0.1872, 0.1669, 0.7563, 0.8777]])
+) at 0x7f9f312b4e20>
+```
+
+3. 高级索引
+
+- 列表索引
+
+```python
+sorted_results = instance_data[instance_data.det_scores.sort().indices]
+print(sorted_results)
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([3, 2])
+    det_scores: tensor([0.7000, 0.8000])
+    bboxes: tensor([[0.3421, 0.7104, 0.6000, 0.1518],
+                [0.1872, 0.1669, 0.7563, 0.8777]])
+) at 0x7f9f312b4a90>
+```
+
+- 布尔索引
+
+```python
+filter_results = instance_data[instance_data.det_scores > 0.75]
+print(filter_results)
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([2])
+    det_scores: tensor([0.8000])
+    bboxes: tensor([[0.1872, 0.1669, 0.7563, 0.8777]])
+) at 0x7fa061299dc0>
+```
+
+4. 结果为空
+
+```python
+empty_results = instance_data[instance_data.det_scores > 1]
+print(empty_results)
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([], dtype=torch.int64)
+    det_scores: tensor([])
+    bboxes: tensor([], size=(0, 4))
+) at 0x7f9f439cccd0>
+```
+
+#### 拼接(cat)
+
+用户可以将两个具有相同 key 的 `InstanceData` 拼接成一个 `InstanceData`。对于长度分别为 N 和 M 的两个 `InstanceData`， 拼接后为长度 N + M 的新的 `InstanceData`
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data.det_scores = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+print('The length of instance_data is', len(instance_data))
+cat_results = InstanceData.cat([instance_data, instance_data])
+print('The length of instance_data is', len(cat_results))
+print(cat_results)
+```
+
+```
+The length of instance_data is 2
+The length of instance_data is 4
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([2, 3, 2, 3])
+    det_scores: tensor([0.8000, 0.7000, 0.8000, 0.7000])
+    bboxes: tensor([[0.5341, 0.8962, 0.9043, 0.2824],
+                [0.3864, 0.2215, 0.7610, 0.7060],
+                [0.5341, 0.8962, 0.9043, 0.2824],
+                [0.3864, 0.2215, 0.7610, 0.7060]])
+) at 0x7fa061d4a9d0>
+```
+
+#### 自定义数据结构
+
+对于自定义结构如果想使用上述扩展要求需要实现`__len__`, `__getitem__` 和 `cat`三个接口.
+
+```python
+import itertools
+
+class TmpObject:
+    def __init__(self, tmp) -> None:
+        assert isinstance(tmp, list)
+        self.tmp = tmp
+
+    def __len__(self):
+        return len(self.tmp)
+
+    def __getitem__(self, item):
+        if type(item) == int:
+            if item >= len(self) or item < -len(self):  # type:ignore
+                raise IndexError(f'Index {item} out of range!')
+            else:
+                # keep the dimension
+                item = slice(item, None, len(self))
+        return TmpObject(self.tmp[item])
+
+    @staticmethod
+    def cat(tmp_objs):
+        assert all(isinstance(results, TmpObject) for results in tmp_objs)
+        if len(tmp_objs) == 1:
+            return tmp_objs[0]
+        tmp_list = [tmp_obj.tmp for tmp_obj in tmp_objs]
+        tmp_list = list(itertools.chain(*tmp_list))
+        new_data = TmpObject(tmp_list)
+        return new_data
+
+    def __repr__(self):
+        return str(self.tmp)
+```
+
+```python
+img_meta = dict(img_shape=(800, 1196, 3), pad_shape=(800, 1216, 3))
+instance_data = InstanceData(metainfo=img_meta)
+instance_data.det_labels = torch.LongTensor([2, 3])
+instance_data["det_scores"] = torch.Tensor([0.8, 0.7])
+instance_data.bboxes = torch.rand((2, 4))
+instance_data.polygons = TmpObject([[1, 2, 3, 4], [5, 6, 7, 8]])
+print(instance_data)
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    det_labels: tensor([2, 3])
+    polygons: [[1, 2, 3, 4], [5, 6, 7, 8]]
+    det_scores: tensor([0.8000, 0.7000])
+    bboxes: tensor([[0.4207, 0.0778, 0.9959, 0.1967],
+                [0.4679, 0.7934, 0.5372, 0.4655]])
+) at 0x7fa061b5d2b0>
+```
+
+```python
+# 高级索引
+print(instance_data[instance_data.det_scores > 0.75])
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    bboxes: tensor([[0.4207, 0.0778, 0.9959, 0.1967]])
+    det_labels: tensor([2])
+    det_scores: tensor([0.8000])
+    polygons: [[1, 2, 3, 4]]
+) at 0x7f9f312716d0>
+```
+
+```python
+# 拼接
+print(InstanceData.cat([instance_data, instance_data]))
+```
+
+```
+<InstanceData(
+
+    META INFORMATION
+    pad_shape: (800, 1216, 3)
+    img_shape: (800, 1196, 3)
+
+    DATA FIELDS
+    bboxes: tensor([[0.4207, 0.0778, 0.9959, 0.1967],
+                [0.4679, 0.7934, 0.5372, 0.4655],
+                [0.4207, 0.0778, 0.9959, 0.1967],
+                [0.4679, 0.7934, 0.5372, 0.4655]])
+    det_labels: tensor([2, 3, 2, 3])
+    det_scores: tensor([0.8000, 0.7000, 0.8000, 0.7000])
+    polygons: [[1, 2, 3, 4], [5, 6, 7, 8], [1, 2, 3, 4], [5, 6, 7, 8]]
+) at 0x7f9f31271490>
+```
+
+### PixelData
+
+[`PixelData`](mmengine.structures.PixelData) 在 `BaseDataElement` 的基础上，同样对对 data 中存储的数据做了限制:
+
+- 所有 data 内的数据均为 3 维，并且顺序为 (通道，高， 宽)
+- 所有在 data 内的数据要有相同的长和宽
+  基于上述假定对 `PixelData`进行了扩展，包括：
+- 对 `PixelData` 中 data 所存储的数据进行了尺寸的校验
+- 支持对 data 部分的数据对实例进行空间维度的索引和切片。
+
+### 数据校验
+
+`PixelData` 会对传入到 data 的数据进行维度与长宽的校验。
+
+```python
+from mmengine.structures import PixelData
+import random
+import torch
+import numpy as np
+metainfo = dict(
+    img_id=random.randint(0, 100),
+    img_shape=(random.randint(400, 600), random.randint(400, 600)))
+image = np.random.randint(0, 255, (4, 20, 40))
+featmap = torch.randint(0, 255, (10, 20, 40))
+pixel_data = PixelData(metainfo=metainfo,
+                       image=image,
+                       featmap=featmap)
+print('The shape of pixel_data is', pixel_data.shape)
+# set
+pixel_data.map3 = torch.randint(0, 255, (20, 40))
+print('The shape of pixel_data is', pixel_data.map3.shape)
+```
+
+```
+The shape of pixel_data is (20, 40)
+The shape of pixel_data is torch.Size([1, 20, 40])
+```
+
+```python
+pixel_data.map2 = torch.randint(0, 255, (3, 20, 30))
+# AssertionError: the height and width of values (20, 30) is not consistent with the length of this :obj:`PixelData` (20, 40)
+```
+
+```
+AssertionError: the height and width of values (20, 30) is not consistent with the length of this :obj:`PixelData` (20, 40)
+```
+
+```python
+pixel_data.map2 = torch.randint(0, 255, (1, 3, 20, 40))
+# AssertionError: The dim of value must be 2 or 3, but got 4
+```
+
+```
+AssertionError: The dim of value must be 2 or 3, but got 4
+```
+
+### 空间维度索引
+
+`PixelData` 支持对 data 部分的数据对实例进行空间维度的索引和切片，只需传入长宽的索引即可。
+
+```python
+metainfo = dict(
+    img_id=random.randint(0, 100),
+    img_shape=(random.randint(400, 600), random.randint(400, 600)))
+image = np.random.randint(0, 255, (4, 20, 40))
+featmap = torch.randint(0, 255, (10, 20, 40))
+pixel_data = PixelData(metainfo=metainfo,
+                       image=image,
+                       featmap=featmap)
+print('The shape of pixel_data is', pixel_data.shape)
+```
+
+```
+The shape of pixel_data is (20, 40)
+```
+
+- 索引
+
+```python
+index_data = pixel_data[10, 20]
+print('The shape of index_data is', index_data.shape)
+```
+
+```
+The shape of index_data is (1, 1)
+```
+
+- 切片
+
+```python
+slice_data = pixel_data[10:20, 20:40]
+print('The shape of slice_data is', slice_data.shape)
+```
+
+```
+The shape of slice_data is (10, 20)
+```
+
+### LabelData
+
+[`LabelData`](mmengine.structures.LabelData) 主要用来封装标签数据，如场景分类标签，文字识别标签等。`LabelData` 没有对 data 做任何限制，只提供了两个额外功能：onehot 与 index 的转换。
+
+```python
+from mmengine.structures import LabelData
+import torch
+
+item = torch.tensor([1], dtype=torch.int64)
+num_classes = 10
+
+```
+
+```python
+onehot = LabelData.label_to_onehot(label=item, num_classes=num_classes)
+print(f'{num_classes} is convert to ', onehot)
+
+index = LabelData.onehot_to_label(onehot=onehot)
+print(f'{onehot} is convert to ', index)
+```
+
+```
+10 is convert to  tensor([0, 1, 0, 0, 0, 0, 0, 0, 0, 0])
+tensor([0, 1, 0, 0, 0, 0, 0, 0, 0, 0]) is convert to tensor([1])
+```
+
+## 数据样本(DataSample)
+
+数据样本作为不同模块最外层的接口，提供了 xxxDataSample 用于单任务中各模块之间统一格式的传递，同时为了各个模块从统一字段获取或写入信息，数据样本中的命名以及类型要进行约束和统一，保证各模块接口的统一性。 OpenMMLab 中各个算法库的命名规范可以参考 [`OpenMMLab` 中的命名规范](命名规范.md)。
+
+### 下游库使用
+
+以 MMDet 为例，说明下游库中数据样本的使用，以及数据样本字段的约束和命名。MMDet 中定义了 `DetDataSample`, 同时定义了 7 个字段，分别为：
+
+- 标注信息
+  - gt_instance(InstanceData): 实例标注信息，包括实例的类别、边界框等， 类型约束为 `InstanceData`。
+  - gt_panoptic_seg(PixelData): 全景分割的标注信息，类型约束为 `PixelData`。
+  - gt_semantic_seg(PixelData): 语义分割的标注信息， 类型约束为 `PixelData`。
+- 预测结果
+  - pred_instance(InstanceData): 实例预测结果，包括实例的类别、边界框等， 类型约束为 `InstanceData`。
+  - pred_panoptic_seg(PixelData): 全景分割的预测结果，类型约束为 `PixelData`。
+  - pred_semantic_seg(PixelData): 语义分割的预测结果， 类型约束为 `PixelData`。
+- 中间结果
+  - proposal(InstanceData): 主要为二阶段中 RPN 的预测结果， 类型约束为 `InstanceData`。
+
+```python
+from mmengine.structures import BaseDataElement
+import torch
+
+class DetDataSample(BaseDataElement):
+
+    # 标注
+    @property
+    def gt_instances(self) -> InstanceData:
+        return self._gt_instances
+
+    @gt_instances.setter
+    def gt_instances(self, value: InstanceData):
+        self.set_field(value, '_gt_instances', dtype=InstanceData)
+
+    @gt_instances.deleter
+    def gt_instances(self):
+        del self._gt_instances
+
+    @property
+    def gt_panoptic_seg(self) -> PixelData:
+        return self._gt_panoptic_seg
+
+    @gt_panoptic_seg.setter
+    def gt_panoptic_seg(self, value: PixelData):
+        self.set_field(value, '_gt_panoptic_seg', dtype=PixelData)
+
+    @gt_panoptic_seg.deleter
+    def gt_panoptic_seg(self):
+        del self._gt_panoptic_seg
+
+    @property
+    def gt_sem_seg(self) -> PixelData:
+        return self._gt_sem_seg
+
+    @gt_sem_seg.setter
+    def gt_sem_seg(self, value: PixelData):
+        self.set_field(value, '_gt_sem_seg', dtype=PixelData)
+
+    @gt_sem_seg.deleter
+    def gt_sem_seg(self):
+        del self._gt_sem_seg
+
+    # 预测
+    @property
+    def pred_instances(self) -> InstanceData:
+        return self._pred_instances
+
+    @pred_instances.setter
+    def pred_instances(self, value: InstanceData):
+        self.set_field(value, '_pred_instances', dtype=InstanceData)
+
+    @pred_instances.deleter
+    def pred_instances(self):
+        del self._pred_instances
+
+    @property
+    def pred_panoptic_seg(self) -> PixelData:
+        return self._pred_panoptic_seg
+
+    @pred_panoptic_seg.setter
+    def pred_panoptic_seg(self, value: PixelData):
+        self.set_field(value, '_pred_panoptic_seg', dtype=PixelData)
+
+    @pred_panoptic_seg.deleter
+    def pred_panoptic_seg(self):
+        del self._pred_panoptic_seg
+
+    # 中间结果
+    @property
+    def pred_sem_seg(self) -> PixelData:
+        return self._pred_sem_seg
+
+    @pred_sem_seg.setter
+    def pred_sem_seg(self, value: PixelData):
+        self.set_field(value, '_pred_sem_seg', dtype=PixelData)
+
+    @pred_sem_seg.deleter
+    def pred_sem_seg(self):
+        del self._pred_sem_seg
+
+    @property
+    def proposals(self) -> InstanceData:
+        return self._proposals
+
+    @proposals.setter
+    def proposals(self, value: InstanceData):
+        self.set_field(value, '_proposals', dtype=InstanceData)
+
+    @proposals.deleter
+    def proposals(self):
+        del self._proposals
+
+```
+
+### 类型约束
+
+DetDataSample 的用法如下所示，在数据类型不符合要求的时候(例如用 torch.Tensor 而非 InstanceData 定义 proposals 时)，DetDataSample 就会报错。
+
+```python
+data_sample = DetDataSample()
+
+data_sample.proposals = InstanceData(data=dict(bboxes=torch.rand((5,4))))
+print(data_sample)
+```
+
+```
+<DetDataSample(
+
+    META INFORMATION
+
+    DATA FIELDS
+    proposals: <InstanceData(
+
+            META INFORMATION
+
+            DATA FIELDS
+            data:
+                bboxes: tensor([[0.7513, 0.9275, 0.6169, 0.5581],
+                            [0.6019, 0.6861, 0.7915, 0.0221],
+                            [0.5977, 0.8987, 0.9541, 0.7877],
+                            [0.0309, 0.1680, 0.1374, 0.0556],
+                            [0.3842, 0.9965, 0.0747, 0.6546]])
+        ) at 0x7f9f1c090310>
+) at 0x7f9f1c090430>
+```
+
+```python
+data_sample.proposals = torch.rand((5, 4))
+```
+
+```
+AssertionError: tensor([[0.4370, 0.1661, 0.0902, 0.8421],
+        [0.4947, 0.1668, 0.0083, 0.1111],
+        [0.2041, 0.8663, 0.0563, 0.3279],
+        [0.7817, 0.1938, 0.2499, 0.6748],
+        [0.4524, 0.8265, 0.4262, 0.2215]]) should be a <class 'mmengine.data.instance_data.InstanceData'> but got <class 'torch.Tensor'>
+```
+
+## 接口的简化
+
+下面以 MMDetection 为例更具体地说明 OpenMMLab 的算法库将如何迁移使用抽象数据接口，以简化模块和组件接口的。我们假定 MMDetection 和 MMEngine 中实现了 DetDataSample 和 InstanceData。
+
+#### 1. 组件接口的简化
+
+检测器的外部接口可以得到显著的简化和统一。MMDet 2.X 中单阶段检测器和单阶段分割算法的接口如下。在训练过程中，`SingleStageDetector` 需要获取
+`img`， `img_metas`， `gt_bboxes`， `gt_labels`， `gt_bboxes_ignore` 作为输入，但是 `SingleStageInstanceSegmentor` 还需要 `gt_masks`，导致 detector 的训练接口不一致，影响了代码的灵活性。
+
+```python
+
+class SingleStageDetector(BaseDetector):
+    ...
+
+    def forward_train(self,
+                      img,
+                      img_metas,
+                      gt_bboxes,
+                      gt_labels,
+                      gt_bboxes_ignore=None):
+
+
+class SingleStageInstanceSegmentor(BaseDetector):
+    ...
+
+    def forward_train(self,
+                      img,
+                      img_metas,
+                      gt_masks,
+                      gt_labels,
+                      gt_bboxes=None,
+                      gt_bboxes_ignore=None,
+                      **kwargs):
+```
+
+在 MMDet 3.0 中，所有检测器的训练接口都可以使用 DetDataSample 统一简化为 `img` 和 `data_samples`，不同模块可以根据需要去访问 `data_samples` 封装的各种所需要的属性。
+
+```python
+class SingleStageDetector(BaseDetector):
+    ...
+
+    def forward_train(self,
+                      img,
+                      data_samples):
+
+class SingleStageInstanceSegmentor(BaseDetector):
+    ...
+
+    def forward_train(self,
+                      img,
+                      data_samples):
+
+```
+
+#### 2. 模块接口的简化
+
+MMDet 2.X 中 `HungarianAssigner` 和 `MaskHungarianAssigner` 分别用于在训练过程中将检测框和实例掩码和标注的实例进行匹配。他们内部的匹配逻辑实现是一样的，只是接口和损失函数的计算不同。
+但是，接口的不同使得 `HungarianAssigner` 中的代码无法被复用，`MaskHungarianAssigner` 中重写了很多冗余的逻辑。
+
+```python
+class HungarianAssigner(BaseAssigner):
+
+    def assign(self,
+               bbox_pred,
+               cls_pred,
+               gt_bboxes,
+               gt_labels,
+               img_meta,
+               gt_bboxes_ignore=None,
+               eps=1e-7):
+
+class MaskHungarianAssigner(BaseAssigner):
+
+    def assign(self,
+               cls_pred,
+               mask_pred,
+               gt_labels,
+               gt_mask,
+               img_meta,
+               gt_bboxes_ignore=None,
+               eps=1e-7):
+```
+
+`InstanceData` 可以封装实例的框、分数、和掩码，将 `HungarianAssigner` 的核心参数简化成 `pred_instances`，`gt_instancess`，和 `gt_instances_ignore`
+使得 `HungarianAssigner` 和 `MaskHungarianAssigner` 可以合并成一个通用的 `HungarianAssigner`。
+
+```python
+class HungarianAssigner(BaseAssigner):
+
+    def assign(self,
+               pred_instances,
+               gt_instancess,
+               gt_instances_ignore=None,
+               eps=1e-7):
+```

testbed/open-mmlab__mmengine/docs/zh_cn/advanced_tutorials/data_transform.md

@@ -0,0 +1,136 @@
+# 数据变换 (Data Transform)
+
+在 OpenMMLab 算法库中，数据集的构建和数据的准备是相互解耦的。通常，数据集的构建只对数据集进行解析，记录每个样本的基本信息；而数据的准备则是通过一系列的数据变换，根据样本的基本信息进行数据加载、预处理、格式化等操作。
+
+## 使用数据变换类
+
+在 MMEngine 中，我们使用各种可调用的数据变换类来进行数据的操作。这些数据变换类可以接受若干配置参数进行实例化，之后通过调用的方式对输入的数据字典进行处理。同时，我们约定所有数据变换都接受一个字典作为输入，并将处理后的数据输出为一个字典。一个简单的例子如下：
+
+```{note}
+MMEngine 中仅约定了数据变换类的规范，常用的数据变换类实现及基类都在 MMCV 中，因此在本篇教程需要提前安装好 MMCV，参见 {external+mmcv:doc}`MMCV 安装教程 <get_started/installation>`。
+```
+
+```python
+>>> import numpy as np
+>>> from mmcv.transforms import Resize
+>>>
+>>> transform = Resize(scale=(224, 224))
+>>> data_dict = {'img': np.random.rand(256, 256, 3)}
+>>> data_dict = transform(data_dict)
+>>> print(data_dict['img'].shape)
+(224, 224, 3)
+```
+
+## 在配置文件中使用
+
+在配置文件中，我们将一系列数据变换组合成为一个列表，称为数据流水线（Data Pipeline），传给数据集的 `pipeline` 参数。通常数据流水线由以下几个部分组成：
+
+1. 数据加载，通常使用 [`LoadImageFromFile`](mmcv.transforms.LoadImageFromFile)
+2. 标签加载，通常使用 [`LoadAnnotations`](mmcv.transforms.LoadAnnotations)
+3. 数据处理及增强，例如 [`RandomResize`](mmcv.transforms.RandomResize)
+4. 数据格式化，根据任务不同，在各个仓库使用自己的变换操作，通常名为 `PackXXXInputs`，其中 XXX 是任务的名称，如分类任务中的 `PackClsInputs`。
+
+以分类任务为例，我们在下图展示了一个典型的数据流水线。对每个样本，数据集中保存的基本信息是一个如图中最左侧所示的字典，之后每经过一个由蓝色块代表的数据变换操作，数据字典中都会加入新的字段（标记为绿色）或更新现有的字段（标记为橙色）。
+
+<div align=center>
+<img src="https://user-images.githubusercontent.com/26739999/206081993-d5351151-466c-4b13-bf6d-9441c0c896c8.png" width="90%" style="background-color: white;padding: 10px;"/>
+</div>
+
+如果我们希望在测试中使用上述数据流水线，则配置文件如下所示：
+
+```python
+test_dataloader = dict(
+    batch_size=32,
+    dataset=dict(
+        type='ImageNet',
+        data_root='data/imagenet',
+        pipeline = [
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', size=256, keep_ratio=True),
+            dict(type='CenterCrop', crop_size=224),
+            dict(type='PackClsInputs'),
+        ]
+    )
+)
+```
+
+## 常用的数据变换类
+
+按照功能，常用的数据变换类可以大致分为数据加载、数据预处理与增强、数据格式化。我们在 MMCV 中提供了一系列常用的数据变换类：
+
+### 数据加载
+
+为了支持大规模数据集的加载，通常在数据集初始化时不加载数据，只加载相应的路径。因此需要在数据流水线中进行具体数据的加载。
+
+|                        数据变换类                        |                   功能                    |
+| :------------------------------------------------------: | :---------------------------------------: |
+| [`LoadImageFromFile`](mmcv.transforms.LoadImageFromFile) |             根据路径加载图像              |
+|   [`LoadAnnotations`](mmcv.transforms.LoadAnnotations)   | 加载和组织标注信息，如 bbox、语义分割图等 |
+
+### 数据预处理及增强
+
+数据预处理和增强通常是对图像本身进行变换，如裁剪、填充、缩放等。
+
+|                         数据变换类                         |                功能                |
+| :--------------------------------------------------------: | :--------------------------------: |
+|                [`Pad`](mmcv.transforms.Pad)                |            填充图像边缘            |
+|         [`CenterCrop`](mmcv.transforms.CenterCrop)         |              居中裁剪              |
+|          [`Normalize`](mmcv.transforms.Normalize)          |          对图像进行归一化          |
+|             [`Resize`](mmcv.transforms.Resize)             |     按照指定尺寸或比例缩放图像     |
+|       [`RandomResize`](mmcv.transforms.RandomResize)       |    缩放图像至指定范围的随机尺寸    |
+| [`RandomChoiceResize`](mmcv.transforms.RandomChoiceResize) | 缩放图像至多个尺寸中的随机一个尺寸 |
+|    [`RandomGrayscale`](mmcv.transforms.RandomGrayscale)    |             随机灰度化             |
+|         [`RandomFlip`](mmcv.transforms.RandomFlip)         |            图像随机翻转            |
+
+### 数据格式化
+
+数据格式化操作通常是对数据进行的类型转换。
+
+|                    数据变换类                    |               功能                |
+| :----------------------------------------------: | :-------------------------------: |
+|      [`ToTensor`](mmcv.transforms.ToTensor)      | 将指定的数据转换为 `torch.Tensor` |
+| [`ImageToTensor`](mmcv.transforms.ImageToTensor) |    将图像转换为 `torch.Tensor`    |
+
+## 自定义数据变换类
+
+要实现一个新的数据变换类，需要继承 `BaseTransform`，并实现 `transform` 方法。这里，我们使用一个简单的翻转变换（`MyFlip`）作为示例：
+
+```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
+```
+
+从而，我们可以实例化一个 `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']
+```
+
+又或者，在配置文件的 pipeline 中使用 `MyFlip` 变换
+
+```python
+pipeline = [
+    ...
+    dict(type='MyFlip', direction='horizontal'),
+    ...
+]
+```
+
+需要注意的是，如需在配置文件中使用，需要保证 `MyFlip` 类所在的文件在运行时能够被导入。

testbed/open-mmlab__mmengine/docs/zh_cn/advanced_tutorials/distributed.md

@@ -0,0 +1,47 @@
+# 分布式通信原语
+
+在分布式训练或测试的过程中，不同进程有时需要根据分布式的环境信息执行不同的代码逻辑，同时不同进程之间也经常会有相互通信的需求，对一些数据进行同步等操作。
+PyTorch 提供了一套基础的通信原语用于多进程之间张量的通信，基于这套原语，MMEngine 实现了更高层次的通信原语封装以满足更加丰富的需求。基于 MMEngine 的通信原语，算法库中的模块可以
+
+1. 在使用通信原语封装时不显式区分分布式/非分布式环境
+2. 进行除 Tensor 以外类型数据的多进程通信
+3. 无需了解底层通信后端或框架
+
+这些通信原语封装的接口和功能可以大致归类为如下三种，我们在后续章节中逐个介绍
+
+1. 分布式初始化：`init_dist` 负责初始化执行器的分布式环境
+2. 分布式信息获取与控制：包括 `get_world_size` 等函数获取当前的 `rank` 和 `world_size` 等信息
+3. 分布式通信接口：包括如 `all_reduce` 等通信函数（collective functions）
+
+## 分布式初始化
+
+- [init_dist](mmengine.dist.init_dist)： 是分布式训练的启动函数，目前支持 pytorch，slurm，MPI 3 种分布式启动方式，同时允许设置通信的后端，默认使用 NCCL。
+
+## 分布式信息获取与控制
+
+分布式信息的获取与控制函数没有参数，这些函数兼容非分布式训练的情况，功能如下
+
+- [get_world_size](mmengine.dist.get_world_size)：获取当前进程组的进程总数，非分布式情况下返回 1
+- [get_rank](mmengine.dist.get_rank)：获取当前进程对应的全局 rank 数，非分布式情况下返回 0
+- [get_backend](mmengine.dist.get_backend)：获取当前通信使用的后端，非分布式情况下返回 None
+- [get_local_rank](mmengine.dist.get_local_rank)：获取当前进程对应到当前机器的 rank 数，非分布式情况下返回 0
+- [get_local_size](mmengine.dist.get_local_size)：获取当前进程所在机器的总进程数，非分布式情况下返回 0
+- [get_dist_info](mmengine.dist.get_dist_info)：获取当前任务的进程总数和当前进程对应到全局的 rank 数，非分布式情况下 word_size = 1，rank = 0
+- [is_main_process](mmengine.dist.is_main_process)：判断是否为 0 号主进程，非分布式情况下返回 True
+- [master_only](mmengine.dist.master_only)：函数装饰器，用于修饰只需要全局 0 号进程（rank 0 而不是 local rank 0）执行的函数
+- [barrier](mmengine.dist.barrier)：同步所有进程到达相同位置
+
+## 分布式通信函数
+
+通信函数 （Collective functions），主要用于进程间数据的通信，基于 PyTorch 原生的 all_reduce，all_gather，gather，broadcast 接口，MMEngine 提供了如下接口，兼容非分布式训练的情况，并支持更丰富数据类型的通信。
+
+- [all_reduce](mmengine.dist.all_reduce): 对进程间 tensor 进行 AllReduce 操作
+- [all_gather](mmengine.dist.all_gather)：对进程间 tensor 进行 AllGather 操作
+- [gather](mmengine.dist.gather)：将进程的 tensor 收集到一个目标 rank
+- [broadcast](mmengine.dist.broadcast)：对某个进程的 tensor 进行广播
+- [sync_random_seed](mmengine.dist.sync_random_seed)：同步进程之间的随机种子
+- [broadcast_object_list](mmengine.dist.broadcast_object_list)：支持对任意可被 Pickle 序列化的 Python 对象列表进行广播，基于 broadcast 接口实现
+- [all_reduce_dict](mmengine.dist.all_reduce_dict)：对 dict 中的内容进行 all_reduce 操作，基于 broadcast 和 all_reduce 接口实现
+- [all_gather_object](mmengine.dist.all_gather_object)：基于 all_gather 实现对任意可以被 Pickle 序列化的 Python 对象进行 all_gather 操作
+- [gather_object](mmengine.dist.gather_object)：将 group 里每个 rank 中任意可被 Pickle 序列化的 Python 对象 gather 到指定的目标 rank
+- [collect_results](mmengine.dist.collect_results)：支持基于 CPU 通信或者 GPU 通信对不同进程间的列表数据进行收集

testbed/open-mmlab__mmengine/docs/zh_cn/advanced_tutorials/fileio.md

@@ -0,0 +1,214 @@
+# 文件读写
+
+`MMEngine` 实现了一套统一的文件读写接口，可以用同一个函数来处理不同的文件格式，如 `json`、
+`yaml` 和 `pickle`，并且可以方便地拓展其它的文件格式。除此之外，文件读写模块还支持从多种文件存储后端读写文件，包括本地磁盘、Petrel（内部使用）、Memcached、LMDB 和 HTTP。
+
+## 读取和保存数据
+
+`MMEngine` 提供了两个通用的接口用于读取和保存数据，目前支持的格式有 `json`、`yaml` 和
+`pickle`。
+
+### 从硬盘读取数据或者将数据保存至硬盘
+
+```python
+from mmengine import load, dump
+
+# 从文件中读取数据
+data = load('test.json')
+data = load('test.yaml')
+data = load('test.pkl')
+# 从文件对象中读取数据
+with open('test.json', 'r') as f:
+    data = load(f, file_format='json')
+
+# 将数据序列化为字符串
+json_str = dump(data, file_format='json')
+
+# 将数据保存至文件 (根据文件名后缀反推文件类型)
+dump(data, 'out.pkl')
+
+# 将数据保存至文件对象
+with open('test.yaml', 'w') as f:
+    data = dump(data, f, file_format='yaml')
+```
+
+### 从其它文件存储后端读写文件
+
+```python
+from mmengine import load, dump
+
+# 从 s3 文件读取数据
+data = load('s3://bucket-name/test.json')
+data = load('s3://bucket-name/test.yaml')
+data = load('s3://bucket-name/test.pkl')
+
+# 将数据保存至 s3 文件 (根据文件名后缀反推文件类型)
+dump(data, 's3://bucket-name/out.pkl')
+```
+
+我们提供了易于拓展的方式以支持更多的文件格式，我们只需要创建一个继承自 `BaseFileHandler` 的文件句柄类，句柄类至少需要重写三个方法。然后使用使用 `register_handler` 装饰器将句柄类注册为对应文件格式的读写句柄。
+
+```python
+from mmengine import register_handler, BaseFileHandler
+
+# 支持为文件句柄类注册多个文件格式
+# @register_handler(['txt', 'log'])
+@register_handler('txt')
+class TxtHandler1(BaseFileHandler):
+
+    def load_from_fileobj(self, file):
+        return file.read()
+
+    def dump_to_fileobj(self, obj, file):
+        file.write(str(obj))
+
+    def dump_to_str(self, obj, **kwargs):
+        return str(obj)
+```
+
+以 `PickleHandler` 为例
+
+```python
+from mmengine import BaseFileHandler
+import pickle
+
+class PickleHandler(BaseFileHandler):
+
+    def load_from_fileobj(self, file, **kwargs):
+        return pickle.load(file, **kwargs)
+
+    def load_from_path(self, filepath, **kwargs):
+        return super(PickleHandler, self).load_from_path(
+            filepath, mode='rb', **kwargs)
+
+    def dump_to_str(self, obj, **kwargs):
+        kwargs.setdefault('protocol', 2)
+        return pickle.dumps(obj, **kwargs)
+
+    def dump_to_fileobj(self, obj, file, **kwargs):
+        kwargs.setdefault('protocol', 2)
+        pickle.dump(obj, file, **kwargs)
+
+    def dump_to_path(self, obj, filepath, **kwargs):
+        super(PickleHandler, self).dump_to_path(
+            obj, filepath, mode='wb', **kwargs)
+```
+
+## 读取文件并返回列表或字典
+
+例如， `a.txt` 是文本文件，一共有5行内容。
+
+```
+a
+b
+c
+d
+e
+```
+
+### 从硬盘读取
+
+使用 `list_from_file` 读取 `a.txt`
+
+```python
+from mmengine import list_from_file
+
+print(list_from_file('a.txt'))
+# ['a', 'b', 'c', 'd', 'e']
+print(list_from_file('a.txt', offset=2))
+# ['c', 'd', 'e']
+print(list_from_file('a.txt', max_num=2))
+# ['a', 'b']
+print(list_from_file('a.txt', prefix='/mnt/'))
+# ['/mnt/a', '/mnt/b', '/mnt/c', '/mnt/d', '/mnt/e']
+```
+
+同样， `b.txt` 也是文本文件，一共有3行内容
+
+```
+1 cat
+2 dog cow
+3 panda
+```
+
+使用 `dict_from_file` 读取 `b.txt`
+
+```python
+from mmengine import dict_from_file
+
+print(dict_from_file('b.txt'))
+# {'1': 'cat', '2': ['dog', 'cow'], '3': 'panda'}
+print(dict_from_file('b.txt', key_type=int))
+# {1: 'cat', 2: ['dog', 'cow'], 3: 'panda'}
+```
+
+### 从其他存储后端读取
+
+使用 `list_from_file` 读取 `s3://bucket-name/a.txt`
+
+```python
+from mmengine import list_from_file
+
+print(list_from_file('s3://bucket-name/a.txt'))
+# ['a', 'b', 'c', 'd', 'e']
+print(list_from_file('s3://bucket-name/a.txt', offset=2))
+# ['c', 'd', 'e']
+print(list_from_file('s3://bucket-name/a.txt', max_num=2))
+# ['a', 'b']
+print(list_from_file('s3://bucket-name/a.txt', prefix='/mnt/'))
+# ['/mnt/a', '/mnt/b', '/mnt/c', '/mnt/d', '/mnt/e']
+```
+
+使用 `dict_from_file` 读取 `b.txt`
+
+```python
+from mmengine import dict_from_file
+
+print(dict_from_file('s3://bucket-name/b.txt'))
+# {'1': 'cat', '2': ['dog', 'cow'], '3': 'panda'}
+print(dict_from_file('s3://bucket-name/b.txt', key_type=int))
+# {1: 'cat', 2: ['dog', 'cow'], 3: 'panda'}
+```
+
+## 读取和保存权重文件
+
+通常情况下，我们可以通过下面的方式从磁盘或者网络远端读取权重文件。
+
+```python
+import torch
+
+filepath1 = '/path/of/your/checkpoint1.pth'
+filepath2 = 'http://path/of/your/checkpoint3.pth'
+
+# 从本地磁盘读取权重文���
+checkpoint = torch.load(filepath1)
+# 保存权重文件到本地磁盘
+torch.save(checkpoint, filepath1)
+
+# 从网络远端读取权重文件
+checkpoint = torch.utils.model_zoo.load_url(filepath2)
+```
+
+在 `MMEngine` 中，得益于多文件存储后端的支持，不同存储形式的权重文件读写可以通过
+`load_checkpoint` 和 `save_checkpoint` 来统一实现。
+
+```python
+from mmengine import load_checkpoint, save_checkpoint
+
+filepath1 = '/path/of/your/checkpoint1.pth'
+filepath2 = 's3://bucket-name/path/of/your/checkpoint1.pth'
+filepath3 = 'http://path/of/your/checkpoint3.pth'
+
+# 从本地磁盘读取权重文件
+checkpoint = load_checkpoint(filepath1)
+# 保存权重文件到本地磁盘
+save_checkpoint(checkpoint, filepath1)
+
+# 从 s3 读取权重文件
+checkpoint = load_checkpoint(filepath2)
+# 保存权重文件到 s3
+save_checkpoint(checkpoint, filepath2)
+
+# 从网络远端读取权重文件
+checkpoint = load_checkpoint(filepath3)
+```