From f919f838c269ddf4ce3ed3874ad03a794a9bef7e Mon Sep 17 00:00:00 2001
From: Weiming <wingalong@gmail.com>
Date: Sat, 9 Apr 2022 16:55:21 +0800
Subject: [PATCH] [Release] v0.1.0

---
 .dockerignore                                 |  10 +
 .gitignore                                    |  11 +
 .readthedocs.yaml                             |  16 +
 LICENSE                                       | 201 ++++
 Makefile                                      |  14 +
 README.md                                     |  95 ++
 docker/base.Dockerfile                        |  17 +
 docker/client.Dockerfile                      |   9 +
 docker/docker-compose.yml                     | 105 ++
 docker/run.Dockerfile                         |   9 +
 docker/server.Dockerfile                      |   9 +
 docker/tracker.Dockerfile                     |   9 +
 docs/en/Makefile                              |  20 +
 docs/en/_static/css/readthedocs.css           |   6 +
 docs/en/_static/image/architecture.png        | Bin 0 -> 319813 bytes
 docs/en/_static/image/docker.png              | Bin 0 -> 46575 bytes
 docs/en/_static/image/easyfl-logo.png         | Bin 0 -> 25810 bytes
 docs/en/_static/image/registry.png            | Bin 0 -> 75632 bytes
 docs/en/_static/image/training-flow.png       | Bin 0 -> 58955 bytes
 docs/en/api.rst                               |  40 +
 docs/en/changelog.md                          |   5 +
 docs/en/conf.py                               | 125 +++
 docs/en/faq.md                                |   8 +
 docs/en/get_started.md                        |  87 ++
 docs/en/index.rst                             |  48 +
 docs/en/introduction.md                       |  51 +
 docs/en/make.bat                              |  35 +
 docs/en/projects.md                           |  11 +
 docs/en/quick_run.md                          |  49 +
 docs/en/tutorials/config.md                   | 318 ++++++
 .../tutorials/customize_server_and_client.md  | 281 ++++++
 docs/en/tutorials/dataset.md                  | 232 +++++
 docs/en/tutorials/distributed_training.md     |  42 +
 docs/en/tutorials/high-level_apis.md          | 126 +++
 docs/en/tutorials/index.rst                   |  11 +
 docs/en/tutorials/model.md                    |  92 ++
 docs/en/tutorials/remote_training.md          | 257 +++++
 easyfl/__init__.py                            |  22 +
 easyfl/client/__init__.py                     |   5 +
 easyfl/client/base.py                         | 471 +++++++++
 easyfl/client/service.py                      |  30 +
 easyfl/communication/__init__.py              |   3 +
 easyfl/communication/grpc_wrapper.py          |  77 ++
 easyfl/compression/__init__.py                |   0
 easyfl/config.yaml                            | 113 +++
 easyfl/coordinator.py                         | 481 +++++++++
 easyfl/datasets/__init__.py                   |  26 +
 easyfl/datasets/cifar10/__init__.py           |   1 +
 easyfl/datasets/cifar10/cifar10.py            |  88 ++
 easyfl/datasets/cifar100/__init__.py          |   1 +
 easyfl/datasets/cifar100/cifar100.py          |  88 ++
 easyfl/datasets/data.py                       | 243 +++++
 easyfl/datasets/data_process/__init__.py      |   0
 easyfl/datasets/data_process/cifar10.py       |  55 ++
 easyfl/datasets/data_process/cifar100.py      |  55 ++
 easyfl/datasets/data_process/femnist.py       |  10 +
 .../datasets/data_process/language_utils.py   | 142 +++
 easyfl/datasets/data_process/shakespeare.py   |  15 +
 easyfl/datasets/dataset.py                    | 427 ++++++++
 easyfl/datasets/dataset_util.py               |  45 +
 easyfl/datasets/femnist/__init__.py           |   1 +
 easyfl/datasets/femnist/femnist.py            | 109 +++
 .../datasets/femnist/preprocess/__init__.py   |   0
 .../femnist/preprocess/data_to_json.py        |  94 ++
 .../femnist/preprocess/get_file_dirs.py       |  71 ++
 .../datasets/femnist/preprocess/get_hashes.py |  55 ++
 .../femnist/preprocess/group_by_writer.py     |  25 +
 .../femnist/preprocess/match_hashes.py        |  25 +
 easyfl/datasets/shakespeare/__init__.py       |   1 +
 easyfl/datasets/shakespeare/shakespeare.py    |  89 ++
 easyfl/datasets/shakespeare/utils/__init__.py |   0
 .../shakespeare/utils/gen_all_data.py         |  17 +
 .../utils/preprocess_shakespeare.py           | 183 ++++
 .../datasets/shakespeare/utils/shake_utils.py |  69 ++
 easyfl/datasets/simulation.py                 | 350 +++++++
 easyfl/datasets/utils/__init__.py             |   0
 easyfl/datasets/utils/base_dataset.py         | 158 +++
 easyfl/datasets/utils/constants.py            |   2 +
 easyfl/datasets/utils/download.py             | 176 ++++
 easyfl/datasets/utils/remove_users.py         |  62 ++
 easyfl/datasets/utils/sample.py               | 274 ++++++
 easyfl/datasets/utils/split_data.py           | 235 +++++
 easyfl/datasets/utils/util.py                 |  42 +
 easyfl/distributed/__init__.py                |  18 +
 easyfl/distributed/distributed.py             | 257 +++++
 easyfl/distributed/slurm.py                   |  64 ++
 easyfl/encryption/__init__.py                 |   0
 easyfl/models/__init__.py                     |   1 +
 easyfl/models/lenet.py                        |  36 +
 easyfl/models/model.py                        |  24 +
 easyfl/models/resnet.py                       | 124 +++
 easyfl/models/resnet18.py                     | 102 ++
 easyfl/models/resnet50.py                     | 107 ++
 easyfl/models/rnn.py                          |  36 +
 easyfl/models/simple_cnn.py                   |  40 +
 easyfl/models/vgg9.py                         |  65 ++
 easyfl/pb/__init__.py                         |   0
 easyfl/pb/client_service_pb2.py               |  75 ++
 easyfl/pb/client_service_pb2_grpc.py          |  66 ++
 easyfl/pb/common_pb2.py                       |  81 ++
 easyfl/pb/common_pb2_grpc.py                  |   4 +
 easyfl/pb/server_service_pb2.py               | 118 +++
 easyfl/pb/server_service_pb2_grpc.py          | 132 +++
 easyfl/pb/tracking_service_pb2.py             | 198 ++++
 easyfl/pb/tracking_service_pb2_grpc.py        | 297 ++++++
 easyfl/protocol/__init__.py                   |   3 +
 easyfl/protocol/codec.py                      |   9 +
 easyfl/registor/Dockerfile                    |  25 +
 easyfl/registor/README.md                     |  60 ++
 easyfl/registor/docker-register.service       |  15 +
 easyfl/registor/etcd.tmpl                     |  37 +
 easyfl/registry/__init__.py                   |   4 +
 easyfl/registry/etcd_client.py                | 207 ++++
 easyfl/registry/k8s.py                        |  29 +
 easyfl/registry/mock_etcd.py                  | 155 +++
 easyfl/registry/registry.py                   |  31 +
 easyfl/registry/vclient.py                    |   5 +
 easyfl/server/__init__.py                     |   7 +
 easyfl/server/base.py                         | 917 ++++++++++++++++++
 easyfl/server/service.py                      | 143 +++
 easyfl/server/strategies.py                   | 119 +++
 easyfl/service.py                             |  71 ++
 easyfl/simulation/__init__.py                 |   0
 easyfl/simulation/mobile_ratio.py             |   6 +
 easyfl/simulation/system_hetero.py            |  71 ++
 easyfl/tracking/__init__.py                   |   0
 easyfl/tracking/client.py                     | 242 +++++
 easyfl/tracking/client_test.py                | 136 +++
 easyfl/tracking/evaluation.py                 |  17 +
 easyfl/tracking/metric.py                     | 486 ++++++++++
 easyfl/tracking/service.py                    | 157 +++
 easyfl/tracking/storage.py                    | 340 +++++++
 easyfl/utils/__init__.py                      |   0
 easyfl/utils/float.py                         |   5 +
 easyfl/version.py                             |  17 +
 examples/cifar10.py                           |   9 +
 examples/dataset_registration.py              |  50 +
 examples/distributed_slurm.py                 |  21 +
 examples/femnist.py                           |  12 +
 examples/remote_client.py                     |   3 +
 examples/remote_run.py                        |  58 ++
 examples/remote_server.py                     |  11 +
 examples/remote_stop.py                       |  26 +
 examples/remote_tracker.py                    |   6 +
 examples/shakespeare.py                       |   9 +
 kubernetes/client.yml                         |  38 +
 kubernetes/namespace.yml                      |  10 +
 kubernetes/server.yml                         |  20 +
 kubernetes/services.yml                       |  43 +
 kubernetes/tracker.yml                        |  20 +
 protos/easyfl/pb/client_service.proto         |  53 +
 protos/easyfl/pb/common.proto                 |  65 ++
 protos/easyfl/pb/server_service.proto         |  63 ++
 protos/easyfl/pb/tracking_service.proto       | 115 +++
 requirements.txt                              |   1 +
 requirements/docs.txt                         |   7 +
 requirements/readthedocs.txt                  |   2 +
 requirements/runtime.txt                      |   9 +
 setup.cfg                                     |   3 +
 setup.py                                      | 131 +++
 160 files changed, 12729 insertions(+)
 create mode 100644 .dockerignore
 create mode 100644 .gitignore
 create mode 100644 .readthedocs.yaml
 create mode 100644 LICENSE
 create mode 100644 Makefile
 create mode 100644 README.md
 create mode 100644 docker/base.Dockerfile
 create mode 100644 docker/client.Dockerfile
 create mode 100644 docker/docker-compose.yml
 create mode 100644 docker/run.Dockerfile
 create mode 100644 docker/server.Dockerfile
 create mode 100644 docker/tracker.Dockerfile
 create mode 100644 docs/en/Makefile
 create mode 100644 docs/en/_static/css/readthedocs.css
 create mode 100644 docs/en/_static/image/architecture.png
 create mode 100644 docs/en/_static/image/docker.png
 create mode 100644 docs/en/_static/image/easyfl-logo.png
 create mode 100644 docs/en/_static/image/registry.png
 create mode 100644 docs/en/_static/image/training-flow.png
 create mode 100644 docs/en/api.rst
 create mode 100644 docs/en/changelog.md
 create mode 100644 docs/en/conf.py
 create mode 100644 docs/en/faq.md
 create mode 100644 docs/en/get_started.md
 create mode 100644 docs/en/index.rst
 create mode 100644 docs/en/introduction.md
 create mode 100644 docs/en/make.bat
 create mode 100644 docs/en/projects.md
 create mode 100644 docs/en/quick_run.md
 create mode 100644 docs/en/tutorials/config.md
 create mode 100644 docs/en/tutorials/customize_server_and_client.md
 create mode 100644 docs/en/tutorials/dataset.md
 create mode 100644 docs/en/tutorials/distributed_training.md
 create mode 100644 docs/en/tutorials/high-level_apis.md
 create mode 100644 docs/en/tutorials/index.rst
 create mode 100644 docs/en/tutorials/model.md
 create mode 100644 docs/en/tutorials/remote_training.md
 create mode 100644 easyfl/__init__.py
 create mode 100644 easyfl/client/__init__.py
 create mode 100644 easyfl/client/base.py
 create mode 100644 easyfl/client/service.py
 create mode 100644 easyfl/communication/__init__.py
 create mode 100644 easyfl/communication/grpc_wrapper.py
 create mode 100644 easyfl/compression/__init__.py
 create mode 100644 easyfl/config.yaml
 create mode 100644 easyfl/coordinator.py
 create mode 100644 easyfl/datasets/__init__.py
 create mode 100644 easyfl/datasets/cifar10/__init__.py
 create mode 100644 easyfl/datasets/cifar10/cifar10.py
 create mode 100644 easyfl/datasets/cifar100/__init__.py
 create mode 100644 easyfl/datasets/cifar100/cifar100.py
 create mode 100644 easyfl/datasets/data.py
 create mode 100644 easyfl/datasets/data_process/__init__.py
 create mode 100644 easyfl/datasets/data_process/cifar10.py
 create mode 100644 easyfl/datasets/data_process/cifar100.py
 create mode 100644 easyfl/datasets/data_process/femnist.py
 create mode 100755 easyfl/datasets/data_process/language_utils.py
 create mode 100644 easyfl/datasets/data_process/shakespeare.py
 create mode 100644 easyfl/datasets/dataset.py
 create mode 100644 easyfl/datasets/dataset_util.py
 create mode 100644 easyfl/datasets/femnist/__init__.py
 create mode 100644 easyfl/datasets/femnist/femnist.py
 create mode 100644 easyfl/datasets/femnist/preprocess/__init__.py
 create mode 100644 easyfl/datasets/femnist/preprocess/data_to_json.py
 create mode 100644 easyfl/datasets/femnist/preprocess/get_file_dirs.py
 create mode 100644 easyfl/datasets/femnist/preprocess/get_hashes.py
 create mode 100644 easyfl/datasets/femnist/preprocess/group_by_writer.py
 create mode 100644 easyfl/datasets/femnist/preprocess/match_hashes.py
 create mode 100644 easyfl/datasets/shakespeare/__init__.py
 create mode 100644 easyfl/datasets/shakespeare/shakespeare.py
 create mode 100644 easyfl/datasets/shakespeare/utils/__init__.py
 create mode 100644 easyfl/datasets/shakespeare/utils/gen_all_data.py
 create mode 100644 easyfl/datasets/shakespeare/utils/preprocess_shakespeare.py
 create mode 100644 easyfl/datasets/shakespeare/utils/shake_utils.py
 create mode 100644 easyfl/datasets/simulation.py
 create mode 100644 easyfl/datasets/utils/__init__.py
 create mode 100644 easyfl/datasets/utils/base_dataset.py
 create mode 100644 easyfl/datasets/utils/constants.py
 create mode 100644 easyfl/datasets/utils/download.py
 create mode 100644 easyfl/datasets/utils/remove_users.py
 create mode 100644 easyfl/datasets/utils/sample.py
 create mode 100644 easyfl/datasets/utils/split_data.py
 create mode 100644 easyfl/datasets/utils/util.py
 create mode 100644 easyfl/distributed/__init__.py
 create mode 100644 easyfl/distributed/distributed.py
 create mode 100644 easyfl/distributed/slurm.py
 create mode 100644 easyfl/encryption/__init__.py
 create mode 100644 easyfl/models/__init__.py
 create mode 100644 easyfl/models/lenet.py
 create mode 100644 easyfl/models/model.py
 create mode 100644 easyfl/models/resnet.py
 create mode 100644 easyfl/models/resnet18.py
 create mode 100644 easyfl/models/resnet50.py
 create mode 100644 easyfl/models/rnn.py
 create mode 100644 easyfl/models/simple_cnn.py
 create mode 100644 easyfl/models/vgg9.py
 create mode 100644 easyfl/pb/__init__.py
 create mode 100644 easyfl/pb/client_service_pb2.py
 create mode 100644 easyfl/pb/client_service_pb2_grpc.py
 create mode 100644 easyfl/pb/common_pb2.py
 create mode 100644 easyfl/pb/common_pb2_grpc.py
 create mode 100644 easyfl/pb/server_service_pb2.py
 create mode 100644 easyfl/pb/server_service_pb2_grpc.py
 create mode 100644 easyfl/pb/tracking_service_pb2.py
 create mode 100644 easyfl/pb/tracking_service_pb2_grpc.py
 create mode 100644 easyfl/protocol/__init__.py
 create mode 100644 easyfl/protocol/codec.py
 create mode 100644 easyfl/registor/Dockerfile
 create mode 100644 easyfl/registor/README.md
 create mode 100644 easyfl/registor/docker-register.service
 create mode 100644 easyfl/registor/etcd.tmpl
 create mode 100644 easyfl/registry/__init__.py
 create mode 100644 easyfl/registry/etcd_client.py
 create mode 100644 easyfl/registry/k8s.py
 create mode 100644 easyfl/registry/mock_etcd.py
 create mode 100644 easyfl/registry/registry.py
 create mode 100644 easyfl/registry/vclient.py
 create mode 100644 easyfl/server/__init__.py
 create mode 100644 easyfl/server/base.py
 create mode 100644 easyfl/server/service.py
 create mode 100644 easyfl/server/strategies.py
 create mode 100644 easyfl/service.py
 create mode 100644 easyfl/simulation/__init__.py
 create mode 100644 easyfl/simulation/mobile_ratio.py
 create mode 100644 easyfl/simulation/system_hetero.py
 create mode 100644 easyfl/tracking/__init__.py
 create mode 100644 easyfl/tracking/client.py
 create mode 100644 easyfl/tracking/client_test.py
 create mode 100644 easyfl/tracking/evaluation.py
 create mode 100644 easyfl/tracking/metric.py
 create mode 100644 easyfl/tracking/service.py
 create mode 100644 easyfl/tracking/storage.py
 create mode 100644 easyfl/utils/__init__.py
 create mode 100644 easyfl/utils/float.py
 create mode 100644 easyfl/version.py
 create mode 100644 examples/cifar10.py
 create mode 100644 examples/dataset_registration.py
 create mode 100644 examples/distributed_slurm.py
 create mode 100644 examples/femnist.py
 create mode 100644 examples/remote_client.py
 create mode 100644 examples/remote_run.py
 create mode 100644 examples/remote_server.py
 create mode 100644 examples/remote_stop.py
 create mode 100644 examples/remote_tracker.py
 create mode 100644 examples/shakespeare.py
 create mode 100644 kubernetes/client.yml
 create mode 100644 kubernetes/namespace.yml
 create mode 100644 kubernetes/server.yml
 create mode 100644 kubernetes/services.yml
 create mode 100644 kubernetes/tracker.yml
 create mode 100644 protos/easyfl/pb/client_service.proto
 create mode 100644 protos/easyfl/pb/common.proto
 create mode 100644 protos/easyfl/pb/server_service.proto
 create mode 100644 protos/easyfl/pb/tracking_service.proto
 create mode 100644 requirements.txt
 create mode 100644 requirements/docs.txt
 create mode 100644 requirements/readthedocs.txt
 create mode 100644 requirements/runtime.txt
 create mode 100644 setup.cfg
 create mode 100644 setup.py

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..0b10d56
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,10 @@
+.git
+.vscode
+.idea
+venv/*
+metrics/*
+__pycache__
+*_pb2.py
+*_pb2_grpc.py
+*.tar.gz
+*.npy
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..f41e6a3
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,11 @@
+__pycache__
+*.pyc
+*.log
+*.csv
+*.db
+*.xls
+*.xlsx
+*.egg-info
+docs/build
+
+
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 0000000..027a774
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,16 @@
+version: 2
+
+formats: all
+
+sphinx:
+  fail_on_warning: false
+  
+
+python:
+  # Install our python package before building the docs
+  version: 3.7
+  install:
+    - method: pip
+      path: .
+    - requirements: requirements/docs.txt
+    - requirements: requirements/readthedocs.txt
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..0853510
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+     Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [EasyFL] [Weiming Zhuang]
+
+   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.
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..5d5a667
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,14 @@
+protobuf:
+	python -m grpc_tools.protoc -I./protos \
+		--python_out=. \
+		--grpc_python_out=. \
+		protos/easyfl/pb/*.proto
+
+base_image:
+	docker build -f docker/base.Dockerfile -t easyfl:base .
+
+image:
+	docker build -f docker/client.Dockerfile -t easyfl-client .
+	docker build -f docker/server.Dockerfile -t easyfl-server .
+	docker build -f docker/tracker.Dockerfile -t easyfl-tracker .
+	docker build -f docker/run.Dockerfile -t easyfl-run .
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..db21000
--- /dev/null
+++ b/README.md
@@ -0,0 +1,95 @@
+<div align="center">
+  <img src="docs/en/_static/image/easyfl-logo.png" width="500"/>
+  <h1 align="center">EasyFL: A Low-code Federated Learning Platform</h1>
+
+[![PyPI](https://img.shields.io/pypi/v/easyfl)](https://pypi.org/project/easyfl)
+[![docs](https://img.shields.io/badge/docs-latest-blue)](https://easyfl.readthedocs.io/en/latest/)
+[![license](https://img.shields.io/github/license/easyfl-ai/easyfl.svg)](https://github.com/easyfl-ai/easyfl/blob/master/LICENSE)
+[![maintained](https://img.shields.io/badge/Maintained%3F-YES-yellow.svg)](https://github.com/easyfl-ai/easyfl/graphs/commit-activity)
+
+[📘 Documentation](https://easyfl.readthedocs.io/en/latest/) | [🛠️ Installation](https://easyfl.readthedocs.io/en/latest/get_started.html)
+</div>
+
+## Introduction
+
+**EasyFL** is an easy-to-use federated learning (FL) platform based on PyTorch. It aims to enable users with various levels of expertise to experiment and prototype FL applications with little/no coding. 
+
+You can use it for:
+* FL Research on algorithm and system
+* Proof-of-concept (POC) of new FL applications
+* Prototype of industrial applications
+* Learning FL implementations
+
+We currently focus on horizontal FL, supporting both cross-silo and cross-device FL. You can learn more about federated learning from these [resources](https://github.com/weimingwill/awesome-federated-learning#blogs). 
+
+## Major Features
+
+**Easy to Start**
+
+EasyFL is easy to install and easy to learn. It does not have complex dependency requirements. You can run EasyFL on your personal computer with only three lines of code ([Quick Start](docs/en/quick_run.md)).
+
+**Out-of-the-box Functionalities**
+
+EasyFL provides many out-of-the-box functionalities, including datasets, models, and FL algorithms. With simple configurations, you simulate different FL scenarios using the popular datasets. We support both statistical heterogeneity simulation and system heterogeneity simulation.
+
+**Flexible, Customizable, and Reproducible**
+
+EasyFL is flexible to be customized according to your needs. You can easily migrate existing CV or NLP applications into the federated manner by writing the PyTorch codes that you are most familiar with. 
+
+**Multiple Training Modes**
+
+EasyFL supports **standalone training**, **distributed training**, and **remote training**. By developing the code once, you can easily speed up FL training with distributed training on multiple GPUs. Besides, you can even deploy it to Kubernetes with Docker using remote training.
+
+## Getting Started
+
+You can refer to [Get Started](docs/en/get_started.md) for installation and [Quick Run](docs/en/quick_run.md) for the simplest way of using EasyFL.
+
+For more advanced usage, we provide a list of tutorials on:
+* [High-level APIs](docs/en/tutorials/high-level_apis.md)
+* [Configurations](docs/en/tutorials/config.md)
+* [Datasets](docs/en/tutorials/dataset.md)
+* [Models](docs/en/tutorials/model.md)
+* [Customize Server and Client](docs/en/tutorials/customize_server_and_client.md)
+* [Distributed Training](docs/en/tutorials/distributed_training.md)
+* [Remote Training](docs/en/tutorials/remote_training.md)
+
+
+## Projects & Papers
+
+The following publications are developed using EasyFL.
+
+- Divergence-aware Federated Self-Supervised Learning, _ICLR'2022_. [[paper]](https://openreview.net/forum?id=oVE1z8NlNe)
+- Collaborative Unsupervised Visual Representation Learning From Decentralized Data, _ICCV'2021_. [[paper]](https://openaccess.thecvf.com/content/ICCV2021/html/Zhuang_Collaborative_Unsupervised_Visual_Representation_Learning_From_Decentralized_Data_ICCV_2021_paper.html)
+- Joint Optimization in Edge-Cloud Continuum for Federated Unsupervised Person Re-identification, _ACMMM'2021_. [[paper]](https://arxiv.org/abs/2108.06493)
+
+:bulb: We will release the source codes of these projects in this repository. Please stay tuned.
+
+We have been doing research on federated learning for several years, the following are our additional publications.
+
+- EasyFL: A Low-code Federated Learning Platform For Dummies, _IEEE Internet-of-Things Journal_. [[paper]](https://arxiv.org/abs/2105.07603)
+- Performance Optimization for Federated Person Re-identification via Benchmark Analysis, _ACMMM'2020_. [[paper]](https://weiming.me/publication/fedreid/)
+- Federated Unsupervised Domain Adaptation for Face Recognition, _ICME'22_. [[paper]](https://weiming.me/publication/fedfr/)
+
+## Join Our Community
+
+Please join our community on Slack: [easyfl.slack.com](https://easyfl.slack.com) 
+
+We will post updated features and answer questions on Slack.
+
+## License
+
+This project is released under the [Apache 2.0 license](LICENSE).
+
+## Citation
+
+If you use this platform or related projects in your research, please cite this project.
+
+```
+@article{zhuang2022easyfl,
+  title={Easyfl: A low-code federated learning platform for dummies},
+  author={Zhuang, Weiming and Gan, Xin and Wen, Yonggang and Zhang, Shuai},
+  journal={IEEE Internet of Things Journal},
+  year={2022},
+  publisher={IEEE}
+}
+```
diff --git a/docker/base.Dockerfile b/docker/base.Dockerfile
new file mode 100644
index 0000000..fecd9ae
--- /dev/null
+++ b/docker/base.Dockerfile
@@ -0,0 +1,17 @@
+FROM python:3.7.7-slim-buster
+
+WORKDIR /app
+
+COPY requirements.txt requirements.txt
+COPY Makefile Makefile
+COPY protos protos
+
+RUN apt-get update \
+    && apt-get install make \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --upgrade pip \
+    && pip install -r requirements.txt \
+    && rm -rf ~/.cache/pip
+
+RUN make protobuf
\ No newline at end of file
diff --git a/docker/client.Dockerfile b/docker/client.Dockerfile
new file mode 100644
index 0000000..539c538
--- /dev/null
+++ b/docker/client.Dockerfile
@@ -0,0 +1,9 @@
+FROM easyfl:base
+
+WORKDIR /app
+
+COPY . .
+
+ENV PYTHONPATH=/app:$PYTHONPATH
+
+ENTRYPOINT ["python", "examples/remote_client.py"]
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
new file mode 100644
index 0000000..a7d5895
--- /dev/null
+++ b/docker/docker-compose.yml
@@ -0,0 +1,105 @@
+version: "3"
+services:
+  etcd0:
+    image: quay.io/coreos/etcd:v3.4.0
+    container_name: etcd
+    ports:
+      - 23790:2379
+      - 23800:2380
+    volumes:
+      - etcd0:/etcd-data
+    environment:
+      - ETCD0=localhost
+    command:
+      - /usr/local/bin/etcd
+      - -name
+      - etcd0
+      - --data-dir
+      - /etcd_data
+      - -advertise-client-urls
+      - http://etcd0:2379
+      - -listen-client-urls
+      - http://0.0.0.0:2379
+      - -initial-advertise-peer-urls
+      - http://etcd0:2380
+      - -listen-peer-urls
+      - http://0.0.0.0:2380
+      - -initial-cluster
+      - etcd0=http://etcd0:2380
+    networks:
+      - easyfl
+
+  docker-register:
+    image: wingalong/docker-register
+    container_name: docker-regiser
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      - HOST_IP=172.25.0.1
+      - ETCD_HOST=etcd0:2379
+    networks:
+      - easyfl
+    depends_on:
+      - etcd0
+
+  tracker:
+    image: easyfl-tracker
+    container_name: easyfl-tracker
+    ports:
+      - "12666:12666"
+    volumes:
+      - /home/zwm/easyfl/tracker:/app/tracker
+    networks:
+      - easyfl
+    environment:
+      - PYTHONUNBUFFERED=1
+
+  client:
+    image: easyfl-client
+    ports:
+      - "23400-23500:23400"
+    volumes:
+      - /home/zwm/easyfl/easyfl/datasets/femnist/data:/app/easyfl/datasets/femnist/data
+    command: ["--is-remote", "True", "--local-port", "23400", "--server-addr", "easyfl-server:23501", "--tracker-addr", "easyfl-tracker:12666"]
+    networks:
+      - easyfl
+    environment:
+      - PYTHONUNBUFFERED=1
+    depends_on:
+      - tracker
+#      - etcd0
+#      - docker-register
+
+  server:
+    image: easyfl-server
+    container_name: easyfl-server
+    ports:
+      - "23501:23501"
+    command: ["--is-remote", "True", "--local-port", "23501", "--tracker-addr", "easyfl-tracker:12666"]
+    networks:
+      - easyfl
+    environment:
+      - PYTHONUNBUFFERED=1
+    depends_on:
+      - tracker
+#      - etcd0
+#      - docker-register
+
+#  trigger_run:
+#    image: easyfl-run
+#    command:
+#      - --server-addr
+#      - 172.21.0.1:23501
+#      - --etcd-addr
+#      - 172.21.0.1:2379
+#    networks:
+#      - easyfl
+#    depends_on:
+#      - client
+#      - server
+
+volumes:
+  etcd0:
+
+networks:
+  easyfl:
\ No newline at end of file
diff --git a/docker/run.Dockerfile b/docker/run.Dockerfile
new file mode 100644
index 0000000..b4c3d5c
--- /dev/null
+++ b/docker/run.Dockerfile
@@ -0,0 +1,9 @@
+FROM easyfl:base
+
+WORKDIR /app
+
+COPY . .
+
+ENV PYTHONPATH=/app:$PYTHONPATH
+
+ENTRYPOINT ["python", "examples/remote_run.py"]
diff --git a/docker/server.Dockerfile b/docker/server.Dockerfile
new file mode 100644
index 0000000..fd5fde2
--- /dev/null
+++ b/docker/server.Dockerfile
@@ -0,0 +1,9 @@
+FROM easyfl:base
+
+WORKDIR /app
+
+COPY . .
+
+ENV PYTHONPATH=/app:$PYTHONPATH
+
+ENTRYPOINT ["python", "examples/remote_server.py"]
diff --git a/docker/tracker.Dockerfile b/docker/tracker.Dockerfile
new file mode 100644
index 0000000..84fa32e
--- /dev/null
+++ b/docker/tracker.Dockerfile
@@ -0,0 +1,9 @@
+FROM easyfl:base
+
+WORKDIR /app
+
+COPY . .
+
+ENV PYTHONPATH=/app:$PYTHONPATH
+
+ENTRYPOINT ["python", "examples/remote_tracker.py"]
\ No newline at end of file
diff --git a/docs/en/Makefile b/docs/en/Makefile
new file mode 100644
index 0000000..d4bb2cb
--- /dev/null
+++ b/docs/en/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/docs/en/_static/css/readthedocs.css b/docs/en/_static/css/readthedocs.css
new file mode 100644
index 0000000..82a13e5
--- /dev/null
+++ b/docs/en/_static/css/readthedocs.css
@@ -0,0 +1,6 @@
+.header-logo {
+    background-image: url("../image/easyfl-logo.png");
+    background-size: 156px 40px;
+    width: 156px;
+    height: 40px;
+}
diff --git a/docs/en/_static/image/architecture.png b/docs/en/_static/image/architecture.png
new file mode 100644
index 0000000000000000000000000000000000000000..c36583863d6dfa0041fcf3e0dfc532ddb0d81477
GIT binary patch
literal 319813
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
Fe*gwRRf+%r

literal 0
HcmV?d00001

diff --git a/docs/en/_static/image/docker.png b/docs/en/_static/image/docker.png
new file mode 100644
index 0000000000000000000000000000000000000000..03f0f4593c125e698f9c0ab9861df5f55df86f7c
GIT binary patch
literal 46575
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
Sn`*TQezer})$-5U-S{7KEcXxq

literal 0
HcmV?d00001

diff --git a/docs/en/_static/image/easyfl-logo.png b/docs/en/_static/image/easyfl-logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..840d3b4151678755b0c138d04bdbb4d121c3a2ff
GIT binary patch
literal 25810
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

literal 0
HcmV?d00001

diff --git a/docs/en/_static/image/registry.png b/docs/en/_static/image/registry.png
new file mode 100644
index 0000000000000000000000000000000000000000..93557bebab595f19e71e0ff8bae28d84917cad76
GIT binary patch
literal 75632
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%0Doaq`)QB8yMY+qN*Pq;tv;P?tZUSG;
z>}p&W`8EW1TxbnqcoLpqvIhvKN7C%G?lVo4=`XAPDP}-s%)~)Cp-(G#E=J4*6wPnv
z)JXjI@}>dh4$;vAWKL<;p;xo>R6Ho?7}o7isY%4}-ok3hB-&6mz>Fdzt`A)^S-U!z
zXQIH$Pi_a?R4mI7GzW%1G2p`<jVy;q(y{vcE&z#QbM<2Lgy-_97mop_&G0k}HOx*>
zQAbRW0ZU3zjmC26PSxJ$HPK&2gIQsmFyYkO2@yWy4oFZ{YMY#~Std{dFttYd?GxJ1
zFe4CjW~s#aUGosDP#@2b7h5Y#!_^hb-IBk5F3acL^2E(>(UgE8dQ|=fO@(Uq@?+Y_
zT<^w;cG&VBp*+g%ngJ2xJwcS*Mt)~D+MUafb^o3r1*{Ao&tpc=4iwLR_v8qmmTWa@
zI0g#d=aN$$yCU(dVra@^TWJD$-(Osr6H^kPj!Ft4;7|{E%LA;8a7m8}s|o+yZK#$m
zhAgMmS$e6Xgh?|f61xlS;achae5vFXon%hi33mKxaYeJ*y4jfwLvd#rSMsA)IdMD<
z1kONVpZDAfAY|J8#FKp<OTGL_B%^BdriI+NU3(RXaPJ`Mn@iX1y#(1e`Pc1TxSd>#
zxxXi*jfdC8(@p6(Q+4on%T74;mQJuX$t=CX$1)+eY^FVNd9^<v-&G^ewD??a5<ZDv
z^2GGvC;XZCFJ#Ao7}nK&Aa%DW#SVVPGx4ko*<RIMi`3L4(`@g2N!R7&H+PpNj&n}E
zbh)45e`+zHHdu~RC-GU3O`VqG(nP4M<E9I3hb?-9(kAILvzU%Sb%0D1YU!6BpN*wT
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
SbomJQCn_u{RQ&Gqm;VP&3aD5B

literal 0
HcmV?d00001

diff --git a/docs/en/_static/image/training-flow.png b/docs/en/_static/image/training-flow.png
new file mode 100644
index 0000000000000000000000000000000000000000..92d10d005c7651f4b25733032a8db317db0ddc7b
GIT binary patch
literal 58955
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
D&BXdJ

literal 0
HcmV?d00001

diff --git a/docs/en/api.rst b/docs/en/api.rst
new file mode 100644
index 0000000..e915a85
--- /dev/null
+++ b/docs/en/api.rst
@@ -0,0 +1,40 @@
+easyfl
+--------------
+.. automodule:: easyfl
+    :members:
+
+easyfl.server
+--------------
+.. automodule:: easyfl.server
+    :members:
+
+easyfl.client
+--------------
+.. automodule:: easyfl.client
+    :members:
+
+easyfl.distributed
+------------------
+.. automodule:: easyfl.distributed
+    :members:
+
+easyfl.dataset
+--------------
+.. automodule:: easyfl.datasets
+    :members:
+
+easyfl.models
+--------------
+.. automodule:: easyfl.models
+    :members:
+
+easyfl.communication
+--------------------
+.. automodule:: easyfl.communication
+    :members:
+
+easyfl.registry
+---------------
+.. automodule:: easyfl.registry
+    :members:
+
diff --git a/docs/en/changelog.md b/docs/en/changelog.md
new file mode 100644
index 0000000..f94e3cb
--- /dev/null
+++ b/docs/en/changelog.md
@@ -0,0 +1,5 @@
+## Changelog
+
+### v0.1.0 (05/04/2022)
+
+- Official release
diff --git a/docs/en/conf.py b/docs/en/conf.py
new file mode 100644
index 0000000..bca9d13
--- /dev/null
+++ b/docs/en/conf.py
@@ -0,0 +1,125 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import subprocess
+import sys
+
+import pytorch_sphinx_theme
+
+sys.path.insert(0, os.path.abspath('../..'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'EasyFL'
+copyright = '2020-2022, EasyFL'
+author = 'EasyFL Authors'
+version_file = '../../easyfl/version.py'
+
+
+def get_version():
+    with open(version_file, 'r') as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+# # The full version, including alpha/beta/rc tags
+release = get_version()
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'recommonmark',
+    'sphinx_markdown_tables',
+    'sphinx_copybutton',
+]
+
+autodoc_mock_imports = [
+    'matplotlib', 'pycocotools', 'terminaltables', 'mmdet.version', 'mmcv.ops'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = {
+    '.rst': 'restructuredtext',
+    '.md': 'markdown',
+}
+
+# The master toctree document.
+master_doc = 'index'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = 'sphinx_rtd_theme'
+html_theme = 'pytorch_sphinx_theme'
+html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
+
+html_theme_options = {
+    'menu': [
+        {
+            'name': 'Get Started',
+            'url': 'get_started.html'
+        },
+        {
+            'name': 'Tutorials',
+            'url': 'tutorials/high-level_apis.html'
+        },
+        {
+            'name': 'API',
+            'url': 'api.html'
+        },
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/EasyFL-AI/easyfl'
+        },
+    ],
+
+    # 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
+
+
+# def builder_inited_handler(app):
+#     subprocess.run(['./stat.py'])
+
+
+# def setup(app):
+#     app.connect('builder-inited', builder_inited_handler)
diff --git a/docs/en/faq.md b/docs/en/faq.md
new file mode 100644
index 0000000..13f9fb8
--- /dev/null
+++ b/docs/en/faq.md
@@ -0,0 +1,8 @@
+# Frequently Asked Questions
+
+We list some common troubles faced by many users and their corresponding solutions here. Feel free to enrich the list if you find any frequent issues and have ways to help others to solve them. If the contents here do not cover your issue, please create an issue using the [provided templates](https://github.com/EasyFL-AI/easyfl/blob/master/.github/ISSUE_TEMPLATE/error-report.md/) and make sure you fill in all required information in the template.
+
+## EasyFL Installation
+
+Waiting for your input :)
+
diff --git a/docs/en/get_started.md b/docs/en/get_started.md
new file mode 100644
index 0000000..9f165a1
--- /dev/null
+++ b/docs/en/get_started.md
@@ -0,0 +1,87 @@
+## Prerequisites
+
+- Linux or macOS (Windows is in experimental support)
+- Python 3.6+
+- PyTorch 1.3+
+- CUDA 9.2+ (If you run using GPU)
+
+## Installation
+
+### Prepare environment
+
+1. Create a conda virtual environment and activate it.
+
+    ```shell
+    conda create -n easyfl python=3.7 -y
+    conda activate easyfl
+    ```
+
+2. Install PyTorch and torchvision following the [official instructions](https://pytorch.org/), e.g.,
+
+    ```shell
+    conda install pytorch torchvision -c pytorch
+    ```
+    or
+    ```shell
+    pip install torch==1.10.1 torchvision==0.11.2
+    ```
+
+4. _You can skip the following CUDA-related content if you plan to run it on CPU._ Make sure that your compilation CUDA version and runtime CUDA version match. 
+
+    Note: Make sure that your compilation CUDA version and runtime CUDA version match.
+    You can check the supported CUDA version for precompiled packages on the [PyTorch website](https://pytorch.org/).
+
+    `E.g.,` 1. If you have CUDA 10.1 installed under `/usr/local/cuda` and would like to install
+    PyTorch 1.5, you need to install the prebuilt PyTorch with CUDA 10.1.
+
+    ```shell
+    conda install pytorch cudatoolkit=10.1 torchvision -c pytorch
+    ```
+
+    `E.g.,` 2. If you have CUDA 9.2 installed under `/usr/local/cuda` and would like to install
+    PyTorch 1.3.1., you need to install the prebuilt PyTorch with CUDA 9.2.
+
+    ```shell
+    conda install pytorch=1.3.1 cudatoolkit=9.2 torchvision=0.4.2 -c pytorch
+    ```
+
+    If you build PyTorch from source instead of installing the prebuilt package,
+    you can use more CUDA versions such as 9.0.
+
+### Install EasyFL
+
+```shell
+pip install easyfl
+```
+
+### A from-scratch setup script
+
+Assuming that you already have CUDA 10.1 installed, here is a full script for setting up MMDetection with conda.
+
+```shell
+conda create -n easyfl python=3.7 -y
+conda activate easyfl
+
+# Without GPU
+conda install pytorch==1.6.0 torchvision==0.7.0 -c pytorch -y
+
+# With GPU
+conda install pytorch==1.6.0 torchvision==0.7.0 cudatoolkit=10.1 -c pytorch -y
+
+# install easyfl
+git clone https://github.com/EasyFL-AI/easyfl.git
+cd easyfl
+pip install -v -e .
+```
+
+## Verification
+
+To verify whether EasyFL is installed correctly, we can run the following sample code to test.
+
+```python
+import easyfl
+
+easyfl.init()
+```
+
+The above code is supposed to run successfully after you finish the installation.
diff --git a/docs/en/index.rst b/docs/en/index.rst
new file mode 100644
index 0000000..4327e65
--- /dev/null
+++ b/docs/en/index.rst
@@ -0,0 +1,48 @@
+Welcome to MMDetection's documentation!
+=======================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Introduction
+
+   introduction.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Get Started
+
+   get_started.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Quick Run
+
+   quick_run.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Tutorials
+
+   tutorials/index.rst
+
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Notes
+
+   projects.md
+   changelog.md
+   faq.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API Reference
+
+   api.rst
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`search`
diff --git a/docs/en/introduction.md b/docs/en/introduction.md
new file mode 100644
index 0000000..3b96875
--- /dev/null
+++ b/docs/en/introduction.md
@@ -0,0 +1,51 @@
+## Why EasyFL?
+
+**EasyFL** is an easy-to-use federated learning platform that aims to enable users with various levels of expertise to experiment and prototype FL applications with little/no coding. 
+
+You can use it for:
+* FL Research on algorithm and system
+* Proof-of-concept (POC) of new FL applications
+* Prototype of industrial applications
+* Learning FL implementations
+
+We currently focus on horizontal FL, supporting both cross-silo and cross-device FL. You can learn more about federated learning from these [resources](https://github.com/weimingwill/awesome-federated-learning#blogs). 
+
+### Major Features
+
+**Easy to Start**
+
+EasyFL is easy to install and easy to learn. It does not have complex dependency requirements. You can run EasyFL on your personal computer with only three lines of code ([Quick Start](quick_run.md)).
+
+**Out-of-the-box Functionalities**
+
+EasyFL provides many out-of-the-box functionalities, including datasets, models, and FL algorithms. With simple configurations, you simulate different FL scenarios using the popular datasets. We support both statistical heterogeneity simulation and system heterogeneity simulation.
+
+**Flexible, Customizable, and Reproducible**
+
+EasyFL is flexible to be customized according to your needs. You can easily migrate existing CV or NLP applications into the federated manner by writing the PyTorch codes that you are most familiar with. 
+
+**Multiple Training Modes**
+
+EasyFL supports **standalone training**, **distributed training**, and **remote training**. By developing the code once, you can easily speed up FL training with distributed training on multiple GPUs. Besides, you can even deploy it to Kubernetes with Docker using remote training.
+
+We have developed many applications and published several [papers](projects.md) in top-tier conferences and journals using EasyFL. We believe that EasyFL will empower you with FL research and development.
+
+## Architecture Overview
+
+Here we introduce the architecture of EasyFL. You can jump directly to [Get Started](get_started.md) without knowing these details.
+
+EasyFL's architecture comprises of an **interface layer** and a modularized **system layer**. The interface layer provides simple APIs for high-level applications and the system layer has complex implementations to accelerate training and shorten deployment time with out-of-the-box functionalities.
+
+![architecture](_static/image/architecture.png)
+
+**Interface Layer**: The interface layer provides a common interface across FL applications. It contains APIs that are designed to encapsulate complex system implementations from users. These APIs decouple application-specific models, datasets, and algorithms such that EasyFL is generic to support a wide range of applications like computer vision and healthcare.
+ 
+**System Layer**: The system layer supports and manages the FL life cycle. It consists of eight modules to support FL training pipeline and life cycle: 
+1. The simulation manager initializes the experimental environment with heterogeneous simulations. 
+2. The data manager loads training and testing datasets, and the model manager loads the model. 
+3. A server and the clients start training and testing with FL algorithms such as FedAvg. 
+4. The distribution manager optimizes the training speed of distributed training. 
+5. The tracking manager collects the evaluation metrics and provides methods to query training results. 
+6. The deployment manager seamlessly deploys FL and scales FL applications in production.
+
+To learn more about EasyFL, you can check out our [paper](https://arxiv.org/abs/2105.07603).
diff --git a/docs/en/make.bat b/docs/en/make.bat
new file mode 100644
index 0000000..922152e
--- /dev/null
+++ b/docs/en/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/docs/en/projects.md b/docs/en/projects.md
new file mode 100644
index 0000000..11c29b2
--- /dev/null
+++ b/docs/en/projects.md
@@ -0,0 +1,11 @@
+# Projects based on EasyFL
+
+We have built several projects based on EasyFL and published four papers in top-tier conferences and journals. 
+We list them as examples of how to extend EasyFL for your projects.
+
+- EasyFL: A Low-code Federated Learning Platform For Dummies, _IEEE Internet-of-Things Journal_. [[paper]](https://arxiv.org/abs/2105.07603)
+- Divergence-aware Federated Self-Supervised Learning, _ICLR'2022_. [[paper]](https://openreview.net/forum?id=oVE1z8NlNe)
+- Collaborative Unsupervised Visual Representation Learning From Decentralized Data, _ICCV'2021_. [[paper]](https://openaccess.thecvf.com/content/ICCV2021/html/Zhuang_Collaborative_Unsupervised_Visual_Representation_Learning_From_Decentralized_Data_ICCV_2021_paper.html)
+- Joint Optimization in Edge-Cloud Continuum for Federated Unsupervised Person Re-identification, _ACMMM'2021_. [[paper]](https://arxiv.org/abs/2108.06493)
+
+If you have built new projects using EasyFL, please feel free to create PR to update this page.
diff --git a/docs/en/quick_run.md b/docs/en/quick_run.md
new file mode 100644
index 0000000..3f0232e
--- /dev/null
+++ b/docs/en/quick_run.md
@@ -0,0 +1,49 @@
+## High-level Introduction
+
+EasyFL provides numerous existing models and datasets. Models include LeNet, RNN, VGG9, and ResNet. Datasets include Femnist, Shakespeare, CIFAR-10, and CIFAR-100. 
+This note will present how to start training with these existing models and standard datasets.
+
+EasyFL provides three types of high-level APIs: **registration**, **initialization**, and **execution**.
+Registration is for registering customized components, which we will introduce in the following notes.
+In this note, we focus on **initialization** and **execution**.
+
+## Simplest Run
+
+We can run federated learning with only two lines of code (not counting the import statement).
+It executes training with default configurations: simulating 100 clients with the FEMNIST dataset and randomly selecting 5 clients for training in each training round.
+We explain more about the configurations in [another note](tutorials/config.md).
+
+Note: we package default partitioning of Femnist data to avoid downloading the whole dataset.
+
+```python
+import easyfl
+
+# Initialize federated learning with default configurations.
+easyfl.init()
+# Execute federated learning training.
+easyfl.run()
+```
+
+## Run with Configurations
+
+You can specify configurations to overwrite the default configurations.
+
+```python
+import easyfl
+
+# Customized configuration.
+config = {
+    "data": {"dataset": "cifar10", "split_type": "class", "num_of_clients": 100},
+    "server": {"rounds": 5, "clients_per_round": 2},
+    "client": {"local_epoch": 5},
+    "model": "resnet18",
+    "test_mode": "test_in_server",
+}
+# Initialize federated learning with default configurations.
+easyfl.init(config)
+# Execute federated learning training.
+easyfl.run()
+```
+
+In the example above, we run training with model ResNet-18 and CIFAR-10 dataset that is partitioned into 100 clients by label `class`.
+It runs training with 2 clients per round for 5 rounds. In each round, each client trains 5 epochs.
diff --git a/docs/en/tutorials/config.md b/docs/en/tutorials/config.md
new file mode 100644
index 0000000..6d6cd04
--- /dev/null
+++ b/docs/en/tutorials/config.md
@@ -0,0 +1,318 @@
+# Tutorial 2: Configurations
+
+Configurations in EasyFL are to control and config the federated learning (FL) training behavior. It instructs data simulation, the model for training, training hyperparameters, distributed training, etc. 
+
+We provide [default configs](#default-configurations) in EasyFL, while there are two ways you can modify the configs of EasyFL: using Python and using a yaml file.
+
+## Modify Config
+
+EasyFL provides two ways to modify the configurations: using Python dictionary and using a yaml file. Either way, if the new configs exist in the default configuration, they overwrite those specific fields. If the new configs do not exist, it adds them to the EasyFL configuration. Thus, you can either modify the default configurations or add new configurations based on your application needs.
+
+### 1. Modify Using Python Dictionary
+
+You can create a new Python dictionary to specify configurations. These configs take effect when you initialize EasyFL with them by calling `easyfl.init(config)`.   
+ 
+The examples provided in the previous [tutorial](high-level_apis.md) demonstrate how to modify config via a Python dictionary.  
+```python
+import easyfl
+
+# Define customized configurations.
+config = {
+    "data": {
+        "dataset": "cifar10", 
+        "num_of_clients": 1000
+    },
+    "server": {
+        "rounds": 5, 
+        "clients_per_round": 2
+    },
+    "client": {"local_epoch": 5},
+    "model": "resnet18",
+    "test_mode": "test_in_server",
+}
+# Initialize EasyFL with the new config.
+easyfl.init(config)
+# Execute federated learning training.
+easyfl.run()
+```
+
+### 2. Modify Using A Yaml File
+
+You can create a new yaml file named `config.yaml` for configuration and load them into EasyFL.
+
+```python
+import easyfl
+# Define customized configurations in a yaml file.
+config_file = "config.yaml"
+# Load the yaml file as config.
+config = easyfl.load_config(config_file)
+# Initialize EasyFL with the new config.
+easyfl.init(config)
+# Execute federated learning training.
+easyfl.run()
+```
+
+You can also combine these two methods of modifying configs.
+
+```python
+import easyfl
+
+# Define part of customized configs.
+config = {
+    "data": {
+        "dataset": "cifar10", 
+        "num_of_clients": 1000
+    },
+    "server": {
+        "rounds": 5, 
+        "clients_per_round": 2
+    },
+    "client": {"local_epoch": 5},
+    "model": "resnet18",
+    "test_mode": "test_in_server",
+}
+
+# Define part of configs in a yaml file.
+config_file = "config.yaml"
+# Load and combine these two configs.
+config = easyfl.load_config(config_file, config)
+# Initialize EasyFL with the new config.
+easyfl.init(config)
+# Execute federated learning training.
+easyfl.run()
+```
+
+## A Common Practice to Modify Configuration
+
+Since some configurations are directly related to training, we may need to set them dynamically with different values. 
+
+For example, we may want to experiment with the effect of batch size and local epoch on federated learning. Instead of changing the value manually each time in configuration, you can pass the value in as command-line arguments and set the value with different commands.
+
+```python
+import easyfl
+import argparse
+
+# Define command line arguments.
+parser = argparse.ArgumentParser(description='Example')
+parser.add_argument("--batch_size", type=int, default=32)
+parser.add_argument("--local_epoch", type=int, default=5)
+args = parser.parse_args()
+print("args", args)
+
+# Define customized configurations using the arguments.
+config = {
+    "client": {
+        "batch_size": args.batch_size,
+        "local_epoch": args.local_epoch,
+    }
+}
+# Initialize EasyFL with the new config.
+easyfl.init(config)
+# Execute federated learning training.
+easyfl.run()
+```
+
+
+## Default Configurations
+
+The followings are the default configurations in EasyFL. 
+They are copied from `easyfl/config.yaml` on April, 2022.
+
+We provide more details on how to simulate different FL scenarios with the out-of-the-box datasets in [another note](dataset.md).  
+
+```yaml
+# The unique identifier for each federated learning task
+task_id: ""
+
+# Provide dataset and federated learning simulation related configuration.
+data:
+  # The root directory where datasets are stored.
+  root: "./data/"
+  # The name of the dataset, support: femnist, shakespeare, cifar10, and cifar100.
+  dataset: femnist
+  # The data distribution of each client, support: iid, niid (for femnist and shakespeare), and dir and class (for cifar datasets).
+    # `iid` means independent and identically distributed data.
+    # `niid` means non-independent and identically distributed data for Femnist and Shakespeare.
+    # `dir` means using Dirichlet process to simulate non-iid data, for CIFAR-10 and CIFAR-100 datasets.
+    # `class` means partitioning the dataset by label classes, for datasets like CIFAR-10, CIFAR-100.
+  split_type: "iid"
+  
+  # The minimal number of samples in each client. It is applicable for LEAF datasets and dir simulation of CIFAR-10 and CIFAR-100.
+  min_size: 10
+  # The fraction of data sampled for LEAF datasets. e.g., 10% means that only 10% of total dataset size are used.
+  data_amount: 0.05
+  # The fraction of the number of clients used when the split_type is 'iid'.
+  iid_fraction: 0.1
+  # Whether partition users of the dataset into train-test groups. Only applicable to femnist and shakespeare datasets.
+    # True means partitioning users of the dataset into train-test groups.
+    # False means partitioning each users' samples into train-test groups.
+  user: False
+  # The fraction of data for training; the rest are for testing.
+  train_test_split: 0.9
+
+  # The number of classes in each client. Only applicable when the split_type is 'class'.  
+  class_per_client: 1
+  # The targeted number of clients to construct.used in non-leaf dataset, number of clients split into. for leaf dataset, only used when split type class.
+  num_of_clients: 100
+
+  # The parameter for Dirichlet distribution simulation, applicable only when split_type is `dir` for CIFAR datasets.
+  alpha: 0.5
+
+  # The targeted distribution of quantities to simulate data quantity heterogeneity.
+    # The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+    # The `num_of_clients` should be divisible by `len(weights)`.
+    # None means clients are simulated with the same data quantity.
+  weights: NULL
+
+# The name of the model for training, support: lenet, rnn, resnet, resnet18, resnet50, vgg9.
+model: lenet
+# How to conduct testing, options: test_in_client or test_in_server.
+  # `test_in_client` means that each client has a test set to run testing.
+  # `test_in_server` means that server has a test set to run testing for the global model. Use this mode for cifar datasets.
+test_mode: "test_in_client"
+# The way to measure testing performance (accuracy) when test mode is `test_in_client`, support: average or weighted (means weighted average).
+test_method: "average"
+
+server:
+  track: False  # Whether track server metrics using the tracking service.
+  rounds: 10  # Total training round.
+  clients_per_round: 5  # The number of clients to train in each round.
+  test_every: 1  # The frequency of testing: conduct testing every N round.
+  save_model_every: 10  # The frequency of saving model: save model every N round.
+  save_model_path: ""  # The path to save model. Default path is root directory of the library.
+  batch_size: 32  # The batch size of test_in_server.
+  test_all: True  # Whether test all clients or only selected clients.
+  random_selection: True  # Whether select clients to train randomly.
+  # The strategy to aggregate client uploaded models, options: FedAvg, equal.
+    # FedAvg aggregates models using weighted average, where the weights are data size of clients.
+    # equal aggregates model by simple averaging.
+  aggregation_stragtegy: "FedAvg"
+  # The content of aggregation, options: all, parameters.
+    # all means aggregating models using state_dict, including both model parameters and persistent buffers like BatchNorm stats.
+    # parameters means aggregating only model parameters.
+  aggregation_content: "all"
+
+client:
+  track: False  # Whether track server metrics using the tracking service.
+  batch_size: 32  # The batch size of training in client.
+  test_batch_size: 5  # The batch size of testing in client.
+  local_epoch: 10  # The number of epochs to train in each round.
+  optimizer:
+    type: "Adam"  # The name of the optimizer, options: Adam, SGD.
+    lr: 0.001
+    momentum: 0.9
+    weight_decay: 0
+  seed: 0
+  local_test: False  # Whether test the trained models in clients before uploading them to the server.
+
+gpu: 0  # The total number of GPUs used in training. 0 means CPU.
+distributed:  # The distributed training configurations. It is only applicable when gpu > 1.
+  backend: "nccl"  # The distributed backend.
+  init_method: ""
+  world_size: 0
+  rank: 0
+  local_rank: 0
+
+tracking:  # The configurations for logging and tracking.
+  database: ""  # The path of local dataset, sqlite3.
+  log_file: ""
+  log_level: "INFO"  # The level of logging.
+  metric_file: ""
+  save_every: 1
+
+# The configuration for system heterogeneity simulation.
+resource_heterogeneous:
+  simulate: False  # Whether simulate system heterogeneity in federated learning.
+  # The type of heterogeneity to simulate, support iso, dir, real.
+    # iso means that
+  hetero_type: "real"
+  level: 3  # The level of heterogeneous (0-5), 0 means no heterogeneous among clients.
+  sleep_group_num: 1000  # The number of groups with different sleep time. 1 means all clients are the same.
+  total_time: 1000  # The total sleep time of all clients, unit: second.
+  fraction: 1  # The fraction of clients attending heterogeneous simulation.
+  grouping_strategy: "greedy"  # The grouping strategy to handle system heterogeneity, support: random, greedy, slowest.
+  initial_default_time: 5  # The estimated default training time for each training round, unit: second.
+  default_time_momentum: 0.2  # The default momentum for default time update.
+
+seed: 0  # The random seed.
+```
+
+### Default Config without Comments
+
+```yaml
+task_id: ""
+data:
+  root: "./data/"
+  dataset: femnist
+  split_type: "iid"
+  
+  min_size: 10
+  data_amount: 0.05
+  iid_fraction: 0.1
+  user: False
+  
+  class_per_client: 1
+  num_of_clients: 100
+  train_test_split: 0.9  
+  alpha: 0.5
+  
+  weights: NULL
+  
+model: lenet
+test_mode: "test_in_client"
+test_method: "average"
+
+server:
+  track: False
+  rounds: 10
+  clients_per_round: 5
+  test_every: 1
+  save_model_every: 10
+  save_model_path: ""
+  batch_size: 32
+  test_all: True
+  random_selection: True
+  aggregation_stragtegy: "FedAvg"
+  aggregation_content: "all"
+
+client:
+  track: False
+  batch_size: 32
+  test_batch_size: 5
+  local_epoch: 10
+  optimizer:
+    type: "Adam"
+    lr: 0.001
+    momentum: 0.9
+    weight_decay: 0
+  seed: 0
+  local_test: False
+
+gpu: 0
+distributed:
+  backend: "nccl"
+  init_method: ""
+  world_size: 0
+  rank: 0
+  local_rank: 0
+
+tracking:
+  database: ""
+  log_file: ""
+  log_level: "INFO"
+  metric_file: ""
+  save_every: 1
+
+resource_heterogeneous:
+  simulate: False
+  hetero_type: "real"
+  level: 3
+  sleep_group_num: 1000
+  total_time: 1000
+  fraction: 1
+  grouping_strategy: "greedy"
+  initial_default_time: 5
+  default_time_momentum: 0.2
+
+seed: 0  
+```
diff --git a/docs/en/tutorials/customize_server_and_client.md b/docs/en/tutorials/customize_server_and_client.md
new file mode 100644
index 0000000..b349157
--- /dev/null
+++ b/docs/en/tutorials/customize_server_and_client.md
@@ -0,0 +1,281 @@
+# Tutorial 5: Customize Server and Client
+
+EasyFL abstracts the federated learning (FL) training flow in the server and the client into granular stages, as shown in the image below.
+
+![Training Flow](../_static/image/training-flow.png)
+
+You have the flexibility to customize any stage of the training flow while reusing the rest by implementing a customized server/client.  
+
+## Customize Server
+
+EasyFL implements random client selection and [Federated Averaging](https://arxiv.org/abs/1602.05629) as the aggregation strategy. 
+You can customize the server implementation by inheriting [BaseServer](../api.html#easyfl.server.BaseServer) and override specific functions.
+
+Below is an example of a customized server. 
+```python
+import easyfl
+from easyfl.server import BaseServer
+from easyfl.server.base import MODEL
+
+class CustomizedServer(BaseServer):
+    def __init__(self, conf, **kwargs):
+        super(CustomizedServer, self).__init__(conf, **kwargs)
+        pass  # more initialization of attributes.
+    
+    def aggregation(self):
+        uploaded_content = self.get_client_uploads()
+        models = list(uploaded_content[MODEL].values())
+        # Original implementation of aggregation weights
+        # weights = list(uploaded_content[DATA_SIZE].values())
+        # We can assign the manipulated customized weights in aggregation.   
+        customized_weights = list(range(len(models)))
+        model = self.aggregate(models, customized_weights)
+        self.set_model(model, load_dict=True)
+
+# Register customized server.
+easyfl.register_server(CustomizedServer)
+# Initialize federated learning with default configurations.
+easyfl.init()
+# Execute federated learning training.
+easyfl.run()
+```
+
+Here we list down more useful functions to override to implement a customized server.  
+
+```python
+import easyfl
+from easyfl.server import BaseServer
+
+class CustomizedServer(BaseServer):
+    def __init__(self, conf, **kwargs):
+        super(CustomizedServer, self).__init__(conf, **kwargs)
+        pass  # more initialization of attributes.
+    
+    def selection(self, clients, clients_per_round):
+        pass  # implement customized client selection algorithm.
+    
+    def compression(self):
+        pass  # implement customized compression algorithm.
+    
+    def pre_train(self):
+        pass  # inject operations before distribution to train.
+    
+    def post_train(self):
+        pass  # inject operations after aggregation.
+    
+    def pre_test(self):
+        pass  # inject operations before distribution to test. 
+    
+    def post_test(self):
+        pass  # inject operations after aggregating testing results.
+    
+    def decompression(self, model):
+        pass  # implement customized decompression algorithm.
+    
+    def aggregation(self):
+        pass  # implement customized aggregation algorithm.
+```
+
+Below are some attributes that you may need in implementing the customized server.
+
+`self.conf`: Configurations of EasyFL.
+
+`self._model`: The global model in server, updated after aggregation.
+
+`self._current_round`: The current training round.
+
+`self._clients`: All available clients.
+
+`self.selected_clients`: The selected clients.
+
+You may refer to the [BaseServer](../api.html#easyfl.server.BaseServer) for more functions and class attributes.
+
+## Customize Client
+
+Each client of EasyFL conducts training and testing. 
+The implementation of training and testing is similar to normal PyTorch implementation.
+We implement training with Adam/SGD optimizer using CrossEntropy loss. 
+You can customize client implementation of training and testing by inheriting [BaseClient](../api.html#easyfl.client.BaseClient) and overriding specific functions. 
+
+Below is an example of a customized client. 
+
+```python
+import time
+import easyfl
+from torch import nn
+import torch.optim as optim
+from easyfl.client.base import BaseClient
+
+# Inherit BaseClient to implement customized client operations.
+class CustomizedClient(BaseClient):
+    def __init__(self, cid, conf, train_data, test_data, device, **kwargs):
+        super(CustomizedClient, self).__init__(cid, conf, train_data, test_data, device, **kwargs)
+        # Initialize a classifier for each client.
+        self.classifier = nn.Sequential(*[nn.Linear(512, 100)])
+
+    def train(self, conf, device):
+        start_time = time.time()
+        self.model.classifier.classifier = self.classifier.to(device)
+        loss_fn, optimizer = self.pretrain_setup(conf, device)
+        self.train_loss = []
+        for i in range(conf.local_epoch):
+            batch_loss = []
+            for batched_x, batched_y in self.train_loader:
+                x, y = batched_x.to(device), batched_y.to(device)
+                optimizer.zero_grad()
+                out = self.model(x)
+                loss = loss_fn(out, y)
+                loss.backward()
+                optimizer.step()
+                batch_loss.append(loss.item())
+            current_epoch_loss = sum(batch_loss) / len(batch_loss)
+            self.train_loss.append(float(current_epoch_loss))
+        self.train_time = time.time() - start_time
+        # Keep the classifier in clients and upload only the backbone of model. 
+        self.classifier = self.model.classifier.classifier
+        self.model.classifier.classifier = nn.Sequential()        
+
+    # A customized optimizer that sets different learning rates for different model parts.
+    def load_optimizer(self, conf):
+        ignored_params = list(map(id, self.model.classifier.parameters()))
+        base_params = filter(lambda p: id(p) not in ignored_params, self.model.parameters())
+        optimizer = optim.SGD([
+            {'params': base_params, 'lr': 0.1 * conf.optimizer.lr},
+            {'params': self.model.classifier.parameters(), 'lr': conf.optimizer.lr}
+        ], weight_decay=5e-4, momentum=conf.optimizer.momentum, nesterov=True)
+        return optimizer
+
+# Register customized client.
+easyfl.register_client(CustomizedClient)
+# Initialize federated learning with default configurations.
+easyfl.init()
+# Execute federated learning training.
+easyfl.run()
+```
+
+Here we list down more useful functions to override to implement a customized client.  
+
+```python
+import easyfl
+from easyfl.client import BaseClient
+
+# Inherit BaseClient to implement customized client operations.
+class CustomizedClient(BaseClient):
+    def __init__(self, cid, conf, train_data, test_data, device, **kwargs):
+        super(CustomizedClient, self).__init__(cid, conf, train_data, test_data, device, **kwargs)
+        pass  # more initialization of attributes.
+
+    def decompression(self):
+        pass  # implement decompression method.
+
+    def pre_train(self):
+        pass  # inject operations before training. 
+
+    def train(self, conf, device):
+        pass  # implement customized training method.
+    
+    def post_train(self):
+        pass  # inject operations after training.
+    
+    def load_loss_fn(self, conf):
+        pass  # load a customized loss function.
+        return loss
+
+    def load_optimizer(self, conf):
+        pass  # load a customized optimizer
+        return optimizer
+
+    def load_loader(self, conf):
+        pass  # load a customized data loader.
+        return train_loader
+
+    def test_local(self):
+        pass  # implement testing of the trained model before uploading to the server.
+
+    def pre_test(self):
+        pass  # inject operations before testing. 
+
+    def test(self, conf, device):
+        pass  # implement customized testing.
+    
+    def post_test(self):
+        pass  # inject operations after testing.
+
+    def encryption(self):
+        pass  # implement customized encryption method.
+
+    def compression(self):
+        pass  # implement customized compression method.
+
+    def upload(self):
+        pass  # implement customized upload method.
+
+    def post_upload(self):
+        pass  # implement customized post upload method.
+```
+
+Below are some attributes that you may need in implementing the customized client.
+
+`self.conf`: Configurations of client, under key "client" of config dictionary.
+
+`self.compressed_model`: The model downloaded from the server.
+
+`self.model`: The model used for training.
+
+`self.cid`: The client id.
+
+`self.device`: The device for training. 
+
+`self.train_data`: The training data of the client.
+
+`self.test_data`: The testing data of the client.
+
+You may refer to the [BaseClient](../api.html#easyfl.client.BaseClient) for more functions and class attributes.
+
+## Existing Works
+
+We surveyed 33 papers from recent publications of FL from both the machine learning and system community. 
+The following table shows that 10 out of 33 (~30%) publications propose new algorithms with changes in only one stage of the training flow, and the majority (~57%) change only two stages. 
+Training flow abstraction you to focus on the problems, without re-implementing the whole FL process.
+
+Annotation of the table: 
+
+_Server stages_: **Sel** -- Selection, **Com** -- Compression, **Agg** -- Aggregation
+
+_Client stages_: **Train**, **Com** -- Compression, **Enc** -- Encryption
+
+| Revenue | Title | Sel | Com | Agg | Train | Com | Enc |
+| :--- | :---: | :---: | :---: | :---: | :---: | :---: | ---: |
+| INFOCOM'20 | Optimizing Federated Learning on Non-IID Data with Reinforcement Learning | ✓ | | | | | | |
+| OSDI'21 | Oort: Informed Participant Selection for Scalable Federated Learning | ✓ | | | | | | |
+| HPDC'20 | TiFL: A Tier-based Federated Learning System | ✓ | | | | | | |
+| IoT'21 | FedMCCS: Multicriteria Client Selection Model for Optimal IoT Federated Learning | ✓ | | | | | | |
+| KDD'20 | FedFast: Going Beyond Average for Faster Training of Federated Recommender Systems | ✓ | | ✓ | | | | |
+| TNNLS 2019 | Robust and Communication-Efficient Federated Learning From Non-i.i.d. Data | | ✓ | | | | ✓ | |
+| NIPS'20 | Ensemble Distillation for Robust Model Fusion in Federated Learning | | | ✓ | | | | |
+| ICDCS 2019 | CMFL: Mitigating Communication Overhead for Federated Learning | | | | | | ✓ | |
+| ICML'20 | FetchSGD: Communication-Efficient Federated Learning with Sketching | | | ✓ | | | ✓ | |
+| ICML'20 | SCAFFOLD: Stochastic Controlled Averaging for Federated Learning | | | ✓ | | | ✓ | |
+| TPDS'20 | FedSCR: Structure-Based Communication Reduction for Federated Learning | | | ✓ | | | ✓ | |
+| HotEdge 2018 | eSGD: Communication Efficient Distributed Deep Learning on the Edge | | | | | | ✓ | |
+| ICML'20 | Adaptive Federated Optimization | | | | | ✓ | | |
+| CVPR'21 | Privacy-preserving Collaborative Learning with Automatic Transformation Search | | | | | ✓ | | |
+| MLSys'20 | Federated Optimization in Heterogeneous Networks | | | | | ✓ | | |
+| ICLR'20 | Federated Learning with Matched Averaging | | | ✓ | | ✓ | | |
+| ACMMM'20 | Performance Optimization for Federated Person Re-identification via Benchmark Analysis | | | ✓ | | ✓ | | |
+| NIPS'20 | Distributionally Robust Federated Averaging | | | ✓ | | ✓ | | |
+| NIPS'20 | Group Knowledge Transfer: Federated Learning of Large CNNs at the Edge | | | ✓ | | ✓ | | |
+| NIPS'20 | Personalized Federated Learning with Moreau Envelopes | | | ✓ | | ✓ | | |
+| ICLR'20 | Fair Resource Allocation in Federated Learning | | | ✓ | | ✓ | | |
+| ICML'20 | Federated Learning with Only Positive Labels | | | ✓ | | ✓ | | |
+| AAAI'21 | Addressing Class Imbalance in Federated Learning | | | ✓ | | ✓ | | |
+| AAAI'21 | Federated Block Coordinate Descent Scheme for Learning Global and Personalized Models | | | ✓ | | ✓ | | |
+| IoT'20 | Toward Communication-Efficient Federated Learning in the Internet of Things With Edge Computing | | | ✓ | | ✓ | ✓ | |
+| ICML'20 | Acceleration for Compressed Gradient Descent in Distributed and Federated Optimization | | | ✓ | | ✓ | ✓ | |
+| INFOCOMM 2018 | When Edge Meets Learning: Adaptive Control for Resource-Constrained Distributed Machine Learning | | | ✓ | | ✓ | | |
+| ATC'20 | BatchCrypt: Efficient Homomorphic Encryption for Cross-Silo Federated Learning | | | ✓ | | | | ✓ |
+| AAAI'21 | FLAME: Differentially Private Federated Learning in the Shuffle Model | | | ✓ | | | | ✓ |
+| TIFS'20 | Federated Learning with Differential Privacy: Algorithms and Performance Analysis | | | ✓ | | | | ✓ |
+| GLOBECOM'20 | Towards Efficient Secure Aggregation for Model Update in Federated Learning | | | ✓ | | | | ✓ |
+| MobiCom'20 | Billion-Scale Federated Learning on Mobile Clients: A Submodel Design with Tunable Privacy | | | ✓ | | ✓ | | ✓ |
+| IoT'20 | Privacy-Preserving Federated Learning in Fog Computing | | | ✓ | | ✓ | | ✓ |
diff --git a/docs/en/tutorials/dataset.md b/docs/en/tutorials/dataset.md
new file mode 100644
index 0000000..e55ee2e
--- /dev/null
+++ b/docs/en/tutorials/dataset.md
@@ -0,0 +1,232 @@
+# Tutorial 3: Datasets
+
+In this note, we present how to use the out-of-the-box datasets to simulate different federated learning (FL) scenarios.
+Besides, we introduce how to use the customized dataset in EasyFL.
+
+We currently provide four out-of-the-box datasets: FEMNIST, Shakespeare, CIFAR-10, and CIFAR-100. FEMNIST and
+Shakespeare are adopted from [LEAF benchmark](https://leaf.cmu.edu/). We plan to integrate and provide more
+out-of-the-box datasets in the future.
+
+## Out-of-the-box Datasets
+
+The simulation of different FL scenarios is configured in the configurations. You can refer to the
+other [tutorial](config.md) to learn more about how to modify configs. In this note, we focus on how to config the
+datasets with different simulations.
+
+The following are dataset configurations.
+
+```yaml
+data:
+  # The root directory where datasets are stored.
+  root: "./data/"
+  # The name of the dataset, support: femnist, shakespeare, cifar10, and cifar100.
+  dataset: femnist
+    # The data distribution of each client, support: iid, niid (for femnist and shakespeare), and dir and class (for cifar datasets).
+    # `iid` means independent and identically distributed data.
+    # `niid` means non-independent and identically distributed data for FEMNIST and Shakespeare.
+    # `dir` means using Dirichlet process to simulate non-iid data, for CIFAR-10 and CIFAR-100 datasets.
+  # `class` means partitioning the dataset by label classes, for datasets like CIFAR-10, CIFAR-100.
+  split_type: "iid"
+
+  # The minimal number of samples in each client. It is applicable for LEAF datasets and dir simulation of CIFAR-10 and CIFAR-100.
+  min_size: 10
+  # The fraction of data sampled for LEAF datasets. e.g., 10% means that only 10% of the total dataset size is used.
+  data_amount: 0.05
+  # The fraction of the number of clients used when the split_type is 'iid'.
+  iid_fraction: 0.1
+    # Whether partition users of the dataset into train-test groups. Only applicable to femnist and shakespeare datasets.
+    # True means partitioning users of the dataset into train-test groups.
+  # False means partitioning each users' samples into train-test groups.
+  user: False
+  # The fraction of data for training; the rest are for testing.
+  train_test_split: 0.9
+
+  # The number of classes in each client. Only applicable when the split_type is 'class'.  
+  class_per_client: 1
+  # The targeted number of clients to construct.used in non-leaf dataset, number of clients split into. for leaf dataset, only used when split type class.
+  num_of_clients: 100
+  # The parameter for Dirichlet distribution simulation, applicable only when split_type is `dir` for CIFAR datasets.
+  alpha: 0.5
+
+    # The targeted distribution of quantities to simulate data quantity heterogeneity.
+    # The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+    # The `num_of_clients` should be divisible by `len(weights)`.
+  # None means clients are simulated with the same data quantity.
+  weights: NULL
+```
+
+Among them, `root` is applicable to all datasets. It specifies the directory to store datasets.
+
+EasyFL automatically downloads a dataset if it is not exist in the root directory.
+
+Next, we introduce the simulation and configuration for specific datasets.
+
+### FEMNIST and Shakespeare Datasets
+
+The following are basic stats of these two datasets.
+
+FEMNIST
+
+* Overview: Image Dataset
+* Details: 3500 users, 62 different classes (10 digits, 26 lowercase, 26 uppercase), images are 28 by 28 pixels (with
+  option to make them all 128 by 128 pixels)
+* Task: Image Classification
+
+Shakespeare
+
+* Overview: Text Dataset of Shakespeare Dialogues
+* Details: 1129 users (reduced to 660 with our choice of sequence length.)
+* Task: Next-Character Prediction
+
+The datasets are non-IID (independent and identically distributed) in nature.
+
+`split_type`: There are two options for these two datasets: `iid` and `niid`, representing IID data simulation and
+non-IID data simulation.
+
+Five hyper-parameters determine the simulated dataset: `min_size`, `data_amount`, `iid_fraction`, `tran_test_split`,
+and `user`.
+
+`user` is a boolean that determines whether to partition the dataset to train test group by user or samples.
+`user: True` means partitioning users of the dataset into train-test groups, i.e. some users are for training, some
+users are for testing.
+`user: False` means partitioning each users' samples into train-test groups, i.e. data in each client is partitioned
+into training set and testing set.
+
+Note: we normally use `test_mode: test_in_clients` for these two datasets.
+
+#### IID Simulation
+
+In IID simulation, data are randomly partitioned into multiple clients.
+
+The number of clients is determined by `data_amount` and `iid_fraction`.
+
+#### Non-IID Simulation
+
+Since FEMNIST and Shakespeare are non-IID in nature, each user of the dataset is regarded as a client.
+
+`data_amount` determine the number of clients participate in training.
+
+### CIFAR-10 and CIFAR-100 Datasets
+
+> The **CIFAR-10** dataset consists of 60000 32x32 colour images in 10 classes, with 6000 images per class. There are 50000 training images and 10000 test images.
+
+> The **CIFAR-100** dataset consists of 60000 32x32 colour images in 100 classes, with 600 images per class. There are 50000 training images and 10000 test images.
+
+`split_type`: There are three options for CIFAR datasets: `iid`, `dir`, and `class`.
+
+Three hyper-parameters determine the simulated dataset: `num_of_clients`, `class_per_client`, and `alpha`.
+
+#### IID Simulation
+
+In IID simulation, the training images of the datasets are randomly partitioned into `num_of_clients` clients.
+
+#### Non-IID Simulation
+
+We can simulate non-IID CIFAR datasets by Dirichlet process (`dir`) or by label class (`class`).
+
+`alpha` controls the level of heterogeneity for `dir` simulation.
+
+`class_per_client` determines the number of classes in each client.
+
+## Customize Datasets
+
+EasyFL also supports integrating with customized dataset to simulate federated learning.
+
+You can use the following classes to integrate customized dataset: [FederatedImageDataset](../api.html#easyfl.datasets.FederatedImageDataset), [FederatedTensorDataset](../api.html#easyfl.datasets.FederatedTensorDataset), and [FederatedTorchDataset](../api.html#easyfl.datasets.FederatedTorchDataset).
+
+The following is an example that integrates [nine person re-identification datasets](https://arxiv.org/abs/2008.11560), where each client contains one dataset.
+
+```python
+import easyfl
+import os
+from torchvision import transforms
+from easyfl.datasets import FederatedImageDataset
+
+TRANSFORM_TRAIN_LIST = transforms.Compose([
+    transforms.Resize((256, 128), interpolation=3),
+    transforms.Pad(10),
+    transforms.RandomCrop((256, 128)),
+    transforms.RandomHorizontalFlip(),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+TRANSFORM_VAL_LIST = transforms.Compose([
+    transforms.Resize(size=(256, 128), interpolation=3),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+DATASETS = ["MSMT17", "Duke", "Market", "cuhk03", "prid", "cuhk01", "viper", "3dpes", "ilids"]
+
+# Prepare customized training data
+def prepare_train_data(data_dir):
+    client_ids = []
+    roots = []
+    for db in DATASETS:
+        client_ids.append(db)
+        data_path = os.path.join(data_dir, db, "pytorch")
+        roots.append(os.path.join(data_path, "train_all"))
+    data = FederatedImageDataset(root=roots,
+                                 simulated=True,
+                                 do_simulate=False,
+                                 transform=TRANSFORM_TRAIN_LIST,
+                                 client_ids=client_ids)
+    return data
+
+
+# Prepare customized testing data
+def prepare_test_data(data_dir):
+    roots = []
+    client_ids = []
+    for db in DATASETS:
+        test_gallery = os.path.join(data_dir, db, 'pytorch', 'gallery')
+        test_query = os.path.join(data_dir, db, 'pytorch', 'query')
+        roots.extend([test_gallery, test_query])
+        client_ids.extend([f"{db}_gallery", f"{db}_query"])
+    data = FederatedImageDataset(root=roots,
+                                 simulated=True,
+                                 do_simulate=False,
+                                 transform=TRANSFORM_VAL_LIST,
+                                 client_ids=client_ids)
+    return data
+
+
+if __name__ == '__main__':
+    config = {...}
+    data_dir = "datasets/"
+    train_data, test_data = prepare_train_data(data_dir), prepare_test_data(data_dir)
+    easyfl.register_dataset(train_data, test_data)
+    easyfl.init(config)
+    easyfl.run()
+```
+
+The folder structure of these datasets are as followed:
+```
+|-- MSMT17
+|   |-- pytorch
+|   |  	  |-- gallery
+|   |     |-- query
+|   |     |-- train
+|   |     |-- train_all
+|   |     `-- val
+|-- cuhk01
+|   |-- pytorch
+|   |  	  |-- gallery
+|   |     |-- query
+|   |     |-- train
+|   |     |-- train_all
+| ...
+```
+
+Please [email us](mailto:weiming001@e.ntu.edu.sg) if you want to access these datasets with:
+1. A short self-introduction.
+2. The purposes of using these datasets.
+
+*⚠️ Further distribution of the datasets are prohibited.*
+
+### Create Your Own Federated Dataset
+
+In case that the provided federated dataset class is not enough, 
+you can implement your own federated dataset by inherit and implement [FederatedDataset](../api.html#easyfl.datasets.FederatedDataset).
+
+You can refer to [FederatedImageDataset](../api.html#easyfl.datasets.FederatedImageDataset), [FederatedTensorDataset](../api.html#easyfl.datasets.FederatedTensorDataset), and [FederatedTorchDataset](../api.html#easyfl.datasets.FederatedTorchDataset) on how to implement.  
diff --git a/docs/en/tutorials/distributed_training.md b/docs/en/tutorials/distributed_training.md
new file mode 100644
index 0000000..38ed847
--- /dev/null
+++ b/docs/en/tutorials/distributed_training.md
@@ -0,0 +1,42 @@
+# Tutorial 6: Distributed Training
+
+EasyFL enables federated learning (FL) training over multiple GPUs. We define the following variables to further illustrate the idea:
+* K: the number of clients who participated in training each round
+* N: the number of available GPUs
+
+When _K == N_, each selected client is allocated to a GPU to train.
+
+When _K > N_, multiple clients are allocated to a GPU, then they execute training sequentially in the GPU.
+
+When _K < N_, you can adjust to use fewer GPUs in training.
+
+We make it easy to use distributed training. You just need to modify the configs, without changing the core implementations.
+In particular, you need to set the number of GPUs in `gpu` and specific distributed settings in the `distributed` configs.
+
+The following is an example of distributed training on a GPU cluster managed by _slurm_.
+
+```python
+import easyfl
+from easyfl.distributed import slurm
+
+# Get the distributed settings.
+rank, local_rank, world_size, host_addr = slurm.setup()
+# Set the distributed training settings.
+config = {
+    "gpu": world_size,
+    "distributed": {
+        "rank": rank, 
+        "local_rank": local_rank, 
+        "world_size": world_size, 
+        "init_method": host_addr
+    },
+}
+# Initialize EasyFL.
+easyfl.init(config)
+# Execute training with distributed training.
+easyfl.run()
+```
+
+We will further provide scripts to set up distributed training using `multiprocess`. 
+Pull requests are also welcomed.
+
diff --git a/docs/en/tutorials/high-level_apis.md b/docs/en/tutorials/high-level_apis.md
new file mode 100644
index 0000000..8773826
--- /dev/null
+++ b/docs/en/tutorials/high-level_apis.md
@@ -0,0 +1,126 @@
+# Tutorial 1: High-level APIs
+
+EasyFL provides three types of high-level APIs: **initialization**, **registration**, and **execution**.
+The initialization API initializes EasyFL with configurations. 
+Registration APIs register customized components into the platform. 
+Execution APIs start federated learning process. 
+These APIs are listed in the table below.
+
+| API Name      | Description | Category 
+| :---        |    :----:   | :--- |
+| init(config) | Initialize EasyFL with configurations | Initialization | 
+| register_dataset(train, test, val) | Register a customized dataset | Registration | 
+| register_model(model) | Register a customized model | Registration | 
+| register_server(server) | Register a customized server | Registration |
+| register_client(client) | Register a customized client | Registration |
+| run() | Start federated learning for standalone and distributed training | Execution |
+| start_server() | Start server service for remote training | Execution |
+| start_client() | Start client service for remote training | Execution |
+
+
+`init(config):` Initialize EasyFL with provided configurations (`config`) or default configurations if not specified.  
+These configurations determine the training hardware and hyperparameters.
+
+`register_<module>:` Register customized modules to the system. 
+EasyFL supports the registration of customized datasets, models, server, and client, replacing the default modules in FL training. In the experimental phase, users can register newly developed algorithms to understand their performance.
+
+`run, start_<server/client>:` The APIs are commands to trigger execution. 
+`run()` starts FL using standalone training or distributed training. 
+ `start_server` and `start_client` start the server and client services to communicate remotely with `args` variables for configurations specific to remote training, such as the endpoint addresses.
+
+Next, we introduce how to use these APIs with examples.
+
+## Standalone Training Example
+
+_**Standalone training**_ means that federated learning (FL) training is run on a single hardware device, such as your personal computer and a single GPU.
+_**Distributed training**_ means conducting FL with multiple GPUs to speed up training.
+Running distributed training is similar to standalone training, except that we need to configure the number of GPUs and the distributed settings. 
+We explain more on distributed training in [another note](distributed_training.md) and focus on standalone training example here.  
+
+To run any federated learning process, we need to first call the initialization API and then use the execution API. Registration is optional.
+
+The simplest way is to run with the default setup. 
+```python
+import easyfl
+# Initialize federated learning with default configurations.
+easyfl.init()
+# Execute federated learning training.
+easyfl.run()
+```
+
+You can run it with specified configurations. 
+```python
+import easyfl
+
+# Customized configuration.
+config = {
+    "data": {"dataset": "cifar10", "num_of_clients": 1000},
+    "server": {"rounds": 5, "clients_per_round": 2, "test_all": False},
+    "client": {"local_epoch": 5},
+    "model": "resnet18",
+    "test_mode": "test_in_server",
+}
+# Initialize federated learning with default configurations.
+easyfl.init(config)
+# Execute federated learning training.
+easyfl.run()
+```
+
+You can also run federated learning with customized datasets, model, server and client implementations.
+
+Note: `registration` must be done before `initialization`.
+
+```python
+import easyfl
+from easyfl.client import BaseClient
+
+# Inherit BaseClient to implement customized client operations.
+class CustomizedClient(BaseClient):
+    def __init__(self, cid, conf, train_data, test_data, device, **kwargs):
+        super(CustomizedClient, self).__init__(cid, conf, train_data, test_data, device, **kwargs)
+        pass  # more initialization of attributes.
+
+    def train(self, conf, device):
+        pass # Implement customized training method, overwriting the default one.
+
+# Register customized client.
+easyfl.register_client(CustomizedClient)
+# Initialize federated learning with default configurations.
+easyfl.init()
+# Execute federated learning training.
+easyfl.run()
+```
+
+## Remote Training Example
+
+_**Remote training**_ is the scenario where the server and the clients are running on different devices.
+We explain more on remote training in [another note](remote_training.md). 
+Here we provide examples on how to start client and server services using the APIs.
+
+Start remote server.
+```python
+import easyfl
+# Configurations for the remote server.
+conf = {"is_remote": True, "local_port": 22999}
+# Initialize only the configuration.
+easyfl.init(conf, init_all=False)
+# Start remote server service.
+# The remote server waits to be connected with the remote client.
+easyfl.start_server()
+```
+
+Start remote client.
+```python
+import easyfl
+# Configurations for the remote client.
+conf = {"is_remote": True, "local_port": 23000}
+# Initialize only the configuration.
+easyfl.init(conf, init_all=False)
+# Start remote client service.
+# The remote client waits to be connected with the remote server.
+easyfl.start_client()
+```
+
+We expose two additional APIs that wrap starting remote services with customized components.
+They are `start_remote_server` and `start_remote_client`. 
+You can explore more in the API documentation.
diff --git a/docs/en/tutorials/index.rst b/docs/en/tutorials/index.rst
new file mode 100644
index 0000000..e5c1887
--- /dev/null
+++ b/docs/en/tutorials/index.rst
@@ -0,0 +1,11 @@
+.. toctree::
+   :maxdepth: 2
+   :caption: Tutorial
+
+   high-level_apis.md
+   config.md
+   dataset.md
+   model.md
+   customize_server_and_client.md
+   distributed_training.md
+   remote_training.md
diff --git a/docs/en/tutorials/model.md b/docs/en/tutorials/model.md
new file mode 100644
index 0000000..58915b9
--- /dev/null
+++ b/docs/en/tutorials/model.md
@@ -0,0 +1,92 @@
+# Tutorial 4: Models
+
+EasyFL supports numerous models and allows you to customize the model.
+
+## Out-of-the-box Models
+
+To use these models, you can set configurations `model: <model_name>`. 
+
+We currently provide `lenet`, `resnet`, `resnet18`, `resnet50`,`vgg9`, and `rnn`.
+
+## Customized Models
+
+EasyFL allows training with a wide range of models by providing the flexibility to customize models. 
+You can customize and register models in two ways: register as a class and register as an instance.
+Either way, the basic is to **inherit and implement the `easyfl.models.BaseModel`**. 
+
+### Register as a Class
+
+In the example below, we implement and conduct FL training with a `CustomizedModel`. 
+
+It is applicable when the model does not require extra arguments to initialize.
+
+```python
+from torch import nn
+import torch.nn.functional as F
+import easyfl
+from easyfl.models import BaseModel
+
+# Define a customized model class.
+class CustomizedModel(BaseModel):
+    def __init__(self):
+        super(CustomizedModel, self).__init__()
+        self.conv1 = nn.Conv2d(3, 32, 224, padding=(2, 2))
+        self.conv2 = nn.Conv2d(32, 64, 5, padding=(2, 2))
+        self.fc1 = nn.Linear(64, 128)
+        self.fc2 = nn.Linear(128, 42)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = x.view(-1, 64)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+
+        return x
+
+# Register the customized model class.
+easyfl.register_model(CustomizedModel)
+# Initialize EasyFL.
+easyfl.init()
+# Execute FL training.
+easyfl.run()
+```
+
+### Register as an Instance
+
+When the model requires arguments for initialization, we can implement and register a model instance. 
+
+```python
+from torch import nn
+import torch.nn.functional as F
+import easyfl
+from easyfl.models import BaseModel
+
+# Define a customized model class.
+class CustomizedModel(BaseModel):
+    def __init__(self, num_class):
+        super(CustomizedModel, self).__init__()
+        self.conv1 = nn.Conv2d(3, 32, 224, padding=(2, 2))
+        self.conv2 = nn.Conv2d(32, 64, 5, padding=(2, 2))
+        self.fc1 = nn.Linear(64, 128)
+        self.fc2 = nn.Linear(128, num_class)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = x.view(-1, 64)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+# Register the customized model instance.
+easyfl.register_model(CustomizedModel(num_class=10))
+# Initialize EasyFL.
+easyfl.init()
+# Execute FL training.
+easyfl.run()
+```
\ No newline at end of file
diff --git a/docs/en/tutorials/remote_training.md b/docs/en/tutorials/remote_training.md
new file mode 100644
index 0000000..88b00c6
--- /dev/null
+++ b/docs/en/tutorials/remote_training.md
@@ -0,0 +1,257 @@
+# Tutorial 7: Remote Training
+
+_**Remote training**_ is the scenario where the server and the clients are running on different devices. Standalone and
+distributed training are mainly for federated learning (FL) simulation experiments. Remote training brings FL from
+experimentation to production.
+
+## Remote Training Example
+
+In remote training, both server and clients are started as gRPC services. Here we provide examples on how to start
+server and client services.
+
+Start remote server.
+
+```python
+import easyfl
+
+# Configurations for the remote server.
+conf = {"is_remote": True, "local_port": 22999}
+# Initialize only the configuration.
+easyfl.init(conf, init_all=False)
+# Start remote server service.
+# The remote server waits to be connected with the remote client.
+easyfl.start_server()
+```
+
+Start remote client 1 with port 23000.
+
+```python
+import easyfl
+
+# Configurations for the remote client.
+conf = {
+    "is_remote": True,
+    "local_port": 23000,
+    "server_addr": "localhost:22999",
+    "index": 0,
+}
+# Initialize only the configuration.
+easyfl.init(conf, init_all=False)
+# Start remote client service.
+# The remote client waits to be connected with the remote server.
+easyfl.start_client()
+```
+
+Start remote client 2 with port 23001.
+
+```python
+import easyfl
+
+# Configurations for the remote client.
+conf = {
+    "is_remote": True,
+    "local_port": 23001,
+    "server_addr": "localhost:22999",
+    "index": 1,
+}
+# Initialize only the configuration.
+easyfl.init(conf, init_all=False)
+# Start remote client service.
+# The remote client waits to be connected with the remote server.
+easyfl.start_client()
+```
+
+The client service connects to the remote service via specified `server_address`. 
+The client service users `index` to decide the data (user) of the configured dataset.
+
+To trigger remote training, we can send gRPC requests to trigger the training operation.
+
+```python
+import easyfl
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.pb import server_service_pb2 as server_pb
+from easyfl.protocol import codec
+from easyfl.communication import grpc_wrapper
+from easyfl.registry.vclient import VirtualClient
+
+server_addr = "localhost:22999"
+config = {
+    "data": {"dataset": "femnist"},
+    "model": "lenet",
+    "test_mode": "test_in_client"
+}
+# Initialize configurations.
+easyfl.init(config, init_all=False)
+# Initialize the model, using the configured 'lenet'
+model = easyfl.init_model()
+
+# Construct gRPC request 
+stub = grpc_wrapper.init_stub(grpc_wrapper.TYPE_SERVER, server_addr)
+request = server_pb.RunRequest(model=codec.marshal(model))
+# The request contains clients' addresses for the server to communicate with the clients.
+clients = [VirtualClient("1", "localhost:23000", 0), VirtualClient("2", "localhost:23001", 1)]
+for c in clients:
+    request.clients.append(server_pb.Client(client_id=c.id, index=c.index, address=c.address))
+# Send request to trigger training.
+response = stub.Run(request)
+result = "Success" if response.status.code == common_pb.SC_OK else response
+print(result)
+```
+
+Similarly, we can also stop remote training by sending gRPC requests to the server.
+
+```python
+from easyfl.communication import grpc_wrapper
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.pb import server_service_pb2 as server_pb
+
+server_addr = "localhost:22999"
+stub = grpc_wrapper.init_stub(grpc_wrapper.TYPE_SERVER, server_addr)
+# Send request to stop training.
+response = stub.Stop(server_pb.StopRequest())
+result = "Success" if response.status.code == common_pb.SC_OK else response
+print(result)
+```
+
+## Remote Training on Docker and Kubernetes
+
+EasyFL supports deployment of FL training using Docker and Kubernetes.
+
+Since we cannot easily obtain the server and client addresses in Docker or Kubernetes, especially when scaling up the number of clients,
+EasyFL provides a service discovery mechanism, as shown in the image below.
+![service_discovery](../_static/image/registry.png)
+
+It contains registors to dynamically register the clients and the registry to store the client addresses for the server to query. 
+The registor gets the addresses of clients and registers them to the registry. 
+Since the clients are unaware of the container environment they are running, 
+they must rely on a third-party service (the registor) to fetch their container addresses to complete registration. 
+The registry stores the registered client addresses for the server to query. 
+EasyFL supports two service discovery methods targeting different deployment scenarios: using Docker and using Kubernetes
+
+The following are the deployment manual and the steps to conduct training in Kubernetes.
+
+⚠️ Note: these commands were tested before refactoring. They may not work as expected now. **Need further testing**. 
+
+### Deployment using Docker
+
+Important: Adjust the `Memeory` constrain of docker to be > 11 GB (To be optimized)
+
+1. Build docker images and start services with either docker compose or individual docker containers
+2. Start training with a grpc message
+
+#### Build images
+
+```
+make base_image
+make image
+```
+
+Or
+
+```
+docker build -t easyfl:base -f docker/base.Dockerfile .
+docker build -t easyfl-client -f docker/client.Dockerfile .
+docker build -t easyfl-server -f docker/server.Dockerfile .
+docker build -t easyfl-run -f docker/run.Dockerfile .
+```
+
+#### Start with Docker Compose
+
+Use docker compose to start all services.
+```
+docker-compose up --scale client=2 && docker-compose rm -fsv
+```
+
+Mac users with Docker Desktop > 2.0 may have port conflict occurs because `bind: address already in use`.
+The workaround is to run with 
+```
+docker-compose up && docker-compose rm -fsv
+``` 
+and start another terminal to scale with 
+```
+docker-compose up --scale client=2 && docker-compose rm -fsv
+```
+
+#### Etcd Setup
+
+```
+export NODE1=localhost
+export DATA_DIR="etcd-data"
+REGISTRY=quay.io/coreos/etcd
+
+docker run --rm \
+  -p 23790:2379 \
+  -p 23800:2380 \
+  --volume=${DATA_DIR}:/etcd-data \
+  --name etcd ${REGISTRY}:v3.4.0 \
+  /usr/local/bin/etcd \
+  --data-dir=/etcd-data --name node1 \
+  --initial-advertise-peer-urls http://${NODE1}:2380 --listen-peer-urls http://0.0.0.0:2380 \
+  --advertise-client-urls http://${NODE1}:2379 --listen-client-urls http://0.0.0.0:2379 \
+  --initial-cluster node1=http://${NODE1}:2380
+```
+
+#### Docker Register
+
+```
+docker run --name docker-register --rm -d -e HOST_IP=<172.18.0.1> -e ETCD_HOST=<172.17.0.1>:2379 -v /var/run/docker.sock:/var/run/docker.sock -t wingalong/docker-register
+```
+* HOST_IP: the ip address of network client runs on: gateway in `docker inspect easyfl-client` 
+* ETCD_HOST: the ip address of etcd: gateway in `docker inspect etcd`
+
+#### Start containers
+
+```shell
+# 1. Start clients
+docker run --rm -p 23400:23400 --name client0 --network host -v <dataset_path>/femnist/data:/app/<dataset_path>/femnist/data easyfl-client --index=0 --is-remote=True --local-port=23400 --server-addr="localhost:23501"
+docker run --rm -p 23401:23401 --name client1 --network host -v <dataset_path>/femnist/data:/app/<dataset_path>/femnist/data easyfl-client --index=1 --is-remote=True --local-port=23401 --server-addr="localhost:23501"
+
+# 2. Start server
+docker run --rm -p 23501:23501 --name easyfl-server --network host  easyfl-server --local-port=23501 --is-remote=True
+```
+
+Note: you need to replace the `dataset_path` with your actual dataset directory.
+
+#### Start Training Remotely 
+```
+docker run --rm --name easyfl-run --network host easyfl-run --server-addr 127.0.0.1:23501 --etcd-addr:127.0.0.1:23790
+```
+It sends a gRPC message to server to start training.
+
+### Deployment using Kubernetes
+
+
+```shell
+# 1. Deploy tracker
+kubectl apply -f kubernetes/tracker.yml
+
+# 2. Deploy server
+kubectl apply -f kubernetes/server.yml
+
+# 3. Deploy client
+kubectl apply -f kubernetes/client.yml
+
+# 4. Scale client
+kubectl scale -n easyfl deployment easyfl-client --replicas=6
+
+# 5. Check pods
+kubectl get pods -n easyfl -o wide
+
+# 6. Run
+
+python examples/remote_run.py --server-addr localhost:32501 --source kubernetes
+
+# 7. Check logs
+kubectl logs -f -n easyfl easyfl-server
+
+# 8. Get results
+python examples/test_services.py --task-id task_ijhwqg
+
+# 9. Save log
+kubectl logs -n easyfl easyfl-server > server-log.log
+
+# 10. Stop client/server/tracker
+kubectl delete -f kubernetes/client.yml
+kubectl delete -f kubernetes/server.yml
+kubectl delete -f kubernetes/tracker.yml
+```
diff --git a/easyfl/__init__.py b/easyfl/__init__.py
new file mode 100644
index 0000000..3777da2
--- /dev/null
+++ b/easyfl/__init__.py
@@ -0,0 +1,22 @@
+from easyfl.coordinator import (
+    init,
+    init_dataset,
+    init_model,
+    start_server,
+    start_client,
+    run,
+    register_dataset,
+    register_model,
+    register_server,
+    register_client,
+    load_config,
+)
+
+from easyfl.service import (
+    start_remote_server,
+    start_remote_client,
+)
+
+__all__ = ["init", "init_dataset", "init_model", "start_server", "start_client", "run",
+           "register_dataset", "register_model", "register_server", "register_client",
+           "load_config", "start_remote_server", "start_remote_client"]
diff --git a/easyfl/client/__init__.py b/easyfl/client/__init__.py
new file mode 100644
index 0000000..a7e0fa9
--- /dev/null
+++ b/easyfl/client/__init__.py
@@ -0,0 +1,5 @@
+from easyfl.client.base import BaseClient
+from easyfl.client.service import ClientService
+
+__all__ = ['BaseClient', 'ClientService']
+
diff --git a/easyfl/client/base.py b/easyfl/client/base.py
new file mode 100644
index 0000000..3c66f76
--- /dev/null
+++ b/easyfl/client/base.py
@@ -0,0 +1,471 @@
+import argparse
+import copy
+import logging
+import time
+
+import torch
+
+from easyfl.client.service import ClientService
+from easyfl.communication import grpc_wrapper
+from easyfl.distributed.distributed import CPU
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.pb import server_service_pb2 as server_pb
+from easyfl.protocol import codec
+from easyfl.tracking import metric
+from easyfl.tracking.client import init_tracking
+from easyfl.tracking.evaluation import model_size
+
+logger = logging.getLogger(__name__)
+
+
+def create_argument_parser():
+    """Create argument parser with arguments/configurations for starting remote client service.
+
+    Returns:
+        argparse.ArgumentParser: Parser with client service arguments.
+    """
+    parser = argparse.ArgumentParser(description='Federated Client')
+    parser.add_argument('--local-port',
+                        type=int,
+                        default=23000,
+                        help='Listen port of the client')
+    parser.add_argument('--server-addr',
+                        type=str,
+                        default="localhost:22999",
+                        help='Address of server in [IP]:[PORT] format')
+    parser.add_argument('--tracker-addr',
+                        type=str,
+                        default="localhost:12666",
+                        help='Address of tracking service in [IP]:[PORT] format')
+    parser.add_argument('--is-remote',
+                        type=bool,
+                        default=False,
+                        help='Whether start as a remote client.')
+    return parser
+
+
+class BaseClient(object):
+    """Default implementation of federated learning client.
+
+    Args:
+        cid (str): Client id.
+        conf (omegaconf.dictconfig.DictConfig): Client configurations.
+        train_data (:obj:`FederatedDataset`): Training dataset.
+        test_data (:obj:`FederatedDataset`): Test dataset.
+        device (str): Hardware device for training, cpu or cuda devices.
+        sleep_time (float): Duration of on hold after training to simulate stragglers.
+        is_remote (bool): Whether start remote training.
+        local_port (int): Port of remote client service.
+        server_addr (str): Remote server service grpc address.
+        tracker_addr (str): Remote tracking service grpc address.
+
+
+    Override the class and functions to implement customized client.
+
+    Example:
+        >>> from easyfl.client import BaseClient
+        >>> class CustomizedClient(BaseClient):
+        >>>     def __init__(self, cid, conf, train_data, test_data, device, **kwargs):
+        >>>         super(CustomizedClient, self).__init__(cid, conf, train_data, test_data, device, **kwargs)
+        >>>         pass  # more initialization of attributes.
+        >>>
+        >>>     def train(self, conf, device=CPU):
+        >>>         # Implement customized client training method, which overwrites the default training method.
+        >>>         pass
+    """
+    def __init__(self,
+                 cid,
+                 conf,
+                 train_data,
+                 test_data,
+                 device,
+                 sleep_time=0,
+                 is_remote=False,
+                 local_port=23000,
+                 server_addr="localhost:22999",
+                 tracker_addr="localhost:12666"):
+        self.cid = cid
+        self.conf = conf
+        self.train_data = train_data
+        self.train_loader = None
+        self.test_data = test_data
+        self.test_loader = None
+        self.device = device
+
+        self.round_time = 0
+        self.train_time = 0
+        self.test_time = 0
+
+        self.train_accuracy = []
+        self.train_loss = []
+        self.test_accuracy = 0
+        self.test_loss = 0
+
+        self.profiled = False
+        self._sleep_time = sleep_time
+
+        self.compressed_model = None
+        self.model = None
+        self._upload_holder = server_pb.UploadContent()
+
+        self.is_remote = is_remote
+        self.local_port = local_port
+        self._server_addr = server_addr
+        self._tracker_addr = tracker_addr
+        self._server_stub = None
+        self._tracker = None
+        self._is_train = True
+
+        if conf.track:
+            self._tracker = init_tracking(init_store=False)
+
+    def run_train(self, model, conf):
+        """Conduct training on clients.
+
+        Args:
+            model (nn.Module): Model to train.
+            conf (omegaconf.dictconfig.DictConfig): Client configurations.
+        Returns:
+            :obj:`UploadRequest`: Training contents. Unify the interface for both local and remote operations.
+        """
+        self.conf = conf
+        if conf.track:
+            self._tracker.set_client_context(conf.task_id, conf.round_id, self.cid)
+
+        self._is_train = True
+
+        self.download(model)
+        self.track(metric.TRAIN_DOWNLOAD_SIZE, model_size(model))
+
+        self.decompression()
+
+        self.pre_train()
+        self.train(conf, self.device)
+        self.post_train()
+
+        self.track(metric.TRAIN_ACCURACY, self.train_accuracy)
+        self.track(metric.TRAIN_LOSS, self.train_loss)
+        self.track(metric.TRAIN_TIME, self.train_time)
+
+        if conf.local_test:
+            self.test_local()
+
+        self.compression()
+
+        self.track(metric.TRAIN_UPLOAD_SIZE, model_size(self.compressed_model))
+
+        self.encryption()
+
+        return self.upload()
+
+    def run_test(self, model, conf):
+        """Conduct testing on clients.
+
+        Args:
+            model (nn.Module): Model to test.
+            conf (omegaconf.dictconfig.DictConfig): Client configurations.
+        Returns:
+            :obj:`UploadRequest`: Testing contents. Unify the interface for both local and remote operations.
+        """
+        self.conf = conf
+        if conf.track:
+            reset = not self._is_train
+            self._tracker.set_client_context(conf.task_id, conf.round_id, self.cid, reset_client=reset)
+
+        self._is_train = False
+
+        self.download(model)
+        self.track(metric.TEST_DOWNLOAD_SIZE, model_size(model))
+
+        self.decompression()
+
+        self.pre_test()
+        self.test(conf, self.device)
+        self.post_test()
+
+        self.track(metric.TEST_ACCURACY, float(self.test_accuracy))
+        self.track(metric.TEST_LOSS, float(self.test_loss))
+        self.track(metric.TEST_TIME, self.test_time)
+
+        return self.upload()
+
+    def download(self, model):
+        """Download model from the server.
+
+        Args:
+            model (nn.Module): Global model distributed from the server.
+        """
+        if self.compressed_model:
+            self.compressed_model.load_state_dict(model.state_dict())
+        else:
+            self.compressed_model = copy.deepcopy(model)
+
+    def decompression(self):
+        """Decompressed model. It can be further implemented when the model is compressed in the server."""
+        self.model = self.compressed_model
+
+    def pre_train(self):
+        """Preprocessing before training."""
+        pass
+
+    def train(self, conf, device=CPU):
+        """Execute client training.
+
+        Args:
+            conf (omegaconf.dictconfig.DictConfig): Client configurations.
+            device (str): Hardware device for training, cpu or cuda devices.
+        """
+        start_time = time.time()
+        loss_fn, optimizer = self.pretrain_setup(conf, device)
+        self.train_loss = []
+        for i in range(conf.local_epoch):
+            batch_loss = []
+            for batched_x, batched_y in self.train_loader:
+                x, y = batched_x.to(device), batched_y.to(device)
+                optimizer.zero_grad()
+                out = self.model(x)
+                loss = loss_fn(out, y)
+                loss.backward()
+                optimizer.step()
+                batch_loss.append(loss.item())
+            current_epoch_loss = sum(batch_loss) / len(batch_loss)
+            self.train_loss.append(float(current_epoch_loss))
+            logger.debug("Client {}, local epoch: {}, loss: {}".format(self.cid, i, current_epoch_loss))
+        self.train_time = time.time() - start_time
+        logger.debug("Client {}, Train Time: {}".format(self.cid, self.train_time))
+
+    def post_train(self):
+        """Postprocessing after training."""
+        pass
+
+    def pretrain_setup(self, conf, device):
+        """Setup loss function and optimizer before training."""
+        self.simulate_straggler()
+        self.model.train()
+        self.model.to(device)
+        loss_fn = self.load_loss_fn(conf)
+        optimizer = self.load_optimizer(conf)
+        if self.train_loader is None:
+            self.train_loader = self.load_loader(conf)
+        return loss_fn, optimizer
+
+    def load_loss_fn(self, conf):
+        return torch.nn.CrossEntropyLoss()
+
+    def load_optimizer(self, conf):
+        """Load training optimizer. Implemented Adam and SGD."""
+        if conf.optimizer.type == "Adam":
+            optimizer = torch.optim.Adam(self.model.parameters(), lr=conf.optimizer.lr)
+        else:
+            # default using optimizer SGD
+            optimizer = torch.optim.SGD(self.model.parameters(),
+                                        lr=conf.optimizer.lr,
+                                        momentum=conf.optimizer.momentum,
+                                        weight_decay=conf.optimizer.weight_decay)
+        return optimizer
+
+    def load_loader(self, conf):
+        """Load the training data loader.
+
+        Args:
+            conf (omegaconf.dictconfig.DictConfig): Client configurations.
+        Returns:
+            torch.utils.data.DataLoader: Data loader.
+        """
+        return self.train_data.loader(conf.batch_size, self.cid, shuffle=True, seed=conf.seed)
+
+    def test_local(self):
+        """Test client local model after training."""
+        pass
+
+    def pre_test(self):
+        """Preprocessing before testing."""
+        pass
+
+    def test(self, conf, device=CPU):
+        """Execute client testing.
+
+        Args:
+            conf (omegaconf.dictconfig.DictConfig): Client configurations.
+            device (str): Hardware device for training, cpu or cuda devices.
+        """
+        begin_test_time = time.time()
+        self.model.eval()
+        self.model.to(device)
+        loss_fn = self.load_loss_fn(conf)
+        if self.test_loader is None:
+            self.test_loader = self.test_data.loader(conf.test_batch_size, self.cid, shuffle=False, seed=conf.seed)
+        # TODO: make evaluation metrics a separate package and apply it here.
+        self.test_loss = 0
+        correct = 0
+        with torch.no_grad():
+            for batched_x, batched_y in self.test_loader:
+                x = batched_x.to(device)
+                y = batched_y.to(device)
+                log_probs = self.model(x)
+                loss = loss_fn(log_probs, y)
+                _, y_pred = torch.max(log_probs, -1)
+                correct += y_pred.eq(y.data.view_as(y_pred)).long().cpu().sum()
+                self.test_loss += loss.item()
+            test_size = self.test_data.size(self.cid)
+            self.test_loss /= test_size
+            self.test_accuracy = 100.0 * float(correct) / test_size
+
+        logger.debug('Client {}, testing -- Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)'.format(
+            self.cid, self.test_loss, correct, test_size, self.test_accuracy))
+
+        self.test_time = time.time() - begin_test_time
+        self.model = self.model.cpu()
+
+    def post_test(self):
+        """Postprocessing after testing."""
+        pass
+
+    def encryption(self):
+        """Encrypt the client local model."""
+        # TODO: encryption of model, remember to track encrypted model instead of compressed one after implementation.
+        pass
+
+    def compression(self):
+        """Compress the client local model after training and before uploading to the server."""
+        self.compressed_model = self.model
+
+    def upload(self):
+        """Upload the messages from client to the server.
+
+        Returns:
+            :obj:`UploadRequest`: The upload request defined in protobuf to unify local and remote operations.
+                Only applicable for local training as remote training upload through a gRPC request.
+        """
+        request = self.construct_upload_request()
+        if not self.is_remote:
+            self.post_upload()
+            return request
+
+        self.upload_remotely(request)
+        self.post_upload()
+
+    def post_upload(self):
+        """Postprocessing after uploading training/testing results."""
+        pass
+
+    def construct_upload_request(self):
+        """Construct client upload request for training updates and testing results.
+
+        Returns:
+            :obj:`UploadRequest`: The upload request defined in protobuf to unify local and remote operations.
+        """
+        data = codec.marshal(server_pb.Performance(accuracy=self.test_accuracy, loss=self.test_loss))
+        typ = common_pb.DATA_TYPE_PERFORMANCE
+        try:
+            if self._is_train:
+                data = codec.marshal(copy.deepcopy(self.compressed_model))
+                typ = common_pb.DATA_TYPE_PARAMS
+                data_size = self.train_data.size(self.cid)
+            else:
+                data_size = 1 if not self.test_data else self.test_data.size(self.cid)
+        except KeyError:
+            # When the datasize cannot be get from dataset, default to use equal aggregate
+            data_size = 1
+
+        m = self._tracker.get_client_metric().to_proto() if self._tracker else common_pb.ClientMetric()
+        return server_pb.UploadRequest(
+            task_id=self.conf.task_id,
+            round_id=self.conf.round_id,
+            client_id=self.cid,
+            content=server_pb.UploadContent(
+                data=data,
+                type=typ,
+                data_size=data_size,
+                metric=m,
+            ),
+        )
+
+    def upload_remotely(self, request):
+        """Send upload request to remote server via gRPC.
+
+        Args:
+            request (:obj:`UploadRequest`): Upload request.
+        """
+        start_time = time.time()
+
+        self.connect_to_server()
+        resp = self._server_stub.Upload(request)
+
+        upload_time = time.time() - start_time
+        m = metric.TRAIN_UPLOAD_TIME if self._is_train else metric.TEST_UPLOAD_TIME
+        self.track(m, upload_time)
+
+        logger.info("client upload time: {}s".format(upload_time))
+        if resp.status.code == common_pb.SC_OK:
+            logger.info("Uploaded remotely to the server successfully\n")
+        else:
+            logger.error("Failed to upload, code: {}, message: {}\n".format(resp.status.code, resp.status.message))
+
+    # Functions for remote services.
+
+    def start_service(self):
+        """Start client service."""
+        if self.is_remote:
+            grpc_wrapper.start_service(grpc_wrapper.TYPE_CLIENT, ClientService(self), self.local_port)
+
+    def connect_to_server(self):
+        """Establish connection between the client and the server."""
+        if self.is_remote and self._server_stub is None:
+            self._server_stub = grpc_wrapper.init_stub(grpc_wrapper.TYPE_SERVER, self._server_addr)
+            logger.info("Successfully connected to gRPC server {}".format(self._server_addr))
+
+    def operate(self, model, conf, index, is_train=True):
+        """A wrapper over operations (training/testing) on clients.
+
+        Args:
+            model (nn.Module): Model for operations.
+            conf (omegaconf.dictconfig.DictConfig): Client configurations.
+            index (int): Client index in the client list, for retrieving data. TODO: improvement.
+            is_train (bool): The flag to indicate whether the operation is training, otherwise testing.
+        """
+        try:
+            # Load the data index depending on server request
+            self.cid = self.train_data.users[index]
+        except IndexError:
+            logger.error("Data index exceed the available data, abort training")
+            return
+
+        if self.conf.track and self._tracker is None:
+            self._tracker = init_tracking(init_store=False)
+
+        if is_train:
+            logger.info("Train on data index {}, client: {}".format(index, self.cid))
+            self.run_train(model, conf)
+        else:
+            logger.info("Test on data index {}, client: {}".format(index, self.cid))
+            self.run_test(model, conf)
+
+    # Functions for tracking.
+
+    def track(self, metric_name, value):
+        """Track a metric.
+
+        Args:
+            metric_name (str): The name of the metric.
+            value (str|int|float|bool|dict|list): The value of the metric.
+        """
+        if not self.conf.track or self._tracker is None:
+            logger.debug("Tracker not available, Tracking not supported")
+            return
+        self._tracker.track_client(metric_name, value)
+
+    def save_metrics(self):
+        """Save client metrics to database."""
+        # TODO: not tested
+        if self._tracker is None:
+            logger.debug("Tracker not available, no saving")
+            return
+        self._tracker.save_client()
+
+    # Functions for simulation.
+
+    def simulate_straggler(self):
+        """Simulate straggler effect of system heterogeneity."""
+        if self._sleep_time > 0:
+            time.sleep(self._sleep_time)
diff --git a/easyfl/client/service.py b/easyfl/client/service.py
new file mode 100644
index 0000000..85514fd
--- /dev/null
+++ b/easyfl/client/service.py
@@ -0,0 +1,30 @@
+import logging
+import threading
+
+from easyfl.pb import client_service_pb2_grpc as client_grpc, client_service_pb2 as client_pb, common_pb2 as common_pb
+from easyfl.protocol import codec
+
+logger = logging.getLogger(__name__)
+
+
+class ClientService(client_grpc.ClientServiceServicer):
+    """"Remote gRPC client service.
+
+    Args:
+        client (:obj:`BaseClient`): Federated learning client instance.
+    """
+    def __init__(self, client):
+        self._base = client
+
+    def Operate(self, request, context):
+        """Perform training/testing operations."""
+        # TODO: add request validation.
+        model = codec.unmarshal(request.model)
+        is_train = request.type == client_pb.OP_TYPE_TRAIN
+        # Threading is necessary to respond to server quickly
+        t = threading.Thread(target=self._base.operate, args=[model, request.config, request.data_index, is_train])
+        t.start()
+        response = client_pb.OperateResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        return response
diff --git a/easyfl/communication/__init__.py b/easyfl/communication/__init__.py
new file mode 100644
index 0000000..a8b9389
--- /dev/null
+++ b/easyfl/communication/__init__.py
@@ -0,0 +1,3 @@
+from easyfl.communication.grpc_wrapper import *
+
+__all__ = ['init_stub', 'start_service']
diff --git a/easyfl/communication/grpc_wrapper.py b/easyfl/communication/grpc_wrapper.py
new file mode 100644
index 0000000..614cc84
--- /dev/null
+++ b/easyfl/communication/grpc_wrapper.py
@@ -0,0 +1,77 @@
+from concurrent import futures
+
+import grpc
+
+from easyfl.pb import client_service_pb2_grpc as client_grpc
+from easyfl.pb import server_service_pb2_grpc as server_grpc
+from easyfl.pb import tracking_service_pb2_grpc as tracking_grpc
+
+MAX_MESSAGE_LENGTH = 524288000  # 500MB
+
+TYPE_CLIENT = "client"
+TYPE_SERVER = "server"
+TYPE_TRACKING = "tracking"
+
+
+def init_stub(typ, address):
+    """Initialize gRPC stub.
+
+    Args:
+        typ (str): Type of service, option: client, server, tracking
+        address (str): Address of the gRPC service.
+    Returns:
+        (:obj:`ClientServiceStub`|:obj:`ServerServiceStub`|:obj:`TrackingServiceStub`): stub of the gRPC service.
+    """
+
+    channel = grpc.insecure_channel(
+        address,
+        options=[
+            ('grpc.max_send_message_length', MAX_MESSAGE_LENGTH),
+            ('grpc.max_receive_message_length', MAX_MESSAGE_LENGTH),
+        ],
+    )
+    if typ == TYPE_CLIENT:
+        stub = client_grpc.ClientServiceStub(channel)
+    elif typ == TYPE_TRACKING:
+        stub = tracking_grpc.TrackingServiceStub(channel)
+    else:
+        stub = server_grpc.ServerServiceStub(channel)
+
+    return stub
+
+
+def start_service(typ, service, port):
+    """Start gRPC service.
+    Args:
+        typ (str): Type of service, option: client, server, tracking.
+        service (:obj:`ClientService`|:obj:`ServerService`|:obj:`TrackingService`): gRPC service to start.
+        port (int): The port of the service.
+    """
+    server = grpc.server(
+        futures.ThreadPoolExecutor(max_workers=10),
+        options=[
+            ('grpc.max_send_message_length', MAX_MESSAGE_LENGTH),
+            ('grpc.max_receive_message_length', MAX_MESSAGE_LENGTH),
+        ],
+    )
+    if typ == TYPE_CLIENT:
+        client_grpc.add_ClientServiceServicer_to_server(service, server)
+    elif typ == TYPE_TRACKING:
+        tracking_grpc.add_TrackingServiceServicer_to_server(service, server)
+    else:
+        server_grpc.add_ServerServiceServicer_to_server(service, server)
+    server.add_insecure_port('[::]:{}'.format(port))
+    server.start()
+    server.wait_for_termination()
+
+
+def endpoint(host, port):
+    """Format endpoint.
+
+    Args:
+        host (str): Host address.
+        port (int): Port number.
+    Returns:
+        str: Address in `host:port` format.
+    """
+    return "{}:{}".format(host, port)
diff --git a/easyfl/compression/__init__.py b/easyfl/compression/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/config.yaml b/easyfl/config.yaml
new file mode 100644
index 0000000..5d0f941
--- /dev/null
+++ b/easyfl/config.yaml
@@ -0,0 +1,113 @@
+# The unique identifier for each federated learning task
+task_id: ""
+
+# Provide dataset and federated learning simulation related configuration.
+data:
+  # The root directory where datasets are stored.
+  root: "./data/"
+  # The name of the dataset, support: femnist, shakespeare, cifar10, and cifar100.
+  dataset: femnist
+  # The data distribution of each client, support: iid, niid (for femnist and shakespeare), and dir and class (for cifar datasets).
+    # `iid` means independent and identically distributed data.
+    # `niid` means non-independent and identically distributed data for FEMNIST and Shakespeare.
+    # `dir` means using Dirichlet process to simulate non-iid data, for CIFAR-10 and CIFAR-100 datasets.
+    # `class` means partitioning the dataset by label classes, for datasets like CIFAR-10, CIFAR-100.
+  split_type: "iid"
+
+  # The minimal number of samples in each client. It is applicable for LEAF datasets and dir simulation of CIFAR-10 and CIFAR-100.
+  min_size: 10
+  # The fraction of data sampled for LEAF datasets. e.g., 10% means that only 10% of total dataset size are used.
+  data_amount: 0.05
+  # The fraction of the number of clients used when the split_type is 'iid'.
+  iid_fraction: 0.1
+  # Whether partition users of the dataset into train-test groups. Only applicable to femnist and shakespeare datasets.
+    # True means partitioning users of the dataset into train-test groups.
+    # False means partitioning each users' samples into train-test groups.
+  user: False
+  # The fraction of data for training; the rest are for testing.
+  train_test_split: 0.9
+
+  # The number of classes in each client. Only applicable when the split_type is 'class'.
+  class_per_client: 1
+  # The targeted number of clients to construct.used in non-leaf dataset, number of clients split into. for leaf dataset, only used when split type class.
+  num_of_clients: 100
+  # The parameter for Dirichlet distribution simulation, applicable only when split_type is `dir` for CIFAR datasets.
+  alpha: 0.5
+
+  # The targeted distribution of quantities to simulate data quantity heterogeneity.
+    # The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+    # The `num_of_clients` should be divisible by `len(weights)`.
+    # None means clients are simulated with the same data quantity.
+  weights: NULL
+
+# The name of the model for training, support: lenet, rnn, resnet, resnet18, resnet50, vgg9.
+model: lenet
+# How to conduct testing, options: test_in_client or test_in_server.
+  # `test_in_client` means that each client has a test set to run testing.
+  # `test_in_server` means that server has a test set to run testing for the global model. Use this mode for cifar datasets.
+test_mode: "test_in_client"
+# The way to measure testing performance (accuracy) when test mode is `test_in_client`, support: average or weighted (means weighted average).
+test_method: "average"
+
+server:
+  track: False  # Whether track server metrics using the tracking service.
+  rounds: 10  # Total training round.
+  clients_per_round: 5  # The number of clients to train in each round.
+  test_every: 1  # The frequency of testing: conduct testing every N round.
+  save_model_every: 10  # The frequency of saving model: save model every N round.
+  save_model_path: ""  # The path to save model. Default path is root directory of the library.
+  batch_size: 32  # The batch size of test_in_server.
+  test_all: False  # Whether test all clients or only selected clients.
+  random_selection: True  # Whether select clients to train randomly.
+  # The strategy to aggregate client uploaded models, options: FedAvg, equal.
+    # FedAvg aggregates models using weighted average, where the weights are data size of clients.
+    # equal aggregates model by simple averaging.
+  aggregation_stragtegy: "FedAvg"
+  # The content of aggregation, options: all, parameters.
+    # all means aggregating models using state_dict, including both model parameters and persistent buffers like BatchNorm stats.
+    # parameters means aggregating only model parameters.
+  aggregation_content: "all"
+
+client:
+  track: False  # Whether track server metrics using the tracking service.
+  batch_size: 32  # The batch size of training in client.
+  test_batch_size: 5  # The batch size of testing in client.
+  local_epoch: 10  # The number of epochs to train in each round.
+  optimizer:
+    type: "Adam"  # The name of the optimizer, options: Adam, SGD.
+    lr: 0.001
+    momentum: 0.9
+    weight_decay: 0
+  seed: 0
+  local_test: False  # Whether test the trained models in clients before uploading them to the server.
+
+gpu: 0  # The total number of GPUs used in training. 0 means CPU.
+distributed:  # The distributed training configurations. It is only applicable when gpu > 1.
+  backend: "nccl"  # The distributed backend.
+  init_method: ""
+  world_size: 0
+  rank: 0
+  local_rank: 0
+
+tracking:  # The configurations for logging and tracking.
+  database: ""  # The path of local dataset, sqlite3.
+  log_file: ""
+  log_level: "INFO"  # The level of logging.
+  metric_file: ""
+  save_every: 1
+
+# The configuration for system heterogeneity simulation.
+resource_heterogeneous:
+  simulate: False  # Whether simulate system heterogeneity in federated learning.
+  # The type of heterogeneity to simulate, support iso, dir, real.
+    # iso means that
+  hetero_type: "real"
+  level: 3  # The level of heterogeneous (0-5), 0 means no heterogeneous among clients.
+  sleep_group_num: 1000  # The number of groups with different sleep time. 1 means all clients are the same.
+  total_time: 1000  # The total sleep time of all clients, unit: second.
+  fraction: 1  # The fraction of clients attending heterogeneous simulation.
+  grouping_strategy: "greedy"  # The grouping strategy to handle system heterogeneity, support: random, greedy, slowest.
+  initial_default_time: 5  # The estimated default training time for each training round, unit: second.
+  default_time_momentum: 0.2  # The default momentum for default time update.
+
+seed: 0  # The random seed.
\ No newline at end of file
diff --git a/easyfl/coordinator.py b/easyfl/coordinator.py
new file mode 100644
index 0000000..0b95748
--- /dev/null
+++ b/easyfl/coordinator.py
@@ -0,0 +1,481 @@
+import logging
+import os
+import random
+import sys
+import time
+from os import path
+
+import numpy as np
+import torch
+from omegaconf import OmegaConf
+
+from easyfl.client.base import BaseClient
+from easyfl.datasets import TEST_IN_SERVER
+from easyfl.datasets.data import construct_datasets
+from easyfl.distributed import dist_init, get_device
+from easyfl.models.model import load_model
+from easyfl.server.base import BaseServer
+from easyfl.simulation.system_hetero import resource_hetero_simulation
+
+logger = logging.getLogger(__name__)
+
+
+class Coordinator(object):
+    """Coordinator manages federated learning server and client.
+    A single instance of coordinator is initialized for each federated learning task
+    when the package is imported.
+    """
+
+    def __init__(self):
+        self.registered_model = False
+        self.registered_dataset = False
+        self.registered_server = False
+        self.registered_client = False
+        self.train_data = None
+        self.test_data = None
+        self.val_data = None
+        self.conf = None
+        self.model = None
+        self._model_class = None
+        self.server = None
+        self._server_class = None
+        self.clients = None
+        self._client_class = None
+        self.tracker = None
+
+    def init(self, conf, init_all=False):
+        """Initialize coordinator
+
+        Args:
+            conf (omegaconf.dictconfig.DictConfig): Internal configurations for federated learning.
+            init_all (bool): Whether initialize dataset, model, server, and client other than configuration.
+        """
+        self.init_conf(conf)
+
+        _set_random_seed(conf.seed)
+
+        if init_all:
+            self.init_dataset()
+
+            self.init_model()
+
+            self.init_server()
+
+            self.init_clients()
+
+    def run(self):
+        """Run the coordinator and the federated learning process.
+        Initialize `torch.distributed` if distributed training is configured.
+        """
+        start_time = time.time()
+
+        if self.conf.is_distributed:
+            dist_init(
+                self.conf.distributed.backend,
+                self.conf.distributed.init_method,
+                self.conf.distributed.world_size,
+                self.conf.distributed.rank,
+                self.conf.distributed.local_rank,
+            )
+        self.server.start(self.model, self.clients)
+        self.print_("Total training time {:.1f}s".format(time.time() - start_time))
+
+    def init_conf(self, conf):
+        """Initialize coordinator configuration.
+
+        Args:
+            conf (omegaconf.dictconfig.DictConfig): Configurations.
+        """
+        self.conf = conf
+        self.conf.is_distributed = (self.conf.gpu > 1)
+        if self.conf.gpu == 0:
+            self.conf.device = "cpu"
+        elif self.conf.gpu == 1:
+            self.conf.device = 0
+        else:
+            self.conf.device = get_device(self.conf.gpu, self.conf.distributed.world_size,
+                                          self.conf.distributed.local_rank)
+        self.print_("Configurations: {}".format(self.conf))
+
+    def init_dataset(self):
+        """Initialize datasets. Use provided datasets if not registered."""
+        if self.registered_dataset:
+            return
+        self.train_data, self.test_data = construct_datasets(self.conf.data.root,
+                                                             self.conf.data.dataset,
+                                                             self.conf.data.num_of_clients,
+                                                             self.conf.data.split_type,
+                                                             self.conf.data.min_size,
+                                                             self.conf.data.class_per_client,
+                                                             self.conf.data.data_amount,
+                                                             self.conf.data.iid_fraction,
+                                                             self.conf.data.user,
+                                                             self.conf.data.train_test_split,
+                                                             self.conf.data.weights,
+                                                             self.conf.data.alpha)
+
+        self.print_(f"Total training data amount: {self.train_data.total_size()}")
+        self.print_(f"Total testing data amount: {self.test_data.total_size()}")
+
+    def init_model(self):
+        """Initialize model instance."""
+        if not self.registered_model:
+            self._model_class = load_model(self.conf.model)
+
+        # model_class is None means model is registered as instance, no need initialization
+        if self._model_class:
+            self.model = self._model_class()
+
+    def init_server(self):
+        """Initialize a server instance."""
+        if not self.registered_server:
+            self._server_class = BaseServer
+
+        kwargs = {
+            "is_remote": self.conf.is_remote,
+            "local_port": self.conf.local_port
+        }
+
+        if self.conf.test_mode == TEST_IN_SERVER:
+            kwargs["test_data"] = self.test_data
+            if self.val_data:
+                kwargs["val_data"] = self.val_data
+
+        self.server = self._server_class(self.conf, **kwargs)
+
+    def init_clients(self):
+        """Initialize client instances, each represent a federated learning client."""
+        if not self.registered_client:
+            self._client_class = BaseClient
+
+        # Enforce system heterogeneity of clients.
+        sleep_time = [0 for _ in self.train_data.users]
+        if self.conf.resource_heterogeneous.simulate:
+            sleep_time = resource_hetero_simulation(self.conf.resource_heterogeneous.fraction,
+                                                    self.conf.resource_heterogeneous.hetero_type,
+                                                    self.conf.resource_heterogeneous.sleep_group_num,
+                                                    self.conf.resource_heterogeneous.level,
+                                                    self.conf.resource_heterogeneous.total_time,
+                                                    len(self.train_data.users))
+
+        client_test_data = self.test_data
+        if self.conf.test_mode == TEST_IN_SERVER:
+            client_test_data = None
+
+        self.clients = [self._client_class(u,
+                                           self.conf.client,
+                                           self.train_data,
+                                           client_test_data,
+                                           self.conf.device,
+                                           **{"sleep_time": sleep_time[i]})
+                        for i, u in enumerate(self.train_data.users)]
+
+        self.print_("Clients in total: {}".format(len(self.clients)))
+
+    def init_client(self):
+        """Initialize client instance.
+
+        Returns:
+            :obj:`BaseClient`: The initialized client instance.
+        """
+        if not self.registered_client:
+            self._client_class = BaseClient
+
+        # Get a random client if not specified
+        if self.conf.index:
+            user = self.train_data.users[self.conf.index]
+        else:
+            user = random.choice(self.train_data.users)
+
+        return self._client_class(user,
+                                  self.conf.client,
+                                  self.train_data,
+                                  self.test_data,
+                                  self.conf.device,
+                                  is_remote=self.conf.is_remote,
+                                  local_port=self.conf.local_port,
+                                  server_addr=self.conf.server_addr,
+                                  tracker_addr=self.conf.tracker_addr)
+
+    def start_server(self, args):
+        """Start a server service for remote training.
+
+        Server controls the model and testing dataset if configured to test in server.
+
+        Args:
+            args (argparse.Namespace): Configurations passed in as arguments, it is merged with configurations.
+        """
+        if args:
+            self.conf = OmegaConf.merge(self.conf, args.__dict__)
+
+        if self.conf.test_mode == TEST_IN_SERVER:
+            self.init_dataset()
+
+        self.init_model()
+
+        self.init_server()
+
+        self.server.start_service()
+
+    def start_client(self, args):
+        """Start a client service for remote training.
+
+        Client controls training datasets.
+
+        Args:
+            args (argparse.Namespace): Configurations passed in as arguments, it is merged with configurations.
+        """
+
+        if args:
+            self.conf = OmegaConf.merge(self.conf, args.__dict__)
+
+        self.init_dataset()
+
+        client = self.init_client()
+
+        client.start_service()
+
+    def register_dataset(self, train_data, test_data, val_data=None):
+        """Register datasets.
+
+        Datasets should inherit from :obj:`FederatedDataset`, e.g., :obj:`FederatedTensorDataset`.
+
+        Args:
+            train_data (:obj:`FederatedDataset`): Training dataset.
+            test_data (:obj:`FederatedDataset`): Testing dataset.
+            val_data (:obj:`FederatedDataset`): Validation dataset.
+        """
+        self.registered_dataset = True
+        self.train_data = train_data
+        self.test_data = test_data
+        self.val_data = val_data
+
+    def register_model(self, model):
+        """Register customized model for federated learning.
+
+        Args:
+            model (nn.Module): PyTorch model, both class and instance are acceptable.
+                Use model class when there is no specific arguments to initialize model.
+        """
+        self.registered_model = True
+        if not isinstance(model, type):
+            self.model = model
+        else:
+            self._model_class = model
+
+    def register_server(self, server):
+        """Register a customized federated learning server.
+
+        Args:
+            server (:obj:`BaseServer`): Customized federated learning server.
+        """
+        self.registered_server = True
+        self._server_class = server
+
+    def register_client(self, client):
+        """Register a customized federated learning client.
+
+        Args:
+            client (:obj:`BaseClient`): Customized federated learning client.
+        """
+        self.registered_client = True
+        self._client_class = client
+
+    def print_(self, content):
+        """Log the content only when the server is primary server.
+
+        Args:
+            content (str): The content to log.
+        """
+        if self._is_primary_server():
+            logger.info(content)
+
+    def _is_primary_server(self):
+        """Check whether current running server is the primary server.
+
+        In standalone or remote training, the server is primary.
+        In distributed training, the server on `rank0` is primary.
+        """
+        return not self.conf.is_distributed or self.conf.distributed.rank == 0
+
+
+def _set_random_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+
+
+# Initialize the global coordinator object
+_global_coord = Coordinator()
+
+
+def init_conf(conf=None):
+    """Initialize configuration for EasyFL. It overrides and supplements default configuration loaded from config.yaml
+    with the provided configurations.
+
+    Args:
+        conf (dict): Configurations.
+
+    Returns:
+        omegaconf.dictconfig.DictConfig: Internal configurations managed by OmegaConf.
+    """
+    here = path.abspath(path.dirname(__file__))
+    config_file = path.join(here, 'config.yaml')
+    return load_config(config_file, conf)
+
+
+def load_config(file, conf=None):
+    """Load and merge configuration from file and input
+
+    Args:
+        file (str): filename of the configuration.
+        conf (dict): Configurations.
+
+    Returns:
+        omegaconf.dictconfig.DictConfig: Internal configurations managed by OmegaConf.
+    """
+    config = OmegaConf.load(file)
+    if conf is not None:
+        config = OmegaConf.merge(config, conf)
+    return config
+
+
+def init_logger(log_level):
+    """Initialize internal logger of EasyFL.
+
+    Args:
+        log_level (int): Logger level, e.g., logging.INFO, logging.DEBUG
+    """
+    log_formatter = logging.Formatter("%(asctime)s [%(threadName)s] [%(levelname)-5.5s]  %(message)s")
+    root_logger = logging.getLogger()
+
+    log_level = logging.INFO if not log_level else log_level
+    root_logger.setLevel(log_level)
+
+    file_path = os.path.join(os.getcwd(), "logs")
+    if not os.path.exists(file_path):
+        os.makedirs(file_path)
+    file_path = path.join(file_path, "train" + time.strftime(".%m_%d_%H_%M_%S") + ".log")
+    file_handler = logging.FileHandler(file_path)
+    file_handler.setFormatter(log_formatter)
+    root_logger.addHandler(file_handler)
+
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(log_formatter)
+    root_logger.addHandler(console_handler)
+
+
+def init(conf=None, init_all=True):
+    """Initialize EasyFL.
+
+    Args:
+        conf (dict, optional): Configurations.
+        init_all (bool, optional): Whether initialize dataset, model, server, and client other than configuration.
+    """
+    global _global_coord
+
+    config = init_conf(conf)
+
+    init_logger(config.tracking.log_level)
+
+    _set_random_seed(config.seed)
+
+    _global_coord.init(config, init_all)
+
+
+def run():
+    """Run federated learning process."""
+    global _global_coord
+    _global_coord.run()
+
+
+def init_dataset():
+    """Initialize dataset, either using registered dataset or out-of-the-box datasets set in config."""
+    global _global_coord
+    _global_coord.init_dataset()
+
+
+def init_model():
+    """Initialize model, either using registered model or out-of–the-box model set in config.
+
+    Returns:
+        nn.Module: Model used in federated learning.
+    """
+    global _global_coord
+    _global_coord.init_model()
+
+    return _global_coord.model
+
+
+def start_server(args=None):
+    """Start federated learning server service for remote training.
+
+    Args:
+        args (argparse.Namespace): Configurations passed in as arguments.
+    """
+    global _global_coord
+
+    _global_coord.start_server(args)
+
+
+def start_client(args=None):
+    """Start federated learning client service for remote training.
+
+    Args:
+        args (argparse.Namespace): Configurations passed in as arguments.
+    """
+    global _global_coord
+
+    _global_coord.start_client(args)
+
+
+def get_coordinator():
+    """Get the global coordinator instance.
+
+    Returns:
+        :obj:`Coordinator`: global coordinator instance.
+    """
+    return _global_coord
+
+
+def register_dataset(train_data, test_data, val_data=None):
+    """Register datasets for federated learning training.
+
+    Args:
+        train_data (:obj:`FederatedDataset`): Training dataset.
+        test_data (:obj:`FederatedDataset`): Testing dataset.
+        val_data (:obj:`FederatedDataset`): Validation dataset.
+    """
+    global _global_coord
+    _global_coord.register_dataset(train_data, test_data, val_data)
+
+
+def register_model(model):
+    """Register model for federated learning training.
+
+    Args:
+        model (nn.Module): PyTorch model, both class and instance are acceptable.
+    """
+    global _global_coord
+    _global_coord.register_model(model)
+
+
+def register_server(server):
+    """Register federated learning server.
+
+    Args:
+        server (:obj:`BaseServer`): Customized federated learning server.
+    """
+    global _global_coord
+    _global_coord.register_server(server)
+
+
+def register_client(client):
+    """Register federated learning client.
+
+    Args:
+        client (:obj:`BaseClient`): Customized federated learning client.
+    """
+    global _global_coord
+    _global_coord.register_client(client)
diff --git a/easyfl/datasets/__init__.py b/easyfl/datasets/__init__.py
new file mode 100644
index 0000000..2f56952
--- /dev/null
+++ b/easyfl/datasets/__init__.py
@@ -0,0 +1,26 @@
+from easyfl.datasets.data import construct_datasets
+from easyfl.datasets.dataset import (
+    FederatedDataset,
+    FederatedImageDataset,
+    FederatedTensorDataset,
+    FederatedTorchDataset,
+    TEST_IN_SERVER,
+    TEST_IN_CLIENT,
+)
+from easyfl.datasets.simulation import (
+    data_simulation,
+    iid,
+    non_iid_dirichlet,
+    non_iid_class,
+    equal_division,
+    quantity_hetero,
+)
+from easyfl.datasets.utils.base_dataset import BaseDataset
+from easyfl.datasets.femnist import Femnist
+from easyfl.datasets.shakespeare import Shakespeare
+from easyfl.datasets.cifar10 import Cifar10
+from easyfl.datasets.cifar100 import Cifar100
+
+__all__ = ['FederatedDataset', 'FederatedImageDataset', 'FederatedTensorDataset', 'FederatedTorchDataset',
+           'construct_datasets', 'data_simulation', 'iid', 'non_iid_dirichlet', 'non_iid_class',
+           'equal_division', 'quantity_hetero', 'BaseDataset', 'Femnist', 'Shakespeare', 'Cifar10', 'Cifar100']
diff --git a/easyfl/datasets/cifar10/__init__.py b/easyfl/datasets/cifar10/__init__.py
new file mode 100644
index 0000000..2539044
--- /dev/null
+++ b/easyfl/datasets/cifar10/__init__.py
@@ -0,0 +1 @@
+from easyfl.datasets.cifar10.cifar10 import Cifar10
diff --git a/easyfl/datasets/cifar10/cifar10.py b/easyfl/datasets/cifar10/cifar10.py
new file mode 100644
index 0000000..2b887c3
--- /dev/null
+++ b/easyfl/datasets/cifar10/cifar10.py
@@ -0,0 +1,88 @@
+import logging
+import os
+
+import torchvision
+
+from easyfl.datasets.simulation import data_simulation
+from easyfl.datasets.utils.base_dataset import BaseDataset, CIFAR10
+from easyfl.datasets.utils.util import save_dict
+
+logger = logging.getLogger(__name__)
+
+
+class Cifar10(BaseDataset):
+    def __init__(self,
+                 root,
+                 fraction,
+                 split_type,
+                 user,
+                 iid_user_fraction=0.1,
+                 train_test_split=0.9,
+                 minsample=10,
+                 num_class=80,
+                 num_of_client=100,
+                 class_per_client=2,
+                 setting_folder=None,
+                 seed=-1,
+                 weights=None,
+                 alpha=0.5):
+        super(Cifar10, self).__init__(root,
+                                      CIFAR10,
+                                      fraction,
+                                      split_type,
+                                      user,
+                                      iid_user_fraction,
+                                      train_test_split,
+                                      minsample,
+                                      num_class,
+                                      num_of_client,
+                                      class_per_client,
+                                      setting_folder,
+                                      seed)
+        self.train_data, self.test_data = {}, {}
+        self.split_type = split_type
+        self.num_of_client = num_of_client
+        self.weights = weights
+        self.alpha = alpha
+        self.min_size = minsample
+        self.class_per_client = class_per_client
+
+    def download_packaged_dataset_and_extract(self, filename):
+        pass
+
+    def download_raw_file_and_extract(self):
+        train_set = torchvision.datasets.CIFAR10(root=self.base_folder, train=True, download=True)
+        test_set = torchvision.datasets.CIFAR10(root=self.base_folder, train=False, download=True)
+
+        self.train_data = {
+            'x': train_set.data,
+            'y': train_set.targets
+        }
+
+        self.test_data = {
+            'x': test_set.data,
+            'y': test_set.targets
+        }
+
+    def preprocess(self):
+        train_data_path = os.path.join(self.data_folder, "train")
+        test_data_path = os.path.join(self.data_folder, "test")
+        if not os.path.exists(self.data_folder):
+            os.makedirs(self.data_folder)
+        if self.weights is None and os.path.exists(train_data_path):
+            return
+        logger.info("Start CIFAR10 data simulation")
+        _, train_data = data_simulation(self.train_data['x'],
+                                        self.train_data['y'],
+                                        self.num_of_client,
+                                        self.split_type,
+                                        self.weights,
+                                        self.alpha,
+                                        self.min_size,
+                                        self.class_per_client)
+        logger.info("Complete CIFAR10 data simulation")
+        save_dict(train_data, train_data_path)
+        save_dict(self.test_data, test_data_path)
+
+    def convert_data_to_json(self):
+        pass
diff --git a/easyfl/datasets/cifar100/__init__.py b/easyfl/datasets/cifar100/__init__.py
new file mode 100644
index 0000000..97144d9
--- /dev/null
+++ b/easyfl/datasets/cifar100/__init__.py
@@ -0,0 +1 @@
+from easyfl.datasets.cifar100.cifar100 import Cifar100
diff --git a/easyfl/datasets/cifar100/cifar100.py b/easyfl/datasets/cifar100/cifar100.py
new file mode 100644
index 0000000..a73567f
--- /dev/null
+++ b/easyfl/datasets/cifar100/cifar100.py
@@ -0,0 +1,88 @@
+import logging
+import os
+
+import torchvision
+
+from easyfl.datasets.simulation import data_simulation
+from easyfl.datasets.utils.base_dataset import BaseDataset, CIFAR100
+from easyfl.datasets.utils.util import save_dict
+
+logger = logging.getLogger(__name__)
+
+
+class Cifar100(BaseDataset):
+    def __init__(self,
+                 root,
+                 fraction,
+                 split_type,
+                 user,
+                 iid_user_fraction=0.1,
+                 train_test_split=0.9,
+                 minsample=10,
+                 num_class=80,
+                 num_of_client=100,
+                 class_per_client=2,
+                 setting_folder=None,
+                 seed=-1,
+                 weights=None,
+                 alpha=0.5):
+        super(Cifar100, self).__init__(root,
+                                       CIFAR100,
+                                       fraction,
+                                       split_type,
+                                       user,
+                                       iid_user_fraction,
+                                       train_test_split,
+                                       minsample,
+                                       num_class,
+                                       num_of_client,
+                                       class_per_client,
+                                       setting_folder,
+                                       seed)
+        self.train_data, self.test_data = {}, {}
+        self.split_type = split_type
+        self.num_of_client = num_of_client
+        self.weights = weights
+        self.alpha = alpha
+        self.min_size = minsample
+        self.class_per_client = class_per_client
+
+    def download_packaged_dataset_and_extract(self, filename):
+        pass
+
+    def download_raw_file_and_extract(self):
+        train_set = torchvision.datasets.CIFAR100(root=self.base_folder, train=True, download=True)
+        test_set = torchvision.datasets.CIFAR100(root=self.base_folder, train=False, download=True)
+
+        self.train_data = {
+            'x': train_set.data,
+            'y': train_set.targets
+        }
+
+        self.test_data = {
+            'x': test_set.data,
+            'y': test_set.targets
+        }
+
+    def preprocess(self):
+        train_data_path = os.path.join(self.data_folder, "train")
+        test_data_path = os.path.join(self.data_folder, "test")
+        if not os.path.exists(self.data_folder):
+            os.makedirs(self.data_folder)
+        if self.weights is None and os.path.exists(train_data_path):
+            return
+        logger.info("Start CIFAR10 data simulation")
+        _, train_data = data_simulation(self.train_data['x'],
+                                        self.train_data['y'],
+                                        self.num_of_client,
+                                        self.split_type,
+                                        self.weights,
+                                        self.alpha,
+                                        self.min_size,
+                                        self.class_per_client)
+        logger.info("Complete CIFAR10 data simulation")
+        save_dict(train_data, train_data_path)
+        save_dict(self.test_data, test_data_path)
+
+    def convert_data_to_json(self):
+        pass
diff --git a/easyfl/datasets/data.py b/easyfl/datasets/data.py
new file mode 100644
index 0000000..3a393f7
--- /dev/null
+++ b/easyfl/datasets/data.py
@@ -0,0 +1,243 @@
+import importlib
+import json
+import logging
+import os
+
+from easyfl.datasets.dataset import FederatedTensorDataset
+from easyfl.datasets.utils.base_dataset import BaseDataset, CIFAR10, CIFAR100
+from easyfl.datasets.utils.util import load_dict
+
+logger = logging.getLogger(__name__)
+
+
+def read_dir(data_dir):
+    clients = []
+    groups = []
+    data = {}
+
+    files = os.listdir(data_dir)
+    files = [f for f in files if f.endswith('.json')]
+    for f in files:
+        file_path = os.path.join(data_dir, f)
+        with open(file_path, 'r') as inf:
+            cdata = json.load(inf)
+        clients.extend(cdata['users'])
+        if 'hierarchies' in cdata:
+            groups.extend(cdata['hierarchies'])
+        data.update(cdata['user_data'])
+
+    clients = list(sorted(data.keys()))
+    return clients, groups, data
+
+
+def read_data(dataset_name, train_data_dir, test_data_dir):
+    """Load datasets from data directories.
+
+    Args:
+        dataset_name (str): The name of the dataset.
+        train_data_dir (str): The directory of training data.
+        test_data_dir (str): The directory of testing data.
+
+    Returns:
+        list[str]: A list of client ids.
+        list[str]: A list of group ids for dataset with hierarchies.
+        dict: A dictionary of training data, e.g., {"id1": {"x": data, "y": label}, "id2": {"x": data, "y": label}}.
+        dict: A dictionary of testing data. The format is same as training data for FEMNIST and Shakespeare datasets.
+            For CIFAR datasets, the format is {"x": data, "y": label}, for centralized testing in the server.
+    """
+    if dataset_name == CIFAR10 or dataset_name == CIFAR100:
+        train_data = load_dict(train_data_dir)
+        test_data = load_dict(test_data_dir)
+        return [], [], train_data, test_data
+
+    # Data in the directories are `json` files with keys `users` and `user_data`.
+    train_clients, train_groups, train_data = read_dir(train_data_dir)
+    test_clients, test_groups, test_data = read_dir(test_data_dir)
+
+    assert train_clients == test_clients
+    assert train_groups == test_groups
+
+    return train_clients, train_groups, train_data, test_data
+
+
+def load_data(root,
+              dataset_name,
+              num_of_clients,
+              split_type,
+              min_size,
+              class_per_client,
+              data_amount,
+              iid_fraction,
+              user,
+              train_test_split,
+              quantity_weights,
+              alpha):
+    """Simulate and load federated datasets.
+
+    Args:
+        root (str): The root directory where datasets stored.
+        dataset_name (str): The name of the dataset. It currently supports: femnist, shakespeare, cifar10, and cifar100.
+            Among them, femnist and shakespeare are adopted from LEAF benchmark.
+        num_of_clients (int): The targeted number of clients to construct.
+        split_type (str): The type of statistical simulation, options: iid, dir, and class.
+            `iid` means independent and identically distributed data.
+            `niid` means non-independent and identically distributed data for Femnist and Shakespeare.
+            `dir` means using Dirichlet process to simulate non-iid data, for CIFAR-10 and CIFAR-100 datasets.
+            `class` means partitioning the dataset by label classes, for datasets like CIFAR-10, CIFAR-100.
+        min_size (int): The minimal number of samples in each client.
+            It is applicable for LEAF datasets and dir simulation of CIFAR-10 and CIFAR-100.
+        class_per_client (int): The number of classes in each client. Only applicable when the split_type is 'class'.
+        data_amount (float): The fraction of data sampled for LEAF datasets.
+            e.g., 10% means that only 10% of total dataset size are used.
+        iid_fraction (float): The fraction of the number of clients used when the split_type is 'iid'.
+        user (bool): A flag to indicate whether partition users of the dataset into train-test groups.
+            Only applicable to LEAF datasets.
+            True means partitioning users of the dataset into train-test groups.
+            False means partitioning each users' samples into train-test groups.
+        train_test_split (float): The fraction of data for training; the rest are for testing.
+            e.g., 0.9 means 90% of data are used for training and 10% are used for testing.
+        quantity_weights (list[float]): The targeted distribution of quantities to simulate data quantity heterogeneity.
+            The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+            The `num_of_clients` should be divisible by `len(weights)`.
+            None means clients are simulated with the same data quantity.
+        alpha (float): The parameter for Dirichlet distribution simulation, applicable only when split_type is `dir`.
+
+    Returns:
+        dict: A dictionary of training data, e.g., {"id1": {"x": data, "y": label}, "id2": {"x": data, "y": label}}.
+        dict: A dictionary of testing data.
+        function: A function to preprocess training data.
+        function: A function to preprocess testing data.
+        torchvision.transforms.transforms.Compose: Training data transformation.
+        torchvision.transforms.transforms.Compose: Testing data transformation.
+    """
+    user_str = "user" if user else "sample"
+    setting = BaseDataset.get_setting_folder(dataset_name, split_type, num_of_clients, min_size, class_per_client,
+                                             data_amount, iid_fraction, user_str, train_test_split, alpha,
+                                             quantity_weights)
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+    dataset_file = os.path.join(dir_path, "data_process", "{}.py".format(dataset_name))
+    if not os.path.exists(dataset_file):
+        logger.error("Please specify a valid process file path for process_x and process_y functions.")
+    dataset_path = "easyfl.datasets.data_process.{}".format(dataset_name)
+    dataset_lib = importlib.import_module(dataset_path)
+    process_x = getattr(dataset_lib, "process_x", None)
+    process_y = getattr(dataset_lib, "process_y", None)
+    transform_train = getattr(dataset_lib, "transform_train", None)
+    transform_test = getattr(dataset_lib, "transform_test", None)
+
+    data_dir = os.path.join(root, dataset_name)
+    if not data_dir:
+        os.makedirs(data_dir)
+    train_data_dir = os.path.join(data_dir, setting, "train")
+    test_data_dir = os.path.join(data_dir, setting, "test")
+
+    if not os.path.exists(train_data_dir) or not os.path.exists(test_data_dir):
+        dataset_class_path = "easyfl.datasets.{}.{}".format(dataset_name, dataset_name)
+        dataset_class_lib = importlib.import_module(dataset_class_path)
+        class_name = dataset_name.capitalize()
+        dataset = getattr(dataset_class_lib, class_name)(root=data_dir,
+                                                         fraction=data_amount,
+                                                         split_type=split_type,
+                                                         user=user,
+                                                         iid_user_fraction=iid_fraction,
+                                                         train_test_split=train_test_split,
+                                                         minsample=min_size,
+                                                         num_of_client=num_of_clients,
+                                                         class_per_client=class_per_client,
+                                                         setting_folder=setting,
+                                                         alpha=alpha,
+                                                         weights=quantity_weights)
+        try:
+            filename = f"{setting}.zip"
+            dataset.download_packaged_dataset_and_extract(filename)
+            logger.info(f"Downloaded packaged dataset {dataset_name}: {filename}")
+        except Exception as e:
+            logger.info(f"Failed to download packaged dataset: {e.args}")
+
+        # CIFAR10 generate data in setup() stage, LEAF related datasets generate data in sampling()
+        if not os.path.exists(train_data_dir):
+            dataset.setup()
+        if not os.path.exists(train_data_dir):
+            dataset.sampling()
+
+    users, train_groups, train_data, test_data = read_data(dataset_name, train_data_dir, test_data_dir)
+    return train_data, test_data, process_x, process_y, transform_train, transform_test
+
+
+def construct_datasets(root,
+                       dataset_name,
+                       num_of_clients,
+                       split_type,
+                       min_size,
+                       class_per_client,
+                       data_amount,
+                       iid_fraction,
+                       user,
+                       train_test_split,
+                       quantity_weights,
+                       alpha):
+    """Construct and load provided federated learning datasets.
+
+    Args:
+        root (str): The root directory where datasets stored.
+        dataset_name (str): The name of the dataset. It currently supports: femnist, shakespeare, cifar10, and cifar100.
+            Among them, femnist and shakespeare are adopted from LEAF benchmark.
+        num_of_clients (int): The targeted number of clients to construct.
+        split_type (str): The type of statistical simulation, options: iid, dir, and class.
+            `iid` means independent and identically distributed data.
+            `niid` means non-independent and identically distributed data for Femnist and Shakespeare.
+            `dir` means using Dirichlet process to simulate non-iid data, for CIFAR-10 and CIFAR-100 datasets.
+            `class` means partitioning the dataset by label classes, for datasets like CIFAR-10, CIFAR-100.
+        min_size (int): The minimal number of samples in each client.
+            It is applicable for LEAF datasets and dir simulation of CIFAR-10 and CIFAR-100.
+        class_per_client (int): The number of classes in each client. Only applicable when the split_type is 'class'.
+        data_amount (float): The fraction of data sampled for LEAF datasets.
+            e.g., 10% means that only 10% of total dataset size are used.
+        iid_fraction (float): The fraction of the number of clients used when the split_type is 'iid'.
+        user (bool): A flag to indicate whether partition users of the dataset into train-test groups.
+            Only applicable to LEAF datasets.
+            True means partitioning users of the dataset into train-test groups.
+            False means partitioning each users' samples into train-test groups.
+        train_test_split (float): The fraction of data for training; the rest are for testing.
+            e.g., 0.9 means 90% of data are used for training and 10% are used for testing.
+        quantity_weights (list[float]): The targeted distribution of quantities to simulate data quantity heterogeneity.
+            The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+            The `num_of_clients` should be divisible by `len(weights)`.
+            None means clients are simulated with the same data quantity.
+        alpha (float): The parameter for Dirichlet distribution simulation, applicable only when split_type is `dir`.
+
+    Returns:
+        :obj:`FederatedDataset`: Training dataset.
+        :obj:`FederatedDataset`: Testing dataset.
+    """
+    train_data, test_data, process_x, process_y, transform_train, transform_test = load_data(root,
+                                                                                             dataset_name,
+                                                                                             num_of_clients,
+                                                                                             split_type,
+                                                                                             min_size,
+                                                                                             class_per_client,
+                                                                                             data_amount,
+                                                                                             iid_fraction,
+                                                                                             user,
+                                                                                             train_test_split,
+                                                                                             quantity_weights,
+                                                                                             alpha)
+
+    # CIFAR datasets are simulated.
+    test_simulated = True
+    if dataset_name == CIFAR10 or dataset_name == CIFAR100:
+        test_simulated = False
+
+    train_data = FederatedTensorDataset(train_data,
+                                        simulated=True,
+                                        do_simulate=False,
+                                        process_x=process_x,
+                                        process_y=process_y,
+                                        transform=transform_train)
+    test_data = FederatedTensorDataset(test_data,
+                                       simulated=test_simulated,
+                                       do_simulate=False,
+                                       process_x=process_x,
+                                       process_y=process_y,
+                                       transform=transform_test)
+    return train_data, test_data
diff --git a/easyfl/datasets/data_process/__init__.py b/easyfl/datasets/data_process/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/datasets/data_process/cifar10.py b/easyfl/datasets/data_process/cifar10.py
new file mode 100644
index 0000000..9c2ffbe
--- /dev/null
+++ b/easyfl/datasets/data_process/cifar10.py
@@ -0,0 +1,55 @@
+import numpy as np
+import torch
+import torchvision
+from torchvision import transforms
+
+
+class Cutout(object):
+    """Cutout data augmentation is adopted from https://github.com/uoguelph-mlrg/Cutout"""
+
+    def __init__(self, length=16):
+        self.length = length
+
+    def __call__(self, img):
+        """
+        Args:
+            img (Tensor): Tensor image of size (C, H, W).
+
+        Returns:
+            Tensor: Image with n_holes of dimension length x length cut out of it. 
+        """
+        h = img.size(1)
+        w = img.size(2)
+
+        mask = np.ones((h, w), np.float32)
+
+        y = np.random.randint(h)
+        x = np.random.randint(w)
+
+        y1 = np.clip(y - self.length // 2, 0, h)
+        y2 = np.clip(y + self.length // 2, 0, h)
+        x1 = np.clip(x - self.length // 2, 0, w)
+        x2 = np.clip(x + self.length // 2, 0, w)
+
+        mask[y1: y2, x1: x2] = 0.
+
+        mask = torch.from_numpy(mask)
+        mask = mask.expand_as(img)
+        img *= mask
+        return img
+
+
+transform_train = transforms.Compose([
+    torchvision.transforms.ToPILImage(mode='RGB'),
+    transforms.RandomCrop(32, padding=4),
+    transforms.RandomHorizontalFlip(),
+    transforms.ToTensor(),
+    transforms.Normalize((0.49139968, 0.48215827, 0.44653124), (0.24703233, 0.24348505, 0.26158768)),
+])
+
+transform_train.transforms.append(Cutout())
+
+transform_test = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.49139968, 0.48215827, 0.44653124), (0.24703233, 0.24348505, 0.26158768)),
+])
diff --git a/easyfl/datasets/data_process/cifar100.py b/easyfl/datasets/data_process/cifar100.py
new file mode 100644
index 0000000..2ae004b
--- /dev/null
+++ b/easyfl/datasets/data_process/cifar100.py
@@ -0,0 +1,55 @@
+import numpy as np
+import torch
+import torchvision
+from torchvision import transforms
+
+
+class Cutout(object):
+    """Cutout data augmentation is adopted from https://github.com/uoguelph-mlrg/Cutout"""
+
+    def __init__(self, length=16):
+        self.length = length
+
+    def __call__(self, img):
+        """
+        Args:
+            img (Tensor): Tensor image of size (C, H, W).
+
+        Returns:
+            Tensor: Image with n_holes of dimension length x length cut out of it.
+        """
+        h = img.size(1)
+        w = img.size(2)
+
+        mask = np.ones((h, w), np.float32)
+
+        y = np.random.randint(h)
+        x = np.random.randint(w)
+
+        y1 = np.clip(y - self.length // 2, 0, h)
+        y2 = np.clip(y + self.length // 2, 0, h)
+        x1 = np.clip(x - self.length // 2, 0, w)
+        x2 = np.clip(x + self.length // 2, 0, w)
+
+        mask[y1: y2, x1: x2] = 0.
+
+        mask = torch.from_numpy(mask)
+        mask = mask.expand_as(img)
+        img *= mask
+        return img
+
+
+transform_train = transforms.Compose([
+    torchvision.transforms.ToPILImage(mode='RGB'),
+    transforms.RandomCrop(32, padding=4),
+    transforms.RandomHorizontalFlip(),
+    transforms.ToTensor(),
+    transforms.Normalize((0.49139968, 0.48215827, 0.44653124), (0.24703233, 0.24348505, 0.26158768)),
+])
+
+transform_train.transforms.append(Cutout())
+
+transform_test = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.49139968, 0.48215827, 0.44653124), (0.24703233, 0.24348505, 0.26158768)),
+])
diff --git a/easyfl/datasets/data_process/femnist.py b/easyfl/datasets/data_process/femnist.py
new file mode 100644
index 0000000..fc0da5a
--- /dev/null
+++ b/easyfl/datasets/data_process/femnist.py
@@ -0,0 +1,10 @@
+import torch
+
+
+def process_x(raw_x_batch):
+    raw_x_batch = torch.FloatTensor(raw_x_batch)
+    return raw_x_batch.view(-1, 1, 28, 28)
+
+
+def process_y(raw_y_batch):
+    return torch.LongTensor(raw_y_batch)
diff --git a/easyfl/datasets/data_process/language_utils.py b/easyfl/datasets/data_process/language_utils.py
new file mode 100755
index 0000000..865585d
--- /dev/null
+++ b/easyfl/datasets/data_process/language_utils.py
@@ -0,0 +1,142 @@
+"""
+These codes are adopted from LEAF.
+"""
+
+import json
+import re
+
+import numpy as np
+
+# ------------------------
+# utils for shakespeare dataset
+
+ALL_LETTERS = "\n !\"&'(),-.0123456789:;>?ABCDEFGHIJKLMNOPQRSTUVWXYZ[]abcdefghijklmnopqrstuvwxyz}"
+NUM_LETTERS = len(ALL_LETTERS)
+
+
+def _one_hot(index, size):
+    """returns one-hot vector with given size and value 1 at given index"""
+    vec = [0 for _ in range(size)]
+    vec[int(index)] = 1
+    return vec
+
+
+def letter_to_vec(letter):
+    """returns one-hot representation of given letter"""
+    index = ALL_LETTERS.find(letter)
+    return _one_hot(index, NUM_LETTERS)
+
+
+def word_to_indices(word):
+    """returns a list of character indices
+
+    Args:
+        word: string
+    
+    Return:
+        indices: int list with length len(word)
+    """
+    indices = []
+    for c in word:
+        indices.append(ALL_LETTERS.find(c))
+    return indices
+
+
+# ------------------------
+# utils for sent140 dataset
+
+
+def split_line(line):
+    """split given line/phrase into list of words
+
+    Args:
+        line: string representing phrase to be split
+    
+    Return:
+        list of strings, with each string representing a word
+    """
+    return re.findall(r"[\w']+|[.,!?;]", line)
+
+
+def _word_to_index(word, indd):
+    """returns index of given word based on given lookup dictionary
+
+    returns the length of the lookup dictionary if word not found
+
+    Args:
+        word: string
+        indd: dictionary with string words as keys and int indices as values
+    """
+    if word in indd:
+        return indd[word]
+    else:
+        return len(indd)
+
+
+def line_to_indices(line, word2id, max_words=25):
+    """converts given phrase into list of word indices
+    
+    if the phrase has more than max_words words, returns a list containing
+    indices of the first max_words words
+    if the phrase has less than max_words words, repeatedly appends integer 
+    representing unknown index to returned list until the list's length is 
+    max_words
+
+    Args:
+        line: string representing phrase/sequence of words
+        word2id: dictionary with string words as keys and int indices as values
+        max_words: maximum number of word indices in returned list
+
+    Return:
+        indl: list of word indices, one index for each word in phrase
+    """
+    unk_id = len(word2id)
+    line_list = split_line(line)  # split phrase in words
+    indl = [word2id[w] if w in word2id else unk_id for w in line_list[:max_words]]
+    indl += [unk_id] * (max_words - len(indl))
+    return indl
+
+
+def bag_of_words(line, vocab):
+    """returns bag of words representation of given phrase using given vocab
+
+    Args:
+        line: string representing phrase to be parsed
+        vocab: dictionary with words as keys and indices as values
+
+    Return:
+        integer list
+    """
+    bag = [0] * len(vocab)
+    words = split_line(line)
+    for w in words:
+        if w in vocab:
+            bag[vocab[w]] += 1
+    return bag
+
+
+def get_word_emb_arr(path):
+    with open(path, 'r') as inf:
+        embs = json.load(inf)
+    vocab = embs['vocab']
+    word_emb_arr = np.array(embs['emba'])
+    indd = {}
+    for i in range(len(vocab)):
+        indd[vocab[i]] = i
+    vocab = {w: i for i, w in enumerate(embs['vocab'])}
+    return word_emb_arr, indd, vocab
+
+
+def val_to_vec(size, val):
+    """Converts target into one-hot.
+
+    Args:
+        size: Size of vector.
+        val: Integer in range [0, size].
+    Returns:
+         vec: one-hot vector with a 1 in the val element.
+    """
+    assert 0 <= val < size
+    vec = [0 for _ in range(size)]
+    vec[int(val)] = 1
+    return vec
diff --git a/easyfl/datasets/data_process/shakespeare.py b/easyfl/datasets/data_process/shakespeare.py
new file mode 100644
index 0000000..5f34b19
--- /dev/null
+++ b/easyfl/datasets/data_process/shakespeare.py
@@ -0,0 +1,15 @@
+import numpy as np
+import torch
+
+from easyfl.datasets.data_process.language_utils import word_to_indices, letter_to_vec
+
+
+def process_x(raw_x_batch):
+    x_batch = [word_to_indices(word) for word in raw_x_batch]
+    x_batch = np.array(x_batch)
+    return torch.LongTensor(x_batch)
+
+
+def process_y(raw_y_batch):
+    y_batch = [np.argmax(letter_to_vec(c)) for c in raw_y_batch]
+    return torch.LongTensor(y_batch)
diff --git a/easyfl/datasets/dataset.py b/easyfl/datasets/dataset.py
new file mode 100644
index 0000000..1d7bfc0
--- /dev/null
+++ b/easyfl/datasets/dataset.py
@@ -0,0 +1,427 @@
+import logging
+import os
+from abc import ABC, abstractmethod
+
+import numpy as np
+import torch
+from torch.utils.data import TensorDataset, DataLoader
+from torchvision.datasets.folder import default_loader, make_dataset
+
+from easyfl.datasets.dataset_util import TransformDataset, ImageDataset
+from easyfl.datasets.simulation import data_simulation, SIMULATE_IID
+
+logger = logging.getLogger(__name__)
+
+TEST_IN_SERVER = "test_in_server"
+TEST_IN_CLIENT = "test_in_client"
+
+IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif', '.tiff', '.webp')
+
+DEFAULT_MERGED_ID = "Merged"
+
+
+def default_process_x(raw_x_batch):
+    return torch.tensor(raw_x_batch)
+
+
+def default_process_y(raw_y_batch):
+    return torch.tensor(raw_y_batch)
+
+
+class FederatedDataset(ABC):
+    """The abstract class of federated dataset for EasyFL."""
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def loader(self, batch_size, shuffle=True):
+        """Get data loader.
+
+        Args:
+            batch_size (int): The batch size of the data loader.
+            shuffle (bool): Whether shuffle the data in the loader.
+        """
+        raise NotImplementedError("Data loader not implemented")
+
+    @abstractmethod
+    def size(self, cid):
+        """Get dataset size.
+
+        Args:
+            cid (str): client id.
+        """
+        raise NotImplementedError("Size not implemented")
+
+    @property
+    def users(self):
+        """Get client ids of the federated dataset."""
+        raise NotImplementedError("Users not implemented")
+
+
+class FederatedTensorDataset(FederatedDataset):
+    """Federated tensor dataset, data of clients are in format of tensor or list.
+
+    Args:
+        data (dict): A dictionary of data, e.g., {"id1": {"x": [[], [], ...], "y": [...]]}}.
+            If simulation is not done previously, it is in format of {'x':[[],[], ...], 'y': [...]}.
+        transform (torchvision.transforms.transforms.Compose, optional): Transformation for data.
+        target_transform (torchvision.transforms.transforms.Compose, optional): Transformation for data labels.
+        process_x (function, optional): A function to preprocess training data.
+        process_y (function, optional): A function to preprocess testing data.
+        simulated (bool, optional): Whether the dataset is simulated to federated learning settings.
+        do_simulate (bool, optional): Whether conduct simulation. It is only effective if it is not simulated.
+        num_of_clients (int, optional): number of clients for simulation. Only need if doing simulation.
+        simulation_method(optional): split method. Only need if doing simulation.
+        weights (list[float], optional): The targeted distribution of quantities to simulate quantity heterogeneity.
+            The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+            The `num_of_clients` should be divisible by `len(weights)`.
+            None means clients are simulated with the same data quantity.
+        alpha (float, optional): The parameter for Dirichlet distribution simulation, only for dir simulation.
+        min_size (int, optional): The minimal number of samples in each client, only for dir simulation.
+        class_per_client (int, optional): The number of classes in each client, only for non-iid by class simulation.
+    """
+
+    def __init__(self,
+                 data,
+                 transform=None,
+                 target_transform=None,
+                 process_x=default_process_x,
+                 process_y=default_process_x,
+                 simulated=False,
+                 do_simulate=True,
+                 num_of_clients=10,
+                 simulation_method=SIMULATE_IID,
+                 weights=None,
+                 alpha=0.5,
+                 min_size=10,
+                 class_per_client=1):
+        super(FederatedTensorDataset, self).__init__()
+        self.simulated = simulated
+        self.data = data
+        self._validate_data(self.data)
+        self.process_x = process_x
+        self.process_y = process_y
+        self.transform = transform
+        self.target_transform = target_transform
+        if simulated:
+            self._users = sorted(list(self.data.keys()))
+
+        elif do_simulate:
+            # For simulation method provided, we support testing in server for now
+            # TODO: support simulation for test data => test in clients
+            self.simulation(num_of_clients, simulation_method, weights, alpha, min_size, class_per_client)
+
+    def simulation(self, num_of_clients, niid=SIMULATE_IID, weights=None, alpha=0.5, min_size=10, class_per_client=1):
+        if self.simulated:
+            logger.warning("The dataset is already simulated, the simulation would not proceed.")
+            return
+        self._users, self.data = data_simulation(
+            self.data['x'],
+            self.data['y'],
+            num_of_clients,
+            niid,
+            weights,
+            alpha,
+            min_size,
+            class_per_client)
+        self.simulated = True
+
+    def loader(self, batch_size, client_id=None, shuffle=True, seed=0, transform=None, drop_last=False):
+        """Get dataset loader.
+
+        Args:
+            batch_size (int): The batch size.
+            client_id (str, optional): The id of client.
+            shuffle (bool, optional): Whether to shuffle before batching.
+            seed (int, optional): The shuffle seed.
+            transform (torchvision.transforms.transforms.Compose, optional): Data transformation.
+            drop_last (bool, optional): Whether to drop the last batch if its size is smaller than batch size.
+
+        Returns:
+            torch.utils.data.DataLoader: The data loader to load data.
+        """
+        # Simulation need to be done before creating a data loader
+        if client_id is None:
+            data = self.data
+        else:
+            data = self.data[client_id]
+
+        data_x = data['x']
+        data_y = data['y']
+
+        data_x = np.array(data_x)
+        data_y = np.array(data_y)
+
+        data_x = self._input_process(data_x)
+        data_y = self._label_process(data_y)
+        if shuffle:
+            np.random.seed(seed)
+            rng_state = np.random.get_state()
+            np.random.shuffle(data_x)
+            np.random.set_state(rng_state)
+            np.random.shuffle(data_y)
+
+        transform = self.transform if transform is None else transform
+        if transform is not None:
+            dataset = TransformDataset(data_x,
+                                       data_y,
+                                       transform_x=transform,
+                                       transform_y=self.target_transform)
+        else:
+            dataset = TensorDataset(data_x, data_y)
+        loader = DataLoader(dataset=dataset,
+                            batch_size=batch_size,
+                            shuffle=shuffle,
+                            drop_last=drop_last)
+        return loader
+
+    @property
+    def users(self):
+        return self._users
+
+    @users.setter
+    def users(self, value):
+        self._users = value
+
+    def size(self, cid=None):
+        if cid is not None:
+            return len(self.data[cid]['y'])
+        else:
+            return len(self.data['y'])
+
+    def total_size(self):
+        if 'y' in self.data:
+            return len(self.data['y'])
+        else:
+            return sum([len(self.data[i]['y']) for i in self.data])
+
+    def _input_process(self, sample):
+        if self.process_x is not None:
+            sample = self.process_x(sample)
+        return sample
+
+    def _label_process(self, label):
+        if self.process_y is not None:
+            label = self.process_y(label)
+        return label
+
+    def _validate_data(self, data):
+        if self.simulated:
+            for i in data:
+                assert len(data[i]['x']) == len(data[i]['y'])
+        else:
+            assert len(data['x']) == len(data['y'])
+
+
+class FederatedImageDataset(FederatedDataset):
+    """
+    Federated image dataset, data of clients are in format of image folder.
+
+    Args:
+        root (str|list[str]): The root directory or directories of image data folder.
+            If the dataset is simulated to multiple clients, the root is a list of directories.
+            Otherwise, it is the directory of an image data folder.
+        simulated (bool): Whether the dataset is simulated to federated learning settings.
+        do_simulate (bool, optional): Whether conduct simulation. It is only effective if it is not simulated.
+        extensions (list[str], optional): A list of allowed image extensions.
+            Only one of `extensions` and `is_valid_file` can be specified.
+        is_valid_file (function, optional): A function that takes path of an Image file and check if it is valid.
+            Only one of `extensions` and `is_valid_file` can be specified.
+        transform (torchvision.transforms.transforms.Compose, optional): Transformation for data.
+        target_transform (torchvision.transforms.transforms.Compose, optional): Transformation for data labels.
+        num_of_clients (int, optional): number of clients for simulation. Only need if doing simulation.
+        simulation_method(optional): split method. Only need if doing simulation.
+        weights (list[float], optional): The targeted distribution of quantities to simulate quantity heterogeneity.
+            The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+            The `num_of_clients` should be divisible by `len(weights)`.
+            None means clients are simulated with the same data quantity.
+        alpha (float, optional): The parameter for Dirichlet distribution simulation, only for dir simulation.
+        min_size (int, optional): The minimal number of samples in each client, only for dir simulation.
+        class_per_client (int, optional): The number of classes in each client, only for non-iid by class simulation.
+        client_ids (list[str], optional): A list of client ids.
+            Each client id matches with an element in roots.
+            The client ids are ["f0000001", "f00000002", ...] if not specified.
+    """
+
+    def __init__(self,
+                 root,
+                 simulated,
+                 do_simulate=True,
+                 extensions=IMG_EXTENSIONS,
+                 is_valid_file=None,
+                 transform=None,
+                 target_transform=None,
+                 client_ids="default",
+                 num_of_clients=10,
+                 simulation_method=SIMULATE_IID,
+                 weights=None,
+                 alpha=0.5,
+                 min_size=10,
+                 class_per_client=1):
+        super(FederatedImageDataset, self).__init__()
+        self.simulated = simulated
+        self.transform = transform
+        self.target_transform = target_transform
+
+        if self.simulated:
+            self.data = {}
+            self.classes = {}
+            self.class_to_idx = {}
+            self.roots = root
+            self.num_of_clients = len(self.roots)
+            if client_ids == "default":
+                self.users = ["f%07.0f" % (i) for i in range(len(self.roots))]
+            else:
+                self.users = client_ids
+            for i in range(self.num_of_clients):
+                current_client_id = self.users[i]
+                classes, class_to_idx = self._find_classes(self.roots[i])
+                samples = make_dataset(self.roots[i], class_to_idx, extensions, is_valid_file)
+                if len(samples) == 0:
+                    msg = "Found 0 files in subfolders of: {}\n".format(self.root)
+                    if extensions is not None:
+                        msg += "Supported extensions are: {}".format(",".join(extensions))
+                    raise RuntimeError(msg)
+
+                self.classes[current_client_id] = classes
+                self.class_to_idx[current_client_id] = class_to_idx
+                temp_client = {'x': [i[0] for i in samples], 'y': [i[1] for i in samples]}
+                self.data[current_client_id] = temp_client
+        elif do_simulate:
+            self.root = root
+            classes, class_to_idx = self._find_classes(self.root)
+            samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file)
+            if len(samples) == 0:
+                msg = "Found 0 files in subfolders of: {}\n".format(self.root)
+                if extensions is not None:
+                    msg += "Supported extensions are: {}".format(",".join(extensions))
+                raise RuntimeError(msg)
+            self.extensions = extensions
+            self.classes = classes
+            self.class_to_idx = class_to_idx
+            self.samples = samples
+            self.inputs = [i[0] for i in self.samples]
+            self.labels = [i[1] for i in self.samples]
+            self.simulation(num_of_clients, simulation_method, weights, alpha, min_size, class_per_client)
+
+    def simulation(self, num_of_clients, niid="iid", weights=[1], alpha=0.5, min_size=10, class_per_client=1):
+        if self.simulated:
+            logger.warning("The dataset is already simulated, the simulation would not proceed.")
+            return
+        self.users, self.data = data_simulation(self.inputs,
+                                                self.labels,
+                                                num_of_clients,
+                                                niid,
+                                                weights,
+                                                alpha,
+                                                min_size,
+                                                class_per_client)
+        self.simulated = True
+
+    def loader(self, batch_size, client_id=None, shuffle=True, seed=0, num_workers=2, transform=None):
+        """Get dataset loader.
+
+        Args:
+            batch_size (int): The batch size.
+            client_id (str, optional): The id of client.
+            shuffle (bool, optional): Whether to shuffle before batching.
+            seed (int, optional): The shuffle seed.
+            transform (torchvision.transforms.transforms.Compose, optional): Data transformation.
+            num_workers (int, optional): The number of workers for dataset loader.
+
+        Returns:
+            torch.utils.data.DataLoader: The data loader to load data.
+        """
+        assert self.simulated is True
+        if client_id is None:
+            data = self.data
+        else:
+            data = self.data[client_id]
+        data_x = data['x'][:]
+        data_y = data['y'][:]
+
+        # randomly shuffle data
+        if shuffle:
+            np.random.seed(seed)
+            rng_state = np.random.get_state()
+            np.random.shuffle(data_x)
+            np.random.set_state(rng_state)
+            np.random.shuffle(data_y)
+
+        transform = self.transform if transform is None else transform
+        dataset = ImageDataset(data_x, data_y, transform, self.target_transform)
+        loader = torch.utils.data.DataLoader(dataset,
+                                             batch_size=batch_size,
+                                             shuffle=shuffle,
+                                             num_workers=num_workers,
+                                             pin_memory=False)
+        return loader
+
+    @property
+    def users(self):
+        return self._users
+
+    @users.setter
+    def users(self, value):
+        self._users = value
+
+    def size(self, cid=None):
+        if cid is not None:
+            return len(self.data[cid]['y'])
+        else:
+            return len(self.data['y'])
+
+    def _find_classes(self, dir):
+        """Get the classes of the dataset.
+
+        Args:
+            dir (str): Root directory path.
+
+        Returns:
+            tuple: (classes, class_to_idx) where classes are relative to directory and class_to_idx is a dictionary.
+
+        Note:
+            Need to ensure that no class is a subdirectory of another.
+        """
+        classes = [d.name for d in os.scandir(dir) if d.is_dir()]
+        classes.sort()
+        class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)}
+        return classes, class_to_idx
+
+
+class FederatedTorchDataset(FederatedDataset):
+    """Wrapper over PyTorch dataset.
+
+    Args:
+        data (dict): A dictionary of client datasets, format {"client_id": loader1, "client_id2": loader2}.
+    """
+
+    def __init__(self, data, users):
+        super(FederatedTorchDataset, self).__init__()
+        self.data = data
+        self._users = users
+
+    def loader(self, batch_size, client_id=None, shuffle=True, seed=0, num_workers=2, transform=None):
+        if client_id is None:
+            data = self.data
+        else:
+            data = self.data[client_id]
+
+        loader = torch.utils.data.DataLoader(
+            data, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, pin_memory=True)
+        return loader
+
+    @property
+    def users(self):
+        return self._users
+
+    @users.setter
+    def users(self, value):
+        self._users = value
+
+    def size(self, cid=None):
+        if cid is not None:
+            return len(self.data[cid])
+        else:
+            return len(self.data)
diff --git a/easyfl/datasets/dataset_util.py b/easyfl/datasets/dataset_util.py
new file mode 100644
index 0000000..49136ee
--- /dev/null
+++ b/easyfl/datasets/dataset_util.py
@@ -0,0 +1,45 @@
+from PIL import Image
+from torch.utils.data import Dataset
+
+
+class ImageDataset(Dataset):
+    def __init__(self, images, labels, transform_x=None, transform_y=None):
+        self.images = images
+        self.labels = labels
+        self.transform_x = transform_x
+        self.transform_y = transform_y
+
+    def __len__(self):
+        return len(self.labels)
+
+    def __getitem__(self, index):
+        data, label = self.images[index], self.labels[index]
+        if self.transform_x is not None:
+            data = self.transform_x(Image.open(data))
+        else:
+            data = Image.open(data)
+        if self.transform_y is not None:
+            label = self.transform_y(label)
+        return data, label
+
+
+class TransformDataset(Dataset):
+    def __init__(self, images, labels, transform_x=None, transform_y=None):
+        self.data = images
+        self.targets = labels
+        self.transform_x = transform_x
+        self.transform_y = transform_y
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        sample = self.data[idx]
+        target = self.targets[idx]
+
+        if self.transform_x:
+            sample = self.transform_x(sample)
+        if self.transform_y:
+            target = self.transform_y(target)
+
+        return sample, target
diff --git a/easyfl/datasets/femnist/__init__.py b/easyfl/datasets/femnist/__init__.py
new file mode 100644
index 0000000..3114b65
--- /dev/null
+++ b/easyfl/datasets/femnist/__init__.py
@@ -0,0 +1 @@
+from easyfl.datasets.femnist.femnist import Femnist
diff --git a/easyfl/datasets/femnist/femnist.py b/easyfl/datasets/femnist/femnist.py
new file mode 100644
index 0000000..1242bea
--- /dev/null
+++ b/easyfl/datasets/femnist/femnist.py
@@ -0,0 +1,109 @@
+import logging
+import os
+
+from easyfl.datasets.femnist.preprocess.data_to_json import data_to_json
+from easyfl.datasets.femnist.preprocess.get_file_dirs import get_file_dir
+from easyfl.datasets.femnist.preprocess.get_hashes import get_hash
+from easyfl.datasets.femnist.preprocess.group_by_writer import group_by_writer
+from easyfl.datasets.femnist.preprocess.match_hashes import match_hash
+from easyfl.datasets.utils.base_dataset import BaseDataset
+from easyfl.datasets.utils.download import download_url, extract_archive, download_from_google_drive
+
+logger = logging.getLogger(__name__)
+
+
+class Femnist(BaseDataset):
+    """FEMNIST dataset implementation. It gets FEMNIST dataset according to configurations.
+     It stores the processed datasets locally.
+
+    Attributes:
+        base_folder (str): The base folder path of the datasets folder.
+        class_url (str): The url to get the by_class split FEMNIST.
+        write_url (str): The url to get the by_write split FEMNIST.
+    """
+
+    def __init__(self,
+                 root,
+                 fraction,
+                 split_type,
+                 user,
+                 iid_user_fraction=0.1,
+                 train_test_split=0.9,
+                 minsample=10,
+                 num_class=62,
+                 num_of_client=100,
+                 class_per_client=2,
+                 setting_folder=None,
+                 seed=-1,
+                 **kwargs):
+        super(Femnist, self).__init__(root,
+                                      "femnist",
+                                      fraction,
+                                      split_type,
+                                      user,
+                                      iid_user_fraction,
+                                      train_test_split,
+                                      minsample,
+                                      num_class,
+                                      num_of_client,
+                                      class_per_client,
+                                      setting_folder,
+                                      seed)
+        self.class_url = "https://s3.amazonaws.com/nist-srd/SD19/by_class.zip"
+        self.write_url = "https://s3.amazonaws.com/nist-srd/SD19/by_write.zip"
+        self.packaged_data_files = {
+            "femnist_niid_100_10_1_0.05_0.1_sample_0.9.zip": "https://dl.dropboxusercontent.com/s/oyhegd3c0pxa0tl/femnist_niid_100_10_1_0.05_0.1_sample_0.9.zip",
+            "femnist_iid_100_10_1_0.05_0.1_sample_0.9.zip": "https://dl.dropboxusercontent.com/s/jcg0xrz5qrri4tv/femnist_iid_100_10_1_0.05_0.1_sample_0.9.zip"
+        }
+        # Google Drive ids
+        # self.packaged_data_files = {
+        #     "femnist_niid_100_10_1_0.05_0.1_sample_0.9.zip": "11vAxASl-af41iHpFqW2jixs1jOUZDXMS",
+        #     "femnist_iid_100_10_1_0.05_0.1_sample_0.9.zip": "1U9Sn2ACbidwhhihdJdZPfK2YddPMr33k"
+        # }
+
+    def download_packaged_dataset_and_extract(self, filename):
+        file_path = download_url(self.packaged_data_files[filename], self.base_folder)
+        extract_archive(file_path, remove_finished=True)
+
+    def download_raw_file_and_extract(self):
+        raw_data_folder = os.path.join(self.base_folder, "raw_data")
+        if not os.path.exists(raw_data_folder):
+            os.makedirs(raw_data_folder)
+        elif os.listdir(raw_data_folder):
+            logger.info("raw file exists")
+            return
+        class_path = download_url(self.class_url, raw_data_folder)
+        write_path = download_url(self.write_url, raw_data_folder)
+        extract_archive(class_path, remove_finished=True)
+        extract_archive(write_path, remove_finished=True)
+        logger.info("raw file is downloaded")
+
+    def preprocess(self):
+        intermediate_folder = os.path.join(self.base_folder, "intermediate")
+        if not os.path.exists(intermediate_folder):
+            os.makedirs(intermediate_folder)
+        if not os.path.exists(intermediate_folder + "/class_file_dirs.pkl"):
+            logger.info("extracting file directories of images")
+            get_file_dir(self.base_folder)
+            logger.info("finished extracting file directories of images")
+        if not os.path.exists(intermediate_folder + "/class_file_hashes.pkl"):
+            logger.info("calculating image hashes")
+            get_hash(self.base_folder)
+            logger.info("finished calculating image hashes")
+        if not os.path.exists(intermediate_folder + "/write_with_class.pkl"):
+            logger.info("assigning class labels to write images")
+            match_hash(self.base_folder)
+            logger.info("finished assigning class labels to write images")
+        if not os.path.exists(intermediate_folder + "/images_by_writer.pkl"):
+            logger.info("grouping images by writer")
+            group_by_writer(self.base_folder)
+            logger.info("finished grouping images by writer")
+
+    def convert_data_to_json(self):
+        all_data_folder = os.path.join(self.base_folder, "all_data")
+        if not os.path.exists(all_data_folder):
+            os.makedirs(all_data_folder)
+        if not os.listdir(all_data_folder):
+            logger.info("converting data to .json format")
+            data_to_json(self.base_folder)
+            logger.info("finished converting data to .json format")
diff --git a/easyfl/datasets/femnist/preprocess/__init__.py b/easyfl/datasets/femnist/preprocess/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/datasets/femnist/preprocess/data_to_json.py b/easyfl/datasets/femnist/preprocess/data_to_json.py
new file mode 100644
index 0000000..ab3a563
--- /dev/null
+++ b/easyfl/datasets/femnist/preprocess/data_to_json.py
@@ -0,0 +1,94 @@
+"""
+These codes are adopted from LEAF with some modifications.
+
+It converts a list of (writer, [list of (file,class)]) tuples into a json object of the form:
+  {users: [bob, etc], num_samples: [124, etc.],
+  user_data: {bob : {x:[img1,img2,etc], y:[class1,class2,etc]}, etc}},
+where "img_" is a vectorized representation of the corresponding image.
+"""
+
+from __future__ import division
+
+import json
+import math
+import os
+
+import numpy as np
+from PIL import Image
+
+from easyfl.datasets.utils import util
+
+MAX_WRITERS = 100  # max number of writers per json file.
+
+
+def relabel_class(c):
+    """
+    maps hexadecimal class value (string) to a decimal number
+    returns:
+    - 0 through 9 for classes representing respective numbers
+    - 10 through 35 for classes representing respective uppercase letters
+    - 36 through 61 for classes representing respective lowercase letters
+    """
+    if c.isdigit() and int(c) < 40:
+        return int(c) - 30
+    elif int(c, 16) <= 90:  # uppercase
+        return int(c, 16) - 55
+    else:
+        return int(c, 16) - 61
+
+
+def data_to_json(base_folder):
+    by_writer_dir = os.path.join(base_folder, "intermediate", "images_by_writer")
+    writers = util.load_obj(by_writer_dir)
+
+    num_json = int(math.ceil(len(writers) / MAX_WRITERS))
+
+    users = []
+    num_samples = []
+    user_data = {}
+
+    writer_count = 0
+    json_index = 0
+    for (w, l) in writers:
+
+        users.append(w)
+        num_samples.append(len(l))
+        user_data[w] = {"x": [], "y": []}
+
+        size = 28, 28  # original image size is 128, 128
+        for (f, c) in l:
+            file_path = os.path.join(base_folder, f)
+            img = Image.open(file_path)
+            gray = img.convert("L")
+            gray.thumbnail(size, Image.ANTIALIAS)
+            arr = np.asarray(gray).copy()
+            vec = arr.flatten()
+            vec = vec / 255  # scale all pixel values to between 0 and 1
+            vec = vec.tolist()
+
+            nc = relabel_class(c)
+
+            user_data[w]["x"].append(vec)
+            user_data[w]["y"].append(nc)
+
+        writer_count += 1
+        if writer_count == MAX_WRITERS:
+            all_data = {}
+            all_data["users"] = users
+            all_data["num_samples"] = num_samples
+            all_data["user_data"] = user_data
+
+            file_name = "all_data_%d.json" % json_index
+            file_path = os.path.join(base_folder, "all_data", file_name)
+
+            print("writing %s" % file_name)
+
+            with open(file_path, "w") as outfile:
+                json.dump(all_data, outfile)
+
+            writer_count = 0
+            json_index += 1
+
+            users[:] = []
+            num_samples[:] = []
+            user_data.clear()
diff --git a/easyfl/datasets/femnist/preprocess/get_file_dirs.py b/easyfl/datasets/femnist/preprocess/get_file_dirs.py
new file mode 100644
index 0000000..6b5cc53
--- /dev/null
+++ b/easyfl/datasets/femnist/preprocess/get_file_dirs.py
@@ -0,0 +1,71 @@
+"""
+These codes are adopted from LEAF with some modifications.
+
+Creates .pkl files for:
+1. list of directories of every image in 'by_class'
+2. list of directories of every image in 'by_write'
+the hierarchal structure of the data is as follows:
+- by_class -> classes -> folders containing images -> images
+- by_write -> folders containing writers -> writer -> types of images -> images
+the directories written into the files are of the form 'raw_data/...'
+"""
+
+import os
+
+from easyfl.datasets.utils import util
+
+
+def get_file_dir(base_folder):
+    class_files = []  # (class, file directory)
+    write_files = []  # (writer, file directory)
+
+    class_dir = os.path.join(base_folder, "raw_data", "by_class")
+    rel_class_dir = os.path.join(base_folder, "raw_data", "by_class")
+    classes = os.listdir(class_dir)
+    classes = [c for c in classes if len(c) == 2]
+
+    for cl in classes:
+        cldir = os.path.join(class_dir, cl)
+        rel_cldir = os.path.join(rel_class_dir, cl)
+        subcls = os.listdir(cldir)
+
+        subcls = [s for s in subcls if (("hsf" in s) and ("mit" not in s))]
+
+        for subcl in subcls:
+            subcldir = os.path.join(cldir, subcl)
+            rel_subcldir = os.path.join(rel_cldir, subcl)
+            images = os.listdir(subcldir)
+            image_dirs = [os.path.join(rel_subcldir, i) for i in images]
+
+            for image_dir in image_dirs:
+                class_files.append((cl, image_dir))
+
+    write_dir = os.path.join(base_folder, "raw_data", "by_write")
+    rel_write_dir = os.path.join(base_folder, "raw_data", "by_write")
+    write_parts = os.listdir(write_dir)
+
+    for write_part in write_parts:
+        writers_dir = os.path.join(write_dir, write_part)
+        rel_writers_dir = os.path.join(rel_write_dir, write_part)
+        writers = os.listdir(writers_dir)
+
+        for writer in writers:
+            writer_dir = os.path.join(writers_dir, writer)
+            rel_writer_dir = os.path.join(rel_writers_dir, writer)
+            wtypes = os.listdir(writer_dir)
+
+            for wtype in wtypes:
+                type_dir = os.path.join(writer_dir, wtype)
+                rel_type_dir = os.path.join(rel_writer_dir, wtype)
+                images = os.listdir(type_dir)
+                image_dirs = [os.path.join(rel_type_dir, i) for i in images]
+
+                for image_dir in image_dirs:
+                    write_files.append((writer, image_dir))
+
+    util.save_obj(
+        class_files,
+        os.path.join(base_folder, "intermediate", "class_file_dirs"))
+    util.save_obj(
+        write_files,
+        os.path.join(base_folder, "intermediate", "write_file_dirs"))
diff --git a/easyfl/datasets/femnist/preprocess/get_hashes.py b/easyfl/datasets/femnist/preprocess/get_hashes.py
new file mode 100644
index 0000000..cdb5b64
--- /dev/null
+++ b/easyfl/datasets/femnist/preprocess/get_hashes.py
@@ -0,0 +1,55 @@
+"""
+These codes are adopted from LEAF with some modifications.
+"""
+
+import hashlib
+import logging
+import os
+
+from easyfl.datasets.utils import util
+
+logger = logging.getLogger(__name__)
+
+
+def get_hash(base_folder):
+    cfd = os.path.join(base_folder, "intermediate", "class_file_dirs")
+    wfd = os.path.join(base_folder, "intermediate", "write_file_dirs")
+    class_file_dirs = util.load_obj(cfd)
+    write_file_dirs = util.load_obj(wfd)
+
+    class_file_hashes = []
+    write_file_hashes = []
+
+    count = 0
+    for tup in class_file_dirs:
+        if (count % 100000 == 0):
+            logger.info("hashed %d class images" % count)
+
+        (cclass, cfile) = tup
+        file_path = os.path.join(base_folder, cfile)
+
+        chash = hashlib.md5(open(file_path, "rb").read()).hexdigest()
+
+        class_file_hashes.append((cclass, cfile, chash))
+
+        count += 1
+
+    cfhd = os.path.join(base_folder, "intermediate", "class_file_hashes")
+    util.save_obj(class_file_hashes, cfhd)
+
+    count = 0
+    for tup in write_file_dirs:
+        if (count % 100000 == 0):
+            logger.info("hashed %d write images" % count)
+
+        (cclass, cfile) = tup
+        file_path = os.path.join(base_folder, cfile)
+
+        chash = hashlib.md5(open(file_path, "rb").read()).hexdigest()
+
+        write_file_hashes.append((cclass, cfile, chash))
+
+        count += 1
+
+    wfhd = os.path.join(base_folder, "intermediate", "write_file_hashes")
+    util.save_obj(write_file_hashes, wfhd)
diff --git a/easyfl/datasets/femnist/preprocess/group_by_writer.py b/easyfl/datasets/femnist/preprocess/group_by_writer.py
new file mode 100644
index 0000000..b58b3a3
--- /dev/null
+++ b/easyfl/datasets/femnist/preprocess/group_by_writer.py
@@ -0,0 +1,25 @@
+"""
+These codes are adopted from LEAF with some modifications.
+"""
+import os
+
+from easyfl.datasets.utils import util
+
+
+def group_by_writer(base_folder):
+    wwcd = os.path.join(base_folder, "intermediate", "write_with_class")
+    write_class = util.load_obj(wwcd)
+
+    writers = []  # each entry is a (writer, [list of (file, class)]) tuple
+    cimages = []
+    (cw, _, _) = write_class[0]
+    for (w, f, c) in write_class:
+        if w != cw:
+            writers.append((cw, cimages))
+            cw = w
+            cimages = [(f, c)]
+        cimages.append((f, c))
+    writers.append((cw, cimages))
+
+    ibwd = os.path.join(base_folder, "intermediate", "images_by_writer")
+    util.save_obj(writers, ibwd)
diff --git a/easyfl/datasets/femnist/preprocess/match_hashes.py b/easyfl/datasets/femnist/preprocess/match_hashes.py
new file mode 100644
index 0000000..1ad2501
--- /dev/null
+++ b/easyfl/datasets/femnist/preprocess/match_hashes.py
@@ -0,0 +1,25 @@
+"""
+These codes are adopted from LEAF with some modifications.
+"""
+import os
+
+from easyfl.datasets.utils import util
+
+
+def match_hash(base_folder):
+    cfhd = os.path.join(base_folder, "intermediate", "class_file_hashes")
+    wfhd = os.path.join(base_folder, "intermediate", "write_file_hashes")
+    class_file_hashes = util.load_obj(cfhd)
+    write_file_hashes = util.load_obj(wfhd)
+    class_hash_dict = {}
+    for i in range(len(class_file_hashes)):
+        (c, f, h) = class_file_hashes[len(class_file_hashes) - i - 1]
+        class_hash_dict[h] = (c, f)
+
+    write_classes = []
+    for tup in write_file_hashes:
+        (w, f, h) = tup
+        write_classes.append((w, f, class_hash_dict[h][0]))
+
+    wwcd = os.path.join(base_folder, "intermediate", "write_with_class")
+    util.save_obj(write_classes, wwcd)
diff --git a/easyfl/datasets/shakespeare/__init__.py b/easyfl/datasets/shakespeare/__init__.py
new file mode 100644
index 0000000..122c995
--- /dev/null
+++ b/easyfl/datasets/shakespeare/__init__.py
@@ -0,0 +1 @@
+from easyfl.datasets.shakespeare.shakespeare import Shakespeare
diff --git a/easyfl/datasets/shakespeare/shakespeare.py b/easyfl/datasets/shakespeare/shakespeare.py
new file mode 100644
index 0000000..1b6e1e0
--- /dev/null
+++ b/easyfl/datasets/shakespeare/shakespeare.py
@@ -0,0 +1,89 @@
+import logging
+import os
+
+from easyfl.datasets.shakespeare.utils.gen_all_data import generated_all_data
+from easyfl.datasets.shakespeare.utils.preprocess_shakespeare import shakespeare_preprocess
+from easyfl.datasets.utils.base_dataset import BaseDataset
+from easyfl.datasets.utils.download import download_url, extract_archive, download_from_google_drive
+
+logger = logging.getLogger(__name__)
+
+
+class Shakespeare(BaseDataset):
+    """Shakespeare dataset implementation. It gets Shakespeare dataset according to configurations.
+
+    Attributes:
+        base_folder (str): The base folder path of the datasets folder.
+        raw_data_url (str): The url to get the `by_class` split shakespeare.
+        write_url (str): The url to get the `by_write` split shakespeare.
+    """
+
+    def __init__(self,
+                 root,
+                 fraction,
+                 split_type,
+                 user,
+                 iid_user_fraction=0.1,
+                 train_test_split=0.9,
+                 minsample=10,
+                 num_class=80,
+                 num_of_client=100,
+                 class_per_client=2,
+                 setting_folder=None,
+                 seed=-1,
+                 **kwargs):
+        super(Shakespeare, self).__init__(root,
+                                          "shakespeare",
+                                          fraction,
+                                          split_type,
+                                          user,
+                                          iid_user_fraction,
+                                          train_test_split,
+                                          minsample,
+                                          num_class,
+                                          num_of_client,
+                                          class_per_client,
+                                          setting_folder,
+                                          seed)
+        self.raw_data_url = "http://www.gutenberg.org/files/100/old/1994-01-100.zip"
+        self.packaged_data_files = {
+            "shakespeare_niid_100_10_1_0.05_0.1_sample_0.9.zip": "https://dl.dropboxusercontent.com/s/5qr9ozziy3yfzss/shakespeare_niid_100_10_1_0.05_0.1_sample_0.9.zip",
+            "shakespeare_iid_100_10_1_0.05_0.1_sample_0.9.zip": "https://dl.dropboxusercontent.com/s/4p7osgjd2pecsi3/shakespeare_iid_100_10_1_0.05_0.1_sample_0.9.zip"
+        }
+        # Google drive ids.
+        # self.packaged_data_files = {
+        #     "shakespeare_niid_100_10_1_0.05_0.1_sample_0.9.zip": "1zvmNiUNu7r0h4t0jBhOJ204qyc61NvfJ",
+        #     "shakespeare_iid_100_10_1_0.05_0.1_sample_0.9.zip": "1Lb8n1zDtrj2DX_QkjNnL6DH5IrnYFdsR"
+        # }
+
+    def download_packaged_dataset_and_extract(self, filename):
+        file_path = download_url(self.packaged_data_files[filename], self.base_folder)
+        extract_archive(file_path, remove_finished=True)
+
+    def download_raw_file_and_extract(self):
+        raw_data_folder = os.path.join(self.base_folder, "raw_data")
+        if not os.path.exists(raw_data_folder):
+            os.makedirs(raw_data_folder)
+        elif os.listdir(raw_data_folder):
+            logger.info("raw file exists")
+            return
+        raw_data_path = download_url(self.raw_data_url, raw_data_folder)
+        extract_archive(raw_data_path, remove_finished=True)
+        os.rename(os.path.join(raw_data_folder, "100.txt"), os.path.join(raw_data_folder, "raw_data.txt"))
+        logger.info("raw file is downloaded")
+
+    def preprocess(self):
+        filename = os.path.join(self.base_folder, "raw_data", "raw_data.txt")
+        raw_data_folder = os.path.join(self.base_folder, "raw_data")
+        if not os.path.exists(raw_data_folder):
+            os.makedirs(raw_data_folder)
+        shakespeare_preprocess(filename, raw_data_folder)
+
+    def convert_data_to_json(self):
+        all_data_folder = os.path.join(self.base_folder, "all_data")
+        if not os.path.exists(all_data_folder):
+            os.makedirs(all_data_folder)
+        if not os.listdir(all_data_folder):
+            logger.info("converting data to .json format")
+            generated_all_data(self.base_folder)
+            logger.info("finished converting data to .json format")
diff --git a/easyfl/datasets/shakespeare/utils/__init__.py b/easyfl/datasets/shakespeare/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/datasets/shakespeare/utils/gen_all_data.py b/easyfl/datasets/shakespeare/utils/gen_all_data.py
new file mode 100644
index 0000000..842f41f
--- /dev/null
+++ b/easyfl/datasets/shakespeare/utils/gen_all_data.py
@@ -0,0 +1,17 @@
+"""
+These codes are adopted from LEAF with some modifications.
+"""
+
+import json
+import os
+
+from easyfl.datasets.shakespeare.utils.shake_utils import parse_data_in
+
+
+def generated_all_data(parent_path):
+    users_and_plays_path = os.path.join(parent_path, 'raw_data', 'users_and_plays.json')
+    txt_dir = os.path.join(parent_path, 'raw_data', 'by_play_and_character')
+    json_data = parse_data_in(txt_dir, users_and_plays_path)
+    json_path = os.path.join(parent_path, 'all_data', 'all_data.json')
+    with open(json_path, 'w') as outfile:
+        json.dump(json_data, outfile)
diff --git a/easyfl/datasets/shakespeare/utils/preprocess_shakespeare.py b/easyfl/datasets/shakespeare/utils/preprocess_shakespeare.py
new file mode 100644
index 0000000..e100615
--- /dev/null
+++ b/easyfl/datasets/shakespeare/utils/preprocess_shakespeare.py
@@ -0,0 +1,183 @@
+"""Preprocesses the Shakespeare dataset for federated training.
+These codes are adopted from LEAF with some modifications.
+"""
+
+import collections
+import json
+import os
+import re
+
+RANDOM_SEED = 1234
+# Regular expression to capture an actors name, and line continuation
+CHARACTER_RE = re.compile(r'^  ([a-zA-Z][a-zA-Z ]*)\. (.*)')
+CONT_RE = re.compile(r'^    (.*)')
+# The Comedy of Errors has errors in its indentation so we need to use
+# different regular expressions.
+COE_CHARACTER_RE = re.compile(r'^([a-zA-Z][a-zA-Z ]*)\. (.*)')
+COE_CONT_RE = re.compile(r'^(.*)')
+
+
+def _match_character_regex(line, comedy_of_errors=False):
+    return (COE_CHARACTER_RE.match(line) if comedy_of_errors
+            else CHARACTER_RE.match(line))
+
+
+def _match_continuation_regex(line, comedy_of_errors=False):
+    return (
+        COE_CONT_RE.match(line) if comedy_of_errors else CONT_RE.match(line))
+
+
+def _split_into_plays(shakespeare_full):
+    """Splits the full data by play."""
+    # List of tuples (play_name, dict from character to list of lines)
+    plays = []
+    discarded_lines = []  # Track discarded lines.
+    slines = shakespeare_full.splitlines(True)[1:]
+
+    # skip contents, the sonnets, and all's well that ends well
+    author_count = 0
+    start_i = 0
+    for i, l in enumerate(slines):
+        if 'by William Shakespeare' in l:
+            author_count += 1
+        if author_count == 2:
+            start_i = i - 5
+            break
+    slines = slines[start_i:]
+
+    current_character = None
+    comedy_of_errors = False
+    for i, line in enumerate(slines):
+        # This marks the end of the plays in the file.
+        if i > 124195 - start_i:
+            break
+        # This is a pretty good heuristic for detecting the start of a new play:
+        if 'by William Shakespeare' in line:
+            current_character = None
+            characters = collections.defaultdict(list)
+            # The title will be 2, 3, 4, 5, 6, or 7 lines above "by William Shakespeare".
+            if slines[i - 2].strip():
+                title = slines[i - 2]
+            elif slines[i - 3].strip():
+                title = slines[i - 3]
+            elif slines[i - 4].strip():
+                title = slines[i - 4]
+            elif slines[i - 5].strip():
+                title = slines[i - 5]
+            elif slines[i - 6].strip():
+                title = slines[i - 6]
+            else:
+                title = slines[i - 7]
+            title = title.strip()
+
+            assert title, ('Parsing error on line %d. Expecting title 2 or 3 lines above.' % i)
+            comedy_of_errors = (title == 'THE COMEDY OF ERRORS')
+            # Degenerate plays are removed at the end of the method.
+            plays.append((title, characters))
+            continue
+        match = _match_character_regex(line, comedy_of_errors)
+        if match:
+            character, snippet = match.group(1), match.group(2)
+            # Some character names are written with multiple casings, e.g., SIR_Toby
+            # and SIR_TOBY. To normalize the character names, we uppercase each name.
+            # Note that this was not done in the original preprocessing and is a
+            # recent fix.
+            character = character.upper()
+            if not (comedy_of_errors and character.startswith('ACT ')):
+                characters[character].append(snippet)
+                current_character = character
+                continue
+            else:
+                current_character = None
+                continue
+        elif current_character:
+            match = _match_continuation_regex(line, comedy_of_errors)
+            if match:
+                if comedy_of_errors and match.group(1).startswith('<'):
+                    current_character = None
+                    continue
+                else:
+                    characters[current_character].append(match.group(1))
+                    continue
+        # Didn't consume the line.
+        line = line.strip()
+        if line and i > 2646:
+            # Before 2646 are the sonnets, which we expect to discard.
+            discarded_lines.append('%d:%s' % (i, line))
+    # Remove degenerate "plays".
+    return [play for play in plays if len(play[1]) > 1], discarded_lines
+
+
+def _remove_nonalphanumerics(filename):
+    return re.sub('\\W+', '_', filename)
+
+
+def play_and_character(play, character):
+    return _remove_nonalphanumerics((play + '_' + character).replace(' ', '_'))
+
+
+def _get_train_test_by_character(plays, test_fraction=0.2):
+    """
+      Splits character data into train and test sets.
+      if test_fraction <= 0, returns {} for all_test_examples
+      plays := list of (play, dict) tuples where play is a string and dict
+      is a dictionary with character names as keys
+    """
+    skipped_characters = 0
+    all_train_examples = collections.defaultdict(list)
+    all_test_examples = collections.defaultdict(list)
+
+    def add_examples(example_dict, example_tuple_list):
+        for play, character, sound_bite in example_tuple_list:
+            example_dict[play_and_character(
+                play, character)].append(sound_bite)
+
+    users_and_plays = {}
+    for play, characters in plays:
+        curr_characters = list(characters.keys())
+        for c in curr_characters:
+            users_and_plays[play_and_character(play, c)] = play
+        for character, sound_bites in characters.items():
+            examples = [(play, character, sound_bite)
+                        for sound_bite in sound_bites]
+            if len(examples) <= 2:
+                skipped_characters += 1
+                # Skip characters with fewer than 2 lines since we need at least one
+                # train and one test line.
+                continue
+            train_examples = examples
+            if test_fraction > 0:
+                num_test = max(int(len(examples) * test_fraction), 1)
+                train_examples = examples[:-num_test]
+                test_examples = examples[-num_test:]
+                assert len(test_examples) == num_test
+                assert len(train_examples) >= len(test_examples)
+                add_examples(all_test_examples, test_examples)
+            add_examples(all_train_examples, train_examples)
+    return users_and_plays, all_train_examples, all_test_examples
+
+
+def _write_data_by_character(examples, output_directory):
+    """Writes a collection of data files by play & character."""
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+    for character_name, sound_bites in examples.items():
+        filename = os.path.join(output_directory, character_name + '.txt')
+        with open(filename, 'w') as output:
+            for sound_bite in sound_bites:
+                output.write(sound_bite + '\n')
+
+
+def shakespeare_preprocess(input_filename, output_directory):
+    print('Splitting .txt data between users')
+    input_filename = input_filename
+    with open(input_filename, 'r') as input_file:
+        shakespeare_full = input_file.read()
+    plays, discarded_lines = _split_into_plays(shakespeare_full)
+    print('Discarded %d lines' % len(discarded_lines))
+    users_and_plays, all_examples, _ = _get_train_test_by_character(plays, test_fraction=-1.0)
+    with open(os.path.join(output_directory, 'users_and_plays.json'), 'w') as ouf:
+        json.dump(users_and_plays, ouf)
+    _write_data_by_character(all_examples,
+                             os.path.join(output_directory,
+                                          'by_play_and_character/'))
diff --git a/easyfl/datasets/shakespeare/utils/shake_utils.py b/easyfl/datasets/shakespeare/utils/shake_utils.py
new file mode 100644
index 0000000..59b3004
--- /dev/null
+++ b/easyfl/datasets/shakespeare/utils/shake_utils.py
@@ -0,0 +1,69 @@
+"""
+Helper functions for preprocessing shakespeare data.
+
+These codes are adopted from LEAF with some modifications.
+"""
+import json
+import os
+import re
+
+
+def __txt_to_data(txt_dir, seq_length=80):
+    """Parses text file in given directory into data for next-character model.
+
+    Args:
+        txt_dir: path to text file
+        seq_length: length of strings in X
+    """
+    raw_text = ""
+    with open(txt_dir, 'r') as inf:
+        raw_text = inf.read()
+    raw_text = raw_text.replace('\n', ' ')
+    raw_text = re.sub(r"   *", r' ', raw_text)
+    dataX = []
+    dataY = []
+    for i in range(0, len(raw_text) - seq_length, 1):
+        seq_in = raw_text[i:i + seq_length]
+        seq_out = raw_text[i + seq_length]
+        dataX.append(seq_in)
+        dataY.append(seq_out)
+    return dataX, dataY
+
+
+def parse_data_in(data_dir, users_and_plays_path, raw=False):
+    """
+    returns dictionary with keys: users, num_samples, user_data
+    raw := bool representing whether to include raw text in all_data
+    if raw is True, then user_data key
+    removes users with no data
+    """
+    with open(users_and_plays_path, 'r') as inf:
+        users_and_plays = json.load(inf)
+    files = os.listdir(data_dir)
+    users = []
+    hierarchies = []
+    num_samples = []
+    user_data = {}
+    for f in files:
+        user = f[:-4]
+        passage = ''
+        filename = os.path.join(data_dir, f)
+        with open(filename, 'r') as inf:
+            passage = inf.read()
+        dataX, dataY = __txt_to_data(filename)
+        if (len(dataX) > 0):
+            users.append(user)
+            if raw:
+                user_data[user] = {'raw': passage}
+            else:
+                user_data[user] = {}
+            user_data[user]['x'] = dataX
+            user_data[user]['y'] = dataY
+            hierarchies.append(users_and_plays[user])
+            num_samples.append(len(dataY))
+    all_data = {}
+    all_data['users'] = users
+    all_data['hierarchies'] = hierarchies
+    all_data['num_samples'] = num_samples
+    all_data['user_data'] = user_data
+    return all_data
diff --git a/easyfl/datasets/simulation.py b/easyfl/datasets/simulation.py
new file mode 100644
index 0000000..0f69e07
--- /dev/null
+++ b/easyfl/datasets/simulation.py
@@ -0,0 +1,350 @@
+import heapq
+import logging
+import math
+
+import numpy as np
+
+SIMULATE_IID = "iid"
+SIMULATE_NIID_DIR = "dir"
+SIMULATE_NIID_CLASS = "class"
+
+logger = logging.getLogger(__name__)
+
+
+def shuffle(data_x, data_y):
+    num_of_data = len(data_y)
+    data_x = np.array(data_x)
+    data_y = np.array(data_y)
+    index = [i for i in range(num_of_data)]
+    np.random.shuffle(index)
+    data_x = data_x[index]
+    data_y = data_y[index]
+    return data_x, data_y
+
+
+def equal_division(num_groups, data_x, data_y=None):
+    """Partition data into multiple clients with equal quantity.
+
+    Args:
+        num_groups (int): THe number of groups to partition to.
+        data_x (list[Object]): A list of elements to be divided.
+        data_y (list[Object], optional): A list of data labels to be divided together with the data.
+
+    Returns:
+        list[list]: A list where each element is a list of data of a group/client.
+        list[list]: A list where each element is a list of data label of a group/client.
+
+    Example:
+        >>> equal_division(3, list[range(9)])
+        >>> ([[0,4,2],[3,1,7],[6,5,8]], [])
+    """
+    if data_y is not None:
+        assert (len(data_x) == len(data_y))
+        data_x, data_y = shuffle(data_x, data_y)
+    else:
+        np.random.shuffle(data_x)
+    num_of_data = len(data_x)
+    assert num_of_data > 0
+    data_per_client = num_of_data // num_groups
+    large_group_num = num_of_data - num_groups * data_per_client
+    small_group_num = num_groups - large_group_num
+    splitted_data_x = []
+    splitted_data_y = []
+    for i in range(small_group_num):
+        base_index = data_per_client * i
+        splitted_data_x.append(data_x[base_index: base_index + data_per_client])
+        if data_y is not None:
+            splitted_data_y.append(data_y[base_index: base_index + data_per_client])
+    small_size = data_per_client * small_group_num
+    data_per_client += 1
+    for i in range(large_group_num):
+        base_index = small_size + data_per_client * i
+        splitted_data_x.append(data_x[base_index: base_index + data_per_client])
+        if data_y is not None:
+            splitted_data_y.append(data_y[base_index: base_index + data_per_client])
+
+    return splitted_data_x, splitted_data_y
+
+
+def quantity_hetero(weights, data_x, data_y=None):
+    """Partition data into multiple clients with different quantities.
+    The number of groups is the same as the number of elements of `weights`.
+    The quantity of each group depends on the values of `weights`.
+
+    Args:
+        weights (list[float]): The targeted distribution of data quantities.
+            The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+        data_x (list[Object]): A list of elements to be divided.
+        data_y (list[Object], optional): A list of data labels to be divided together with the data.
+
+    Returns:
+        list[list]: A list where each element is a list of data of a group/client.
+        list[list]: A list where each element is a list of data label of a group/client.
+        
+    Example:
+        >>> quantity_hetero([0.1, 0.2, 0.7], list(range(0, 10)))
+        >>> ([[4], [8, 9], [6, 0, 1, 7, 3, 2, 5]], [])
+    """
+    # This is due to the float number in python,
+    # e.g.sum([0.1,0.2,0.4,0.2,0.1]) is not exactly 1, but 1.0000000000000002.
+    assert (round(sum(weights), 3) == 1)
+
+    if data_y is not None:
+        assert (len(data_x) == len(data_y))
+        data_x, data_y = shuffle(data_x, data_y)
+    else:
+        np.random.shuffle(data_x)
+    data_size = len(data_x)
+
+    i = 0
+
+    splitted_data_x = []
+    splitted_data_y = []
+    for w in weights:
+        size = math.floor(data_size * w)
+        splitted_data_x.append(data_x[i:i + size])
+        if data_y is not None:
+            splitted_data_y.append(data_y[i:i + size])
+        i += size
+
+    parts = len(weights)
+    if i < data_size:
+        remain = data_size - i
+        for i in range(-remain, 0, 1):
+            splitted_data_x[(-i) % parts].append(data_x[i])
+            if data_y is not None:
+                splitted_data_y[(-i) % parts].append(data_y[i])
+
+    return splitted_data_x, splitted_data_y
+
+
+def iid(data_x, data_y, num_of_clients, x_dtype, y_dtype):
+    """Partition dataset into multiple clients with equal data quantity (difference is less than 1) randomly.
+
+    Args:
+        data_x (list[Object]): A list of data.
+        data_y (list[Object]): A list of dataset labels.
+        num_of_clients (int): The number of clients to partition to.
+        x_dtype (numpy.dtype): The type of data.
+        y_dtype (numpy.dtype): The type of data label.
+
+    Returns:
+        list[str]: A list of client ids.
+        dict: The partitioned data, key is client id, value is the client data. e.g., {'client_1': {'x': [data_x], 'y': [data_y]}}.
+    """
+    data_x, data_y = shuffle(data_x, data_y)
+    x_divided_list, y_divided_list = equal_division(num_of_clients, data_x, data_y)
+    clients = []
+    federated_data = {}
+    for i in range(num_of_clients):
+        client_id = "f%07.0f" % (i)
+        temp_client = {}
+        temp_client['x'] = np.array(x_divided_list[i]).astype(x_dtype)
+        temp_client['y'] = np.array(y_divided_list[i]).astype(y_dtype)
+        federated_data[client_id] = temp_client
+        clients.append(client_id)
+    return clients, federated_data
+
+
+def non_iid_dirichlet(data_x, data_y, num_of_clients, alpha, min_size, x_dtype, y_dtype):
+    """Partition dataset into multiple clients following the Dirichlet process.
+
+    Args:
+        data_x (list[Object]): A list of data.
+        data_y (list[Object]): A list of dataset labels.
+        num_of_clients (int): The number of clients to partition to.
+        alpha (float): The parameter for Dirichlet process simulation.
+        min_size (int): The minimum number of data size of a client.
+        x_dtype (numpy.dtype): The type of data.
+        y_dtype (numpy.dtype): The type of data label.
+
+    Returns:
+        list[str]: A list of client ids.
+        dict: The partitioned data, key is client id, value is the client data. e.g., {'client_1': {'x': [data_x], 'y': [data_y]}}.
+    """
+    n_train = data_x.shape[0]
+    current_min_size = 0
+    num_class = np.amax(data_y) + 1
+    data_size = data_y.shape[0]
+    net_dataidx_map = {}
+
+    while current_min_size < min_size:
+        idx_batch = [[] for _ in range(num_of_clients)]
+        for k in range(num_class):
+            idx_k = np.where(data_y == k)[0]
+            np.random.shuffle(idx_k)
+            proportions = np.random.dirichlet(np.repeat(alpha, num_of_clients))
+            # using the proportions from dirichlet, only selet those clients having data amount less than average
+            proportions = np.array(
+                [p * (len(idx_j) < data_size / num_of_clients) for p, idx_j in zip(proportions, idx_batch)])
+            # scale proportions
+            proportions = proportions / proportions.sum()
+            proportions = (np.cumsum(proportions) * len(idx_k)).astype(int)[:-1]
+            idx_batch = [idx_j + idx.tolist() for idx_j, idx in zip(idx_batch, np.split(idx_k, proportions))]
+            current_min_size = min([len(idx_j) for idx_j in idx_batch])
+
+    federated_data = {}
+    clients = []
+    for j in range(num_of_clients):
+        np.random.shuffle(idx_batch[j])
+        client_id = "f%07.0f" % j
+        clients.append(client_id)
+        temp = {}
+        temp['x'] = np.array(data_x[idx_batch[j]]).astype(x_dtype)
+        temp['y'] = np.array(data_y[idx_batch[j]]).astype(y_dtype)
+        federated_data[client_id] = temp
+        net_dataidx_map[client_id] = idx_batch[j]
+    print_data_distribution(data_y, net_dataidx_map)
+    return clients, federated_data
+
+
+def non_iid_class(data_x, data_y, class_per_client, num_of_clients, x_dtype, y_dtype, stack_x=True):
+    """Partition dataset into multiple clients based on label classes.
+    Each client contains [1, n] classes, where n is the number of classes of a dataset.
+
+    Note: Each class is divided into `ceil(class_per_client * num_of_clients / num_class)` parts
+        and each client chooses `class_per_client` parts from each class to construct its dataset.
+
+    Args:
+        data_x (list[Object]): A list of data.
+        data_y (list[Object]): A list of dataset labels.
+        class_per_client (int): The number of classes in each client.
+        num_of_clients (int): The number of clients to partition to.
+        x_dtype (numpy.dtype): The type of data.
+        y_dtype (numpy.dtype): The type of data label.
+        stack_x (bool, optional): A flag to indicate whether using np.vstack or append to construct dataset.
+
+    Returns:
+        list[str]: A list of client ids.
+        dict: The partitioned data, key is client id, value is the client data. e.g., {'client_1': {'x': [data_x], 'y': [data_y]}}.
+    """
+    num_class = np.amax(data_y) + 1
+    all_index = []
+    clients = []
+    data_index_map = {}
+    for i in range(num_class):
+        # get indexes for all data with current label i at index i in all_index
+        all_index.append(np.where(data_y == i)[0].tolist())
+
+    federated_data = {}
+
+    # total no. of parts
+    total_amount = class_per_client * num_of_clients
+    # no. of parts each class should be diveded into
+    parts_per_class = math.ceil(total_amount / num_class)
+
+    for i in range(num_of_clients):
+        client_id = "f%07.0f" % (i)
+        clients.append(client_id)
+        data_index_map[client_id] = []
+        data = {}
+        data['x'] = np.array([])
+        data['y'] = np.array([])
+        federated_data[client_id] = data
+
+    class_map = {}
+    parts_consumed = []
+    for i in range(num_class):
+        class_map[i], _ = equal_division(parts_per_class, all_index[i])
+        heapq.heappush(parts_consumed, (0, i))
+    for i in clients:
+        for j in range(class_per_client):
+            class_chosen = heapq.heappop(parts_consumed)
+            part_indexes = class_map[class_chosen[1]].pop(0)
+            if len(federated_data[i]['x']) != 0:
+                if stack_x:
+                    federated_data[i]['x'] = np.vstack((federated_data[i]['x'], data_x[part_indexes])).astype(x_dtype)
+                else:
+                    federated_data[i]['x'] = np.append(federated_data[i]['x'], data_x[part_indexes]).astype(x_dtype)
+                federated_data[i]['y'] = np.append(federated_data[i]['y'], data_y[part_indexes]).astype(y_dtype)
+            else:
+                federated_data[i]['x'] = data_x[part_indexes].astype(x_dtype)
+                federated_data[i]['y'] = data_y[part_indexes].astype(y_dtype)
+            heapq.heappush(parts_consumed, (class_chosen[0] + 1, class_chosen[1]))
+            data_index_map[i].extend(part_indexes)
+    print_data_distribution(data_y, data_index_map)
+    return clients, federated_data
+
+
+def data_simulation(data_x, data_y, num_of_clients, data_distribution, weights=None, alpha=0.5, min_size=10,
+                    class_per_client=1, stack_x=True):
+    """Simulate federated learning datasets by partitioning a data into multiple clients using different strategies.
+
+    Args:
+        data_x (list[Object]): A list of data.
+        data_y (list[Object]): A list of dataset labels.
+        num_of_clients (int): The number of clients to partition to.
+        data_distribution (str): The ways to partition the dataset, options:
+            `iid`: Partition dataset into multiple clients with equal quantity (difference is less than 1) randomly.
+            `dir`: partition dataset into multiple clients following the Dirichlet process.
+            `class`: partition dataset into multiple clients based on classes.
+        weights: list, for simulating data quantity heterogeneity
+            If None, each client are simulated with same data quantity
+            Note: num_of_clients should be divisible by len(weights)
+        weights (list[float], optional): The targeted distribution of data quantities.
+            The values should sum up to 1. e.g., [0.1, 0.2, 0.7].
+            When `weights=None`, the data quantity of clients only depends on data_distribution.
+        alpha (float, optional): The parameter for Dirichlet process simulation.
+            It is only applicable when data_distribution is `dir`.
+        min_size (int, optional): The minimum number of data size of a client.
+            It is only applicable when data_distribution is `dir`.
+        class_per_client (int): The number of classes in each client.
+            It is only applicable when data_distribution is `class`.
+        stack_x (bool, optional): A flag to indicate whether using np.vstack or append to construct dataset.
+            It is only applicable when data_distribution is `class`.
+
+    Raise:
+        ValueError: When the simulation method `data_distribution` is not supported.
+
+    Returns:
+        list[str]: A list of client ids.
+        dict: The partitioned data, key is client id, value is the client data. e.g., {'client_1': {'x': [data_x], 'y': [data_y]}}.
+    """
+    data_x = np.array(data_x)
+    data_y = np.array(data_y)
+    x_dtype = data_x.dtype
+    y_dtype = data_y.dtype
+    if weights is not None:
+        assert num_of_clients % len(weights) == 0
+        num_of_clients = num_of_clients // len(weights)
+
+    if data_distribution == SIMULATE_IID:
+        group_client_list, group_federated_data = iid(data_x, data_y, num_of_clients, x_dtype, y_dtype)
+    elif data_distribution == SIMULATE_NIID_DIR:
+        group_client_list, group_federated_data = non_iid_dirichlet(data_x, data_y, num_of_clients, alpha, min_size,
+                                                                    x_dtype, y_dtype)
+    elif data_distribution == SIMULATE_NIID_CLASS:
+        group_client_list, group_federated_data = non_iid_class(data_x, data_y, class_per_client, num_of_clients,
+                                                                x_dtype,
+                                                                y_dtype, stack_x=stack_x)
+    else:
+        raise ValueError("Simulation type not supported")
+    if weights is None:
+        return group_client_list, group_federated_data
+
+    clients = []
+    federated_data = {}
+    cur_key = 0
+    for i in group_client_list:
+        current_client = group_federated_data[i]
+        input_lists, label_lists = quantity_hetero(weights, current_client['x'], current_client['y'])
+        for j in range(len(input_lists)):
+            client_id = "f%07.0f" % (cur_key)
+            temp_client = {}
+            temp_client['x'] = np.array(input_lists[j]).astype(x_dtype)
+            temp_client['y'] = np.array(label_lists[j]).astype(y_dtype)
+            federated_data[client_id] = temp_client
+            clients.append(client_id)
+            cur_key += 1
+    return clients, federated_data
+
+
+def print_data_distribution(data_y, data_index_map):
+    """Log the distribution of client datasets."""
+    data_distribution = {}
+    for index, dataidx in data_index_map.items():
+        unique_values, counts = np.unique(data_y[dataidx], return_counts=True)
+        distribution = {unique_values[i]: counts[i] for i in range(len(unique_values))}
+        data_distribution[index] = distribution
+    logger.info(data_distribution)
+    return data_distribution
diff --git a/easyfl/datasets/utils/__init__.py b/easyfl/datasets/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/datasets/utils/base_dataset.py b/easyfl/datasets/utils/base_dataset.py
new file mode 100644
index 0000000..b105f12
--- /dev/null
+++ b/easyfl/datasets/utils/base_dataset.py
@@ -0,0 +1,158 @@
+import logging
+import os
+from abc import abstractmethod
+
+from easyfl.datasets.utils.remove_users import remove
+from easyfl.datasets.utils.sample import sample, extreme
+from easyfl.datasets.utils.split_data import split_train_test
+
+logger = logging.getLogger(__name__)
+
+CIFAR10 = "cifar10"
+CIFAR100 = "cifar100"
+
+
+class BaseDataset(object):
+    """The internal base dataset implementation.
+
+    Args:
+        root (str): The root directory where datasets stored.
+        dataset_name (str): The name of the dataset.
+        fraction (float): The fraction of the data chosen from the raw data to use.
+        num_of_clients (int): The targeted number of clients to construct.
+        split_type (str): The type of statistical simulation, options: iid, dir, and class.
+            `iid` means independent and identically distributed data.
+            `niid` means non-independent and identically distributed data for Femnist and Shakespeare.
+            `dir` means using Dirichlet process to simulate non-iid data, for CIFAR-10 and CIFAR-100 datasets.
+            `class` means partitioning the dataset by label classes, for datasets like CIFAR-10, CIFAR-100.
+        minsample (int): The minimal number of samples in each client.
+            It is applicable for LEAF datasets and dir simulation of CIFAR-10 and CIFAR-100.
+        class_per_client (int): The number of classes in each client. Only applicable when the split_type is 'class'.
+        iid_user_fraction (float): The fraction of the number of clients used when the split_type is 'iid'.
+        user (bool): A flag to indicate whether partition users of the dataset into train-test groups.
+            Only applicable to LEAF datasets.
+            True means partitioning users of the dataset into train-test groups.
+            False means partitioning each users' samples into train-test groups.
+        train_test_split (float): The fraction of data for training; the rest are for testing.
+            e.g., 0.9 means 90% of data are used for training and 10% are used for testing.
+        num_class: The number of classes in this dataset.
+        seed: Random seed.
+    """
+
+    def __init__(self,
+                 root,
+                 dataset_name,
+                 fraction,
+                 split_type,
+                 user,
+                 iid_user_fraction,
+                 train_test_split,
+                 minsample,
+                 num_class,
+                 num_of_client,
+                 class_per_client,
+                 setting_folder,
+                 seed=-1,
+                 **kwargs):
+        # file_path = os.path.dirname(os.path.realpath(__file__))
+        # self.base_folder = os.path.join(os.path.dirname(file_path), "data", dataset_name)
+        self.base_folder = root
+        self.dataset_name = dataset_name
+        self.fraction = fraction
+        self.split_type = split_type  # iid, niid, class
+        self.user = user
+        self.iid_user_fraction = iid_user_fraction
+        self.train_test_split = train_test_split
+        self.minsample = minsample
+        self.num_class = num_class
+        self.num_of_client = num_of_client
+        self.class_per_client = class_per_client
+        self.seed = seed
+        if split_type == "iid":
+            assert self.user == False
+            self.iid = True
+        elif split_type == "niid":
+            # if niid, user can be either True or False
+            self.iid = False
+
+        self.setting_folder = setting_folder
+        self.data_folder = os.path.join(self.base_folder, self.setting_folder)
+
+    @abstractmethod
+    def download_packaged_dataset_and_extract(self, filename):
+        raise NotImplementedError("download_packaged_dataset_and_extract not implemented")
+
+    @abstractmethod
+    def download_raw_file_and_extract(self):
+        raise NotImplementedError("download_raw_file_and_extract not implemented")
+
+    @abstractmethod
+    def preprocess(self):
+        raise NotImplementedError("preprocess not implemented")
+
+    @abstractmethod
+    def convert_data_to_json(self):
+        raise NotImplementedError("convert_data_to_json not implemented")
+
+    @staticmethod
+    def get_setting_folder(dataset, split_type, num_of_client, min_size, class_per_client,
+                           fraction, iid_fraction, user_str, train_test_split, alpha=None, weights=None):
+        if dataset == CIFAR10 or dataset == CIFAR100:
+            return "{}_{}_{}_{}_{}_{}_{}".format(dataset, split_type, num_of_client, min_size, class_per_client, alpha,
+                                                 1 if weights else 0)
+        else:
+            return "{}_{}_{}_{}_{}_{}_{}_{}_{}".format(dataset, split_type, num_of_client, min_size, class_per_client,
+                                                       fraction, iid_fraction, user_str, train_test_split)
+
+    def setup(self):
+        self.download_raw_file_and_extract()
+        self.preprocess()
+        self.convert_data_to_json()
+
+    def sample_customized(self):
+        meta_folder = os.path.join(self.base_folder, "meta")
+        if not os.path.exists(meta_folder):
+            os.makedirs(meta_folder)
+        sample_folder = os.path.join(self.data_folder, "sampled_data")
+        if not os.path.exists(sample_folder):
+            os.makedirs(sample_folder)
+        if not os.listdir(sample_folder):
+            sample(self.base_folder, self.data_folder, meta_folder, self.fraction, self.iid, self.iid_user_fraction, self.seed)
+
+    def sample_extreme(self):
+        meta_folder = os.path.join(self.base_folder, "meta")
+        if not os.path.exists(meta_folder):
+            os.makedirs(meta_folder)
+        sample_folder = os.path.join(self.data_folder, "sampled_data")
+        if not os.path.exists(sample_folder):
+            os.makedirs(sample_folder)
+        if not os.listdir(sample_folder):
+            extreme(self.base_folder, self.data_folder, meta_folder, self.fraction, self.num_class, self.num_of_client, self.class_per_client, self.seed)
+
+    def remove_unqualified_user(self):
+        rm_folder = os.path.join(self.data_folder, "rem_user_data")
+        if not os.path.exists(rm_folder):
+            os.makedirs(rm_folder)
+        if not os.listdir(rm_folder):
+            remove(self.data_folder, self.dataset_name, self.minsample)
+
+    def split_train_test_set(self):
+        meta_folder = os.path.join(self.base_folder, "meta")
+        train = os.path.join(self.data_folder, "train")
+        if not os.path.exists(train):
+            os.makedirs(train)
+        test = os.path.join(self.data_folder, "test")
+        if not os.path.exists(test):
+            os.makedirs(test)
+        if not os.listdir(train) and not os.listdir(test):
+            split_train_test(self.data_folder, meta_folder, self.dataset_name, self.user, self.train_test_split, self.seed)
+
+    def sampling(self):
+        if self.split_type == "iid":
+            self.sample_customized()
+        elif self.split_type == "niid":
+            self.sample_customized()
+        elif self.split_type == "class":
+            self.sample_extreme()
+        self.remove_unqualified_user()
+        self.split_train_test_set()
diff --git a/easyfl/datasets/utils/constants.py b/easyfl/datasets/utils/constants.py
new file mode 100644
index 0000000..baef471
--- /dev/null
+++ b/easyfl/datasets/utils/constants.py
@@ -0,0 +1,2 @@
+DATASETS = ['sent140', 'femnist', 'shakespeare', 'celeba', 'synthetic']
+SEED_FILES = {'sampling': 'sampling_seed.txt', 'split': 'split_seed.txt'}
diff --git a/easyfl/datasets/utils/download.py b/easyfl/datasets/utils/download.py
new file mode 100644
index 0000000..7dc11ae
--- /dev/null
+++ b/easyfl/datasets/utils/download.py
@@ -0,0 +1,176 @@
+"""
+These codes are adopted from torchvison with some modifications.
+"""
+import gzip
+import hashlib
+import logging
+import os
+import tarfile
+import zipfile
+
+import requests
+from tqdm import tqdm
+
+logger = logging.getLogger(__name__)
+
+
+def gen_bar_updater():
+    pbar = tqdm(total=None)
+
+    def bar_update(count, block_size, total_size):
+        if pbar.total is None and total_size:
+            pbar.total = total_size
+        progress_bytes = count * block_size
+        pbar.update(progress_bytes - pbar.n)
+
+    return bar_update
+
+
+def calculate_md5(fpath, chunk_size=1024 * 1024):
+    md5 = hashlib.md5()
+    with open(fpath, 'rb') as f:
+        for chunk in iter(lambda: f.read(chunk_size), b''):
+            md5.update(chunk)
+    return md5.hexdigest()
+
+
+def check_md5(fpath, md5, **kwargs):
+    return md5 == calculate_md5(fpath, **kwargs)
+
+
+def check_integrity(fpath, md5=None):
+    if not os.path.isfile(fpath):
+        return False
+    if md5 is None:
+        return True
+    return check_md5(fpath, md5)
+
+
+def download_url(url, root, filename=None, md5=None):
+    """Download a file from a url and place it in root.
+    Args:
+        url (str): URL to download file from
+        root (str): Directory to place downloaded file in
+        filename (str, optional): Name to save the file under. If None, use the basename of the URL
+    """
+    import urllib.request
+    import urllib.error
+
+    root = os.path.expanduser(root)
+    if not filename:
+        filename = os.path.basename(url)
+    fpath = os.path.join(root, filename)
+
+    os.makedirs(root, exist_ok=True)
+
+    # check if file is already present locally
+    if check_integrity(fpath, md5):
+        logger.info("Using downloaded and verified file: " + fpath)
+        return fpath
+    else:  # download the file
+        try:
+            logger.info("Downloading {} to {}".format(url, fpath))
+            urllib.request.urlretrieve(
+                url, fpath,
+                reporthook=gen_bar_updater()
+            )
+        except (urllib.error.URLError, IOError) as e:
+            if url[:5] != 'https':
+                raise e
+            url = url.replace('https:', 'http:')
+            logger.info("Failed download. Trying https -> http instead."
+                        "Downloading {} to {}".format(url, fpath))
+            urllib.request.urlretrieve(
+                url, fpath,
+                reporthook=gen_bar_updater()
+            )
+
+        # check integrity of downloaded file
+        if not check_integrity(fpath, md5):
+            raise RuntimeError("File not found or corrupted.")
+    return fpath
+
+
+def download_from_google_drive(id, destination):
+    # taken from this StackOverflow answer: https://stackoverflow.com/a/39225039
+    URL = "https://docs.google.com/uc?export=download"
+
+    session = requests.Session()
+
+    response = session.get(URL, params={'id': id}, stream=True)
+    token = get_confirm_token(response)
+
+    if token:
+        params = {'id': id, 'confirm': token}
+        response = session.get(URL, params=params, stream=True)
+    else:
+        raise FileNotFoundError("Google drive file id does not exist")
+    save_response_content(response, destination)
+
+
+def get_confirm_token(response):
+    for key, value in response.cookies.items():
+        if key.startswith('download_warning'):
+            return value
+
+    return None
+
+
+def save_response_content(response, destination):
+    CHUNK_SIZE = 32768
+
+    with open(destination, "wb") as f:
+        for chunk in response.iter_content(CHUNK_SIZE):
+            if chunk:  # filter out keep-alive new chunks
+                f.write(chunk)
+
+
+def _is_tarxz(filename):
+    return filename.endswith(".tar.xz")
+
+
+def _is_tar(filename):
+    return filename.endswith(".tar")
+
+
+def _is_targz(filename):
+    return filename.endswith(".tar.gz")
+
+
+def _is_tgz(filename):
+    return filename.endswith(".tgz")
+
+
+def _is_gzip(filename):
+    return filename.endswith(".gz") and not filename.endswith(".tar.gz")
+
+
+def _is_zip(filename):
+    return filename.endswith(".zip")
+
+
+def extract_archive(from_path, to_path=None, remove_finished=False):
+    if to_path is None:
+        to_path = os.path.dirname(from_path)
+
+    if _is_tar(from_path):
+        with tarfile.open(from_path, 'r') as tar:
+            tar.extractall(path=to_path)
+    elif _is_targz(from_path) or _is_tgz(from_path):
+        with tarfile.open(from_path, 'r:gz') as tar:
+            tar.extractall(path=to_path)
+    elif _is_tarxz(from_path):
+        with tarfile.open(from_path, 'r:xz') as tar:
+            tar.extractall(path=to_path)
+    elif _is_gzip(from_path):
+        to_path = os.path.join(to_path, os.path.splitext(os.path.basename(from_path))[0])
+        with open(to_path, "wb") as out_f, gzip.GzipFile(from_path) as zip_f:
+            out_f.write(zip_f.read())
+    elif _is_zip(from_path):
+        with zipfile.ZipFile(from_path, 'r') as z:
+            z.extractall(to_path)
+    else:
+        raise ValueError("file format not supported")
+
+    if remove_finished:
+        os.remove(from_path)
diff --git a/easyfl/datasets/utils/remove_users.py b/easyfl/datasets/utils/remove_users.py
new file mode 100644
index 0000000..1841ef2
--- /dev/null
+++ b/easyfl/datasets/utils/remove_users.py
@@ -0,0 +1,62 @@
+"""
+Removes users with less than the given number of samples.
+
+These codes are adopted from LEAF with some modifications.
+"""
+
+import json
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def remove(setting_folder, dataset, min_samples):
+    parent_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    dir = os.path.join(parent_path, dataset, "data")
+    subdir = os.path.join(dir, setting_folder, "sampled_data")
+    files = []
+    if os.path.exists(subdir):
+        files = os.listdir(subdir)
+    if len(files) == 0:
+        subdir = os.path.join(dir, "all_data")
+        files = os.listdir(subdir)
+    files = [f for f in files if f.endswith(".json")]
+
+    for f in files:
+        users = []
+        hierarchies = []
+        num_samples = []
+        user_data = {}
+
+        file_dir = os.path.join(subdir, f)
+        with open(file_dir, "r") as inf:
+            data = json.load(inf)
+
+        num_users = len(data["users"])
+        for i in range(num_users):
+            curr_user = data["users"][i]
+            curr_hierarchy = None
+            if "hierarchies" in data:
+                curr_hierarchy = data["hierarchies"][i]
+            curr_num_samples = data["num_samples"][i]
+            if (curr_num_samples >= min_samples):
+                user_data[curr_user] = data["user_data"][curr_user]
+                users.append(curr_user)
+                if curr_hierarchy is not None:
+                    hierarchies.append(curr_hierarchy)
+                num_samples.append(data["num_samples"][i])
+
+        all_data = {}
+        all_data["users"] = users
+        if len(hierarchies) == len(users):
+            all_data["hierarchies"] = hierarchies
+        all_data["num_samples"] = num_samples
+        all_data["user_data"] = user_data
+
+        file_name = "{}_keep_{}.json".format((f[:-5]), min_samples)
+        ouf_dir = os.path.join(dir, setting_folder, "rem_user_data", file_name)
+
+        logger.info("writing {}".format(file_name))
+        with open(ouf_dir, "w") as outfile:
+            json.dump(all_data, outfile)
diff --git a/easyfl/datasets/utils/sample.py b/easyfl/datasets/utils/sample.py
new file mode 100644
index 0000000..48ffab8
--- /dev/null
+++ b/easyfl/datasets/utils/sample.py
@@ -0,0 +1,274 @@
+"""
+These codes are adopted from LEAF with some modifications.
+
+Samples from all raw data;
+by default samples in a non-iid manner; namely, randomly selects users from 
+raw data until their cumulative amount of data exceeds the given number of 
+datapoints to sample (specified by --fraction argument);
+ordering of original data points is not preserved in sampled data
+"""
+
+import json
+import logging
+import os
+import random
+import time
+from collections import OrderedDict
+
+from easyfl.datasets.simulation import non_iid_class
+from easyfl.datasets.utils.constants import SEED_FILES
+from easyfl.datasets.utils.util import iid_divide
+
+logger = logging.getLogger(__name__)
+
+
+def extreme(data_dir, data_folder, metafile, fraction, num_class=62, num_of_client=100, class_per_client=2, seed=-1):
+    """
+    Note: for extreme split, there are two ways, one is divide each class into parts and then distribute to the clients;
+    The second way is to let clients to go through classes to get a part of the data; Current version is the latter one, we 
+    can also provide the previous one (the one we adopt in CIFA10); If (num_of_client*class_per_client)%num_class, there is no 
+    difference(assume each class is equal), otherwise, how to deal with some remain parts is a question to discuss. (currently,
+    the method will just give the remain part to the next client coming for collection, which may make the last clients have more
+    than class_per_client;)
+    """
+    logger.info("------------------------------")
+    logger.info("sampling data")
+
+    subdir = os.path.join(data_dir, 'all_data')
+    files = os.listdir(subdir)
+    files = [f for f in files if f.endswith('.json')]
+
+    rng_seed = (seed if (seed is not None and seed >= 0) else int(time.time()))
+    logger.info("Using seed {}".format(rng_seed))
+    rng = random.Random(rng_seed)
+
+    logger.info(metafile)
+    if metafile is not None:
+        seed_fname = os.path.join(metafile, SEED_FILES['sampling'])
+        with open(seed_fname, 'w+') as f:
+            f.write("# sampling_seed used by sampling script - supply as "
+                    "--smplseed to preprocess.sh or --seed to utils/sample.py\n")
+            f.write(str(rng_seed))
+        logger.info("- random seed written out to {file}".format(file=seed_fname))
+    else:
+        logger.info("- using random seed '{seed}' for sampling".format(seed=rng_seed))
+    new_user_count = 0  # for iid case
+    all_users = []
+    all_user_data = {}
+    for f in files:
+        file_dir = os.path.join(subdir, f)
+        with open(file_dir, 'r') as inf:
+            data = json.load(inf, object_pairs_hook=OrderedDict)
+
+        num_users = len(data['users'])
+
+        tot_num_samples = sum(data['num_samples'])
+        num_new_samples = int(fraction * tot_num_samples)
+
+        raw_list = list(data['user_data'].values())
+        raw_x = [elem['x'] for elem in raw_list]
+        raw_y = [elem['y'] for elem in raw_list]
+        x_list = [item for sublist in raw_x for item in sublist]  # flatten raw_x
+        y_list = [item for sublist in raw_y for item in sublist]  # flatten raw_y
+        num_new_users = num_users
+
+        indices = [i for i in range(tot_num_samples)]
+        new_indices = rng.sample(indices, num_new_samples)
+        users = [str(i + new_user_count) for i in range(num_new_users)]
+        all_users.extend(users)
+        user_data = {}
+        for user in users:
+            user_data[user] = {'x': [], 'y': []}
+        all_x_samples = [x_list[i] for i in new_indices]
+        all_y_samples = [y_list[i] for i in new_indices]
+        x_groups = iid_divide(all_x_samples, num_new_users)
+        y_groups = iid_divide(all_y_samples, num_new_users)
+        for i in range(num_new_users):
+            user_data[users[i]]['x'] = x_groups[i]
+            user_data[users[i]]['y'] = y_groups[i]
+        all_user_data.update(user_data)
+
+        num_samples = [len(user_data[u]['y']) for u in users]
+        new_user_count += num_new_users
+
+    allx = []
+    ally = []
+    for i in all_users:
+        allx.extend(all_user_data[i]['x'])
+        ally.extend(all_user_data[i]['y'])
+    clients, all_user_data = non_iid_class(x_list, y_list, class_per_client, num_of_client)
+
+    # ------------
+    # create .json file
+    all_num_samples = []
+    for i in clients:
+        all_num_samples.append(len(all_user_data[i]['y']))
+    all_data = {}
+    all_data['users'] = clients
+    all_data['num_samples'] = all_num_samples
+    all_data['user_data'] = all_user_data
+
+    slabel = ''
+
+    arg_frac = str(fraction)
+    arg_frac = arg_frac[2:]
+    arg_label = arg_frac
+    file_name = '%s_%s_%s.json' % ("class", slabel, arg_label)
+    ouf_dir = os.path.join(data_folder, 'sampled_data', file_name)
+
+    logger.info("writing {}".format(file_name))
+    with open(ouf_dir, 'w') as outfile:
+        json.dump(all_data, outfile)
+
+
+def sample(data_dir, data_folder, metafile, fraction, iid, iid_user_fraction=0.01, seed=-1):
+    logger.info("------------------------------")
+    logger.info("sampling data")
+    subdir = os.path.join(data_dir, 'all_data')
+    files = os.listdir(subdir)
+    files = [f for f in files if f.endswith('.json')]
+
+    rng_seed = (seed if (seed is not None and seed >= 0) else int(time.time()))
+    logger.info("Using seed {}".format(rng_seed))
+    rng = random.Random(rng_seed)
+
+    logger.info(metafile)
+    if metafile is not None:
+        seed_fname = os.path.join(metafile, SEED_FILES['sampling'])
+        with open(seed_fname, 'w+') as f:
+            f.write("# sampling_seed used by sampling script - supply as "
+                    "--smplseed to preprocess.sh or --seed to utils/sample.py\n")
+            f.write(str(rng_seed))
+        logger.info("- random seed written out to {file}".format(file=seed_fname))
+    else:
+        logger.info("- using random seed '{seed}' for sampling".format(seed=rng_seed))
+
+    new_user_count = 0  # for iid case
+    for f in files:
+        file_dir = os.path.join(subdir, f)
+        with open(file_dir, 'r') as inf:
+            # Load data into an OrderedDict, to prevent ordering changes
+            # and enable reproducibility
+            data = json.load(inf, object_pairs_hook=OrderedDict)
+
+        num_users = len(data['users'])
+
+        tot_num_samples = sum(data['num_samples'])
+        num_new_samples = int(fraction * tot_num_samples)
+
+        hierarchies = None
+
+        if iid:
+            # iid in femnist is to put all data together, and then split them according to
+            # iid_user_fraction * num_users numbers of clients evenly
+            raw_list = list(data['user_data'].values())
+            raw_x = [elem['x'] for elem in raw_list]
+            raw_y = [elem['y'] for elem in raw_list]
+            x_list = [item for sublist in raw_x for item in sublist]  # flatten raw_x
+            y_list = [item for sublist in raw_y for item in sublist]  # flatten raw_y
+
+            num_new_users = int(round(iid_user_fraction * num_users))
+            if num_new_users == 0:
+                num_new_users += 1
+
+            indices = [i for i in range(tot_num_samples)]
+            new_indices = rng.sample(indices, num_new_samples)
+            users = ["f%07.0f" % (i + new_user_count) for i in range(num_new_users)]
+
+            user_data = {}
+            for user in users:
+                user_data[user] = {'x': [], 'y': []}
+            all_x_samples = [x_list[i] for i in new_indices]
+            all_y_samples = [y_list[i] for i in new_indices]
+            x_groups = iid_divide(all_x_samples, num_new_users)
+            y_groups = iid_divide(all_y_samples, num_new_users)
+            for i in range(num_new_users):
+                user_data[users[i]]['x'] = x_groups[i]
+                user_data[users[i]]['y'] = y_groups[i]
+
+            num_samples = [len(user_data[u]['y']) for u in users]
+
+            new_user_count += num_new_users
+
+        else:
+            # niid's fraction in femnist is to choose some clients, one by one,
+            # until the data size meets the fration * total data size
+            ctot_num_samples = 0
+
+            users = data['users']
+            users_and_hiers = None
+            if 'hierarchies' in data:
+                users_and_hiers = list(zip(users, data['hierarchies']))
+                rng.shuffle(users_and_hiers)
+            else:
+                rng.shuffle(users)
+            user_i = 0
+            num_samples = []
+            user_data = {}
+
+            if 'hierarchies' in data:
+                hierarchies = []
+
+            while ctot_num_samples < num_new_samples:
+                hierarchy = None
+                if users_and_hiers is not None:
+                    user, hier = users_and_hiers[user_i]
+                else:
+                    user = users[user_i]
+
+                cdata = data['user_data'][user]
+
+                cnum_samples = len(data['user_data'][user]['y'])
+
+                if ctot_num_samples + cnum_samples > num_new_samples:
+                    cnum_samples = num_new_samples - ctot_num_samples
+                    indices = [i for i in range(cnum_samples)]
+                    new_indices = rng.sample(indices, cnum_samples)
+                    x = []
+                    y = []
+                    for i in new_indices:
+                        x.append(data['user_data'][user]['x'][i])
+                        y.append(data['user_data'][user]['y'][i])
+                    cdata = {'x': x, 'y': y}
+
+                if 'hierarchies' in data:
+                    hierarchies.append(hier)
+
+                num_samples.append(cnum_samples)
+                user_data[user] = cdata
+
+                ctot_num_samples += cnum_samples
+                user_i += 1
+
+            if 'hierarchies' in data:
+                users = [u for u, h in users_and_hiers][:user_i]
+            else:
+                users = users[:user_i]
+
+        # ------------
+        # create .json file
+
+        all_data = {}
+        all_data['users'] = users
+        if hierarchies is not None:
+            all_data['hierarchies'] = hierarchies
+        all_data['num_samples'] = num_samples
+        all_data['user_data'] = user_data
+
+        slabel = 'niid'
+        if iid:
+            slabel = 'iid'
+
+        arg_frac = str(fraction)
+        arg_frac = arg_frac[2:]
+        arg_nu = str(iid_user_fraction)
+        arg_nu = arg_nu[2:]
+        arg_label = arg_frac
+        if iid:
+            arg_label = '%s_%s' % (arg_nu, arg_label)
+        file_name = '%s_%s_%s.json' % ((f[:-5]), slabel, arg_label)
+        ouf_dir = os.path.join(data_folder, 'sampled_data', file_name)
+
+        logger.info('writing %s' % file_name)
+        with open(ouf_dir, 'w') as outfile:
+            json.dump(all_data, outfile)
diff --git a/easyfl/datasets/utils/split_data.py b/easyfl/datasets/utils/split_data.py
new file mode 100644
index 0000000..87546a4
--- /dev/null
+++ b/easyfl/datasets/utils/split_data.py
@@ -0,0 +1,235 @@
+"""
+These codes are adopted from LEAF with some modifications.
+
+Splits data into train and test sets.
+"""
+
+import json
+import logging
+import os
+import random
+import sys
+import time
+from collections import OrderedDict
+
+from easyfl.datasets.utils.constants import SEED_FILES
+
+logger = logging.getLogger(__name__)
+
+
+def create_jsons_for(dir, setting_folder, user_files, which_set, max_users, include_hierarchy, subdir, arg_label):
+    """Used in split-by-user case"""
+    user_count = 0
+    json_index = 0
+    users = []
+    if include_hierarchy:
+        hierarchies = []
+    else:
+        hierarchies = None
+    num_samples = []
+    user_data = {}
+    for (i, t) in enumerate(user_files):
+        if include_hierarchy:
+            (u, h, ns, f) = t
+        else:
+            (u, ns, f) = t
+
+        file_dir = os.path.join(subdir, f)
+        with open(file_dir, 'r') as inf:
+            data = json.load(inf)
+
+        users.append(u)
+        if include_hierarchy:
+            hierarchies.append(h)
+        num_samples.append(ns)
+        user_data[u] = data['user_data'][u]
+        user_count += 1
+
+        if (user_count == max_users) or (i == len(user_files) - 1):
+
+            all_data = {}
+            all_data['users'] = users
+            if include_hierarchy:
+                all_data['hierarchies'] = hierarchies
+            all_data['num_samples'] = num_samples
+            all_data['user_data'] = user_data
+
+            data_i = f.find('data')
+            num_i = data_i + 5
+            num_to_end = f[num_i:]
+            param_i = num_to_end.find('_')
+            param_to_end = '.json'
+            if param_i != -1:
+                param_to_end = num_to_end[param_i:]
+            nf = "{}_{}{}".format(f[:(num_i - 1)], json_index, param_to_end)
+            file_name = '{}_{}_{}.json'.format((nf[:-5]), which_set, arg_label)
+            ouf_dir = os.path.join(dir, setting_folder, which_set, file_name)
+
+            logger.info('writing {}'.format(file_name))
+            with open(ouf_dir, 'w') as outfile:
+                json.dump(all_data, outfile)
+
+            user_count = 0
+            json_index += 1
+            users = []
+            if include_hierarchy:
+                hierarchies = []
+            num_samples = []
+            user_data = {}
+
+
+def split_train_test(setting_folder, metafile, name, user, frac, seed):
+    logger.info("------------------------------")
+    logger.info("generating training and test sets")
+
+    parent_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    dir = os.path.join(parent_path, name, 'data')
+    subdir = os.path.join(dir, setting_folder, 'rem_user_data')
+    files = []
+    if os.path.exists(subdir):
+        files = os.listdir(subdir)
+    if len(files) == 0:
+        subdir = os.path.join(dir, setting_folder, 'sampled_data')
+        if os.path.exists(subdir):
+            files = os.listdir(subdir)
+    if len(files) == 0:
+        subdir = os.path.join(dir, 'all_data')
+        files = os.listdir(subdir)
+    files = [f for f in files if f.endswith('.json')]
+
+    rng_seed = (seed if (seed is not None and seed >= 0) else int(time.time()))
+    rng = random.Random(rng_seed)
+    if metafile is not None:
+        seed_fname = os.path.join(metafile, SEED_FILES['split'])
+        with open(seed_fname, 'w+') as f:
+            f.write("# split_seed used by sampling script - supply as "
+                    "--spltseed to preprocess.sh or --seed to utils/split_data.py\n")
+            f.write(str(rng_seed))
+        logger.info("- random seed written out to {file}".format(file=seed_fname))
+    else:
+        logger.info("- using random seed '{seed}' for sampling".format(seed=rng_seed))
+
+    arg_label = str(frac)
+    arg_label = arg_label[2:]
+
+    # check if data contains information on hierarchies
+    file_dir = os.path.join(subdir, files[0])
+    with open(file_dir, 'r') as inf:
+        data = json.load(inf)
+    include_hierarchy = 'hierarchies' in data
+
+    if (user):
+        logger.info("splitting data by user")
+
+        # 1 pass through all the json files to instantiate arr
+        # containing all possible (user, .json file name) tuples
+        user_files = []
+        for f in files:
+            file_dir = os.path.join(subdir, f)
+            with open(file_dir, 'r') as inf:
+                # Load data into an OrderedDict, to prevent ordering changes
+                # and enable reproducibility
+                data = json.load(inf, object_pairs_hook=OrderedDict)
+            if include_hierarchy:
+                user_files.extend([(u, h, ns, f) for (u, h, ns) in
+                                   zip(data['users'], data['hierarchies'], data['num_samples'])])
+            else:
+                user_files.extend([(u, ns, f) for (u, ns) in
+                                   zip(data['users'], data['num_samples'])])
+
+        # randomly sample from user_files to pick training set users
+        num_users = len(user_files)
+        num_train_users = int(frac * num_users)
+        indices = [i for i in range(num_users)]
+        train_indices = rng.sample(indices, num_train_users)
+        train_blist = [False for i in range(num_users)]
+        for i in train_indices:
+            train_blist[i] = True
+        train_user_files = []
+        test_user_files = []
+        for i in range(num_users):
+            if (train_blist[i]):
+                train_user_files.append(user_files[i])
+            else:
+                test_user_files.append(user_files[i])
+
+        max_users = sys.maxsize
+        if name == 'femnist':
+            max_users = 50  # max number of users per json file
+        create_jsons_for(dir, setting_folder, train_user_files, 'train', max_users, include_hierarchy, subdir,
+                         arg_label)
+        create_jsons_for(dir, setting_folder, test_user_files, 'test', max_users, include_hierarchy, subdir, arg_label)
+
+    else:
+        logger.info("splitting data by sample")
+
+        for f in files:
+            file_dir = os.path.join(subdir, f)
+            with open(file_dir, 'r') as inf:
+                # Load data into an OrderedDict, to prevent ordering changes
+                # and enable reproducibility
+                data = json.load(inf, object_pairs_hook=OrderedDict)
+
+            num_samples_train = []
+            user_data_train = {}
+            num_samples_test = []
+            user_data_test = {}
+
+            user_indices = []  # indices of users in data['users'] that are not deleted
+
+            for i, u in enumerate(data['users']):
+                user_data_train[u] = {'x': [], 'y': []}
+                user_data_test[u] = {'x': [], 'y': []}
+
+                curr_num_samples = len(data['user_data'][u]['y'])
+                if curr_num_samples >= 2:
+                    user_indices.append(i)
+
+                    # ensures number of train and test samples both >= 1
+                    num_train_samples = max(1, int(frac * curr_num_samples))
+                    if curr_num_samples == 2:
+                        num_train_samples = 1
+
+                    num_test_samples = curr_num_samples - num_train_samples
+                    num_samples_train.append(num_train_samples)
+                    num_samples_test.append(num_test_samples)
+
+                    indices = [j for j in range(curr_num_samples)]
+                    train_indices = rng.sample(indices, num_train_samples)
+                    train_blist = [False for _ in range(curr_num_samples)]
+                    for j in train_indices:
+                        train_blist[j] = True
+
+                    for j in range(curr_num_samples):
+                        if (train_blist[j]):
+                            user_data_train[u]['x'].append(data['user_data'][u]['x'][j])
+                            user_data_train[u]['y'].append(data['user_data'][u]['y'][j])
+                        else:
+                            user_data_test[u]['x'].append(data['user_data'][u]['x'][j])
+                            user_data_test[u]['y'].append(data['user_data'][u]['y'][j])
+
+            users = [data['users'][i] for i in user_indices]
+
+            all_data_train = {}
+            all_data_train['users'] = users
+            all_data_train['num_samples'] = num_samples_train
+            all_data_train['user_data'] = user_data_train
+            all_data_test = {}
+            all_data_test['users'] = users
+            all_data_test['num_samples'] = num_samples_test
+            all_data_test['user_data'] = user_data_test
+
+            if include_hierarchy:
+                all_data_train['hierarchies'] = data['hierarchies']
+                all_data_test['hierarchies'] = data['hierarchies']
+
+            file_name_train = '{}_train_{}.json'.format((f[:-5]), arg_label)
+            file_name_test = '{}_test_{}.json'.format((f[:-5]), arg_label)
+            ouf_dir_train = os.path.join(dir, setting_folder, 'train', file_name_train)
+            ouf_dir_test = os.path.join(dir, setting_folder, 'test', file_name_test)
+            logger.info("writing {}".format(file_name_train))
+            with open(ouf_dir_train, 'w') as outfile:
+                json.dump(all_data_train, outfile)
+            logger.info("writing {}".format(file_name_test))
+            with open(ouf_dir_test, 'w') as outfile:
+                json.dump(all_data_test, outfile)
diff --git a/easyfl/datasets/utils/util.py b/easyfl/datasets/utils/util.py
new file mode 100644
index 0000000..031824a
--- /dev/null
+++ b/easyfl/datasets/utils/util.py
@@ -0,0 +1,42 @@
+import pickle
+
+
+def save_obj(obj, name):
+    with open(name + '.pkl', 'wb') as f:
+        pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)
+
+
+def load_obj(name):
+    with open(name + '.pkl', 'rb') as f:
+        return pickle.load(f)
+
+
+def save_dict(dic, filename):
+    with open(filename, 'wb') as f:
+        pickle.dump(dic, f)
+
+
+def load_dict(filename):
+    with open(filename, 'rb') as f:
+        dic = pickle.load(f)
+    return dic
+
+
+def iid_divide(l, g):
+    """
+    divide list l among g groups
+    each group has either int(len(l)/g) or int(len(l)/g)+1 elements
+    returns a list of groups
+    """
+    num_elems = len(l)
+    group_size = int(len(l) / g)
+    num_big_groups = num_elems - g * group_size
+    num_small_groups = g - num_big_groups
+    glist = []
+    for i in range(num_small_groups):
+        glist.append(l[group_size * i: group_size * (i + 1)])
+    bi = group_size * num_small_groups
+    group_size += 1
+    for i in range(num_big_groups):
+        glist.append(l[bi + group_size * i:bi + group_size * (i + 1)])
+    return glist
diff --git a/easyfl/distributed/__init__.py b/easyfl/distributed/__init__.py
new file mode 100644
index 0000000..9dc94ab
--- /dev/null
+++ b/easyfl/distributed/__init__.py
@@ -0,0 +1,18 @@
+from easyfl.distributed.distributed import (
+    dist_init,
+    get_device,
+    grouping,
+    reduce_models,
+    reduce_models_only_params,
+    reduce_value,
+    reduce_values,
+    reduce_weighted_values,
+    gather_value,
+    CPU
+)
+
+from easyfl.distributed.slurm import setup, get_ip
+
+__all__ = ['dist_init', 'get_device', 'grouping', 'gather_value', 'setup', 'get_ip',
+           'reduce_models', 'reduce_models_only_params', 'reduce_value', 'reduce_values', 'reduce_weighted_values']
+
diff --git a/easyfl/distributed/distributed.py b/easyfl/distributed/distributed.py
new file mode 100644
index 0000000..27e91c2
--- /dev/null
+++ b/easyfl/distributed/distributed.py
@@ -0,0 +1,257 @@
+import logging
+
+import numpy as np
+import torch
+import torch.distributed as dist
+
+logger = logging.getLogger(__name__)
+
+CPU = "cpu"
+
+RANDOMIZE_GROUPING = "random"
+GREEDY_GROUPING = "greedy"
+SLOWEST_GROUPING = "slowest"
+
+
+def reduce_models(model, sample_sum):
+    """Aggregate models across devices and update the model with the new aggregated model parameters.
+
+    Args:
+        model (nn.Module): The model in a device to aggregate.
+        sample_sum (int): Sum of the total dataset sizes of clients in a device.
+    """
+    dist.all_reduce(sample_sum, op=dist.ReduceOp.SUM)
+    state = model.state_dict()
+    for k in state.keys():
+        dist.all_reduce(state[k], op=dist.ReduceOp.SUM)
+        state[k] = torch.div(state[k], sample_sum)
+    model.load_state_dict(state)
+
+
+def reduce_models_only_params(model, sample_sum):
+    """Aggregate models across devices and update the model with the new aggregated model parameters,
+    excluding the persistent buffers like BN stats.
+
+    Args:
+        model (nn.Module): The model in a device to aggregate.
+        sample_sum (torch.Tensor): Sum of the total dataset sizes of clients in a device.
+    """
+    dist.all_reduce(sample_sum, op=dist.ReduceOp.SUM)
+    for param in model.parameters():
+        dist.all_reduce(param.data, op=dist.ReduceOp.SUM)
+        param.data = torch.div(param.data, sample_sum)
+
+
+def reduce_value(value, device):
+    """Calculate the sum of the value across devices.
+
+    Args:
+        value (float/int): Value to sum.
+        device (str): The device where the value is on, either cpu or cuda devices.
+    Returns:
+         torch.Tensor: Sum of the values.
+    """
+    v = torch.tensor(value).to(device)
+    dist.all_reduce(v, op=dist.ReduceOp.SUM)
+    return v
+
+
+def reduce_values(values, device):
+    """Calculate the average of values across devices.
+
+    Args:
+        values (list[float|int]): Values to average.
+        device (str): The device where the value is on, either cpu or cuda devices.
+    Returns:
+         torch.Tensor: The average of the values across devices.
+    """
+    length = torch.tensor(len(values)).to(device)
+    total = torch.tensor(sum(values)).to(device)
+    dist.all_reduce(length, op=dist.ReduceOp.SUM)
+    dist.all_reduce(total, op=dist.ReduceOp.SUM)
+    return torch.div(total, length)
+
+
+def reduce_weighted_values(values, weights, device):
+    """Calculate the weighted average of values across devices.
+
+    Args:
+        values (list[float|int]): Values to average.
+        weights (list[float|int]): The weights to calculate weighted average.
+        device (str): The device where the value is on, either cpu or cuda devices.
+    Returns:
+         torch.Tensor: The average of values across devices.
+    """
+    values = torch.tensor(values).to(device)
+    weights = torch.tensor(weights).to(device)
+    total_weights = torch.sum(weights).to(device)
+    weighted_sum = torch.sum(values * weights).to(device)
+    dist.all_reduce(total_weights, op=dist.ReduceOp.SUM)
+    dist.all_reduce(weighted_sum, op=dist.ReduceOp.SUM)
+    return torch.div(weighted_sum, total_weights)
+
+
+def gather_value(value, world_size, device):
+    """Gather the value from devices to a list.
+
+    Args:
+        value (float|int): The value to gather.
+        world_size (int): The number of processes.
+        device (str): The device where the value is on, either cpu or cuda devices.
+    Returns:
+         list[torch.Tensor]: A list of gathered values.
+    """
+    v = torch.tensor(value).to(device)
+    target = [v.clone() for _ in range(world_size)]
+    dist.all_gather(target, v)
+    return target
+
+
+def grouping(clients, world_size, default_time=10, strategy=RANDOMIZE_GROUPING, seed=1):
+    """Divide clients into groups with different strategies.
+
+    Args:
+        clients (list[:obj:`BaseClient`]): A list of clients.
+        world_size (int): The number of processes, it represent the number of groups here.
+        default_time (float, optional): The default training time for not profiled clients.
+        strategy (str, optional): Strategy of grouping, options: random, greedy, worst.
+            When no strategy is applied, each client is a group.
+        seed (int, optional): Random seed.
+
+    Returns:
+        list[list[:obj:`BaseClient`]]: Groups of clients, each group is a sub-list.
+    """
+    np.random.seed(seed)
+    if strategy == RANDOMIZE_GROUPING:
+        return randomize_grouping(clients, world_size)
+    elif strategy == GREEDY_GROUPING:
+        return greedy_grouping(clients, world_size, default_time)
+    elif strategy == SLOWEST_GROUPING:
+        return slowest_grouping(clients, world_size)
+    else:
+        # default, no strategy applied
+        return [[client] for client in clients]
+
+
+def randomize_grouping(clients, world_size):
+    """"Randomly divide clients into groups.
+
+    Args:
+        clients (list[:obj:`BaseClient`]): A list of clients.
+        world_size (int): The number of processes, it represent the number of groups here.
+
+    Returns:
+        list[list[:obj:`BaseClient`]]: Groups of clients, each group is a sub-list.
+    """
+    num_of_clients = len(clients)
+    np.random.shuffle(clients)
+    data_per_client = num_of_clients // world_size
+    large_group_num = num_of_clients - world_size * data_per_client
+    small_group_num = world_size - large_group_num
+    grouped_clients = []
+    for i in range(small_group_num):
+        base_index = data_per_client * i
+        grouped_clients.append(clients[base_index: base_index + data_per_client])
+    small_size = data_per_client * small_group_num
+    data_per_client += 1
+    for i in range(large_group_num):
+        base_index = small_size + data_per_client * i
+        grouped_clients.append(clients[base_index: base_index + data_per_client])
+    return grouped_clients
+
+
+def greedy_grouping(clients, world_size, default_time):
+    """"Greedily allocate the clients with longest training time to the most available device.
+
+
+    Args:
+        clients (list[:obj:`BaseClient`]): A list of clients.
+        world_size (int): The number of processes, it represent the number of groups here.
+        default_time (float, optional): The default training time for not profiled clients.
+
+    Returns:
+        list[list[:obj:`BaseClient`]]: Groups of clients, each group is a sub-list.
+    """
+    round_time_estimation = [[i, c.round_time] if c.round_time != 0
+                             else [i, default_time] for i, c in enumerate(clients)]
+    round_time_estimation = sorted(round_time_estimation, reverse=True, key=lambda tup: (tup[1], tup[0]))
+    top_world_size = round_time_estimation[:world_size]
+    groups = [[clients[index]] for (index, time) in top_world_size]
+    time_sum = [time for (index, time) in top_world_size]
+    for i in round_time_estimation[world_size:]:
+        min_index = np.argmin(time_sum)
+        groups[min_index].append(clients[i[0]])
+        time_sum[min_index] += i[1]
+    return groups
+
+
+def slowest_grouping(clients, world_size):
+    """"Allocate the clients with longest training time to the most busy device.
+    Only for experiment, not practical in use.
+
+
+    Args:
+        clients (list[:obj:`BaseClient`]): A list of clients.
+        world_size (int): The number of processes, it represent the number of groups here.
+
+    Returns:
+        list[list[:obj:`BaseClient`]]: Groups of clients, each group is a sub-list.
+    """
+    num_of_clients = len(clients)
+    clients = sorted(clients, key=lambda tup: (tup.round_time, tup.cid))
+    data_per_client = num_of_clients // world_size
+    large_group_num = num_of_clients - world_size * data_per_client
+    small_group_num = world_size - large_group_num
+    grouped_clients = []
+    for i in range(small_group_num):
+        base_index = data_per_client * i
+        grouped_clients.append(clients[base_index: base_index + data_per_client])
+    small_size = data_per_client * small_group_num
+    data_per_client += 1
+    for i in range(large_group_num):
+        base_index = small_size + data_per_client * i
+        grouped_clients.append(clients[base_index: base_index + data_per_client])
+    return grouped_clients
+
+
+def dist_init(backend, init_method, world_size, rank, local_rank):
+    """Initialize PyTorch distribute.
+
+    Args:
+        backend (str or Backend): Distributed backend to use, e.g., `nccl`, `gloo`.
+        init_method (str, optional): URL specifying how to initialize the process group.
+        world_size (int, optional): Number of processes participating in the job.
+        rank (int, optional): Rank of the current process.
+        local rank (int, optional): Local rank of the current process.
+
+    Returns:
+        int: Rank of current process.
+        int: Total number of processes.
+    """
+    dist.init_process_group(backend, init_method=init_method, rank=rank, world_size=world_size)
+    assert dist.is_initialized()
+    return rank, world_size
+
+
+def get_device(gpu, world_size, local_rank):
+    """Obtain the device by checking the number of GPUs and distributed settings.
+
+    Args:
+        gpu (int): The number of requested gpu.
+        world_size (int): The number of processes.
+        local_rank (int): The local rank of the current process.
+
+    Returns:
+        str: Device to be used in PyTorch like `tensor.to(device)`.
+    """
+    if gpu > world_size:
+        logger.error("Available gpu: {}, requested gpu: {}".format(world_size, gpu))
+        raise ValueError("available number of gpu are less than requested")
+
+    # TODO: think of a better way to handle this, maybe just use one config param instead of two.
+    assert gpu == world_size
+
+    n = torch.cuda.device_count()
+
+    device_ids = list(range(n))
+    return device_ids[local_rank]
diff --git a/easyfl/distributed/slurm.py b/easyfl/distributed/slurm.py
new file mode 100644
index 0000000..5b2e1c6
--- /dev/null
+++ b/easyfl/distributed/slurm.py
@@ -0,0 +1,64 @@
+import logging
+import os
+import re
+import socket
+
+logger = logging.getLogger(__name__)
+
+
+def setup(port=23344):
+    """Setup distributed settings of slurm.
+
+    Args:
+        port (int, optional): The port of the primary server.
+            It respectively auto-increments by 1 when the port is in-use.
+
+    Returns:
+        int: The rank of current process.
+        int: The local rank of current process.
+        int: Total number of processes.
+        str: The address of the distributed init method.
+    """
+    try:
+        rank = int(os.environ['SLURM_PROCID'])
+        local_rank = int(os.environ['SLURM_LOCALID'])
+        world_size = int(os.environ['SLURM_NTASKS'])
+        host = get_ip(os.environ['SLURM_STEP_NODELIST'])
+        while is_port_in_use(host, port):
+            port += 1
+        host_addr = 'tcp://' + host + ':' + str(port)
+    except KeyError:
+        return 0, 0, 0, ""
+    return rank, local_rank, world_size, host_addr
+
+
+def get_ip(node_list):
+    """Get the ip address of nodes.
+
+    Args:
+        node_list (str): Name of the nodes.
+
+    Returns:
+        str: The first node in the nodes.
+    """
+    if "[" not in node_list:
+        return node_list
+    r = re.search(r'([\w-]*)\[(\d*)[-+,+\d]*\]', node_list)
+    if not r:
+        return
+    base, node = r.groups()
+    return base + node
+
+
+def is_port_in_use(host, port):
+    """Check whether the port is in use.
+
+    Args:
+        host (str): Host address.
+        port (int): Port to use.
+
+    Returns:
+        bool: A flag to indicate whether the port is in use in the host.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex((host, port)) == 0
diff --git a/easyfl/encryption/__init__.py b/easyfl/encryption/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/models/__init__.py b/easyfl/models/__init__.py
new file mode 100644
index 0000000..bce4a1d
--- /dev/null
+++ b/easyfl/models/__init__.py
@@ -0,0 +1 @@
+from easyfl.models.model import BaseModel
diff --git a/easyfl/models/lenet.py b/easyfl/models/lenet.py
new file mode 100644
index 0000000..eb00c27
--- /dev/null
+++ b/easyfl/models/lenet.py
@@ -0,0 +1,36 @@
+from torch import nn
+import torch.nn.functional as F
+
+from easyfl.models.model import BaseModel
+
+
+class Model(BaseModel):
+    def __init__(self):
+        super(Model, self).__init__()
+        self.conv1 = nn.Conv2d(1, 32, 5, padding=(2, 2))
+        self.conv2 = nn.Conv2d(32, 64, 5, padding=(2, 2))
+        self.fc1 = nn.Linear(7 * 7 * 64, 2048)
+        self.fc2 = nn.Linear(2048, 62)
+        self.init_weights()
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = x.view(-1, 7 * 7 * 64)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+
+        return x
+
+    def init_weights(self):
+        init_range = 0.1
+        self.conv1.weight.data.uniform_(-init_range, init_range)
+        self.conv1.bias.data.zero_()
+        self.conv2.weight.data.uniform_(-init_range, init_range)
+        self.conv2.bias.data.zero_()
+        self.fc1.weight.data.uniform_(-init_range, init_range)
+        self.fc1.bias.data.zero_()
+        self.fc2.weight.data.uniform_(-init_range, init_range)
+        self.fc2.bias.data.zero_()
diff --git a/easyfl/models/model.py b/easyfl/models/model.py
new file mode 100644
index 0000000..a688639
--- /dev/null
+++ b/easyfl/models/model.py
@@ -0,0 +1,24 @@
+import importlib
+import logging
+from os import path
+
+from torch import nn
+
+logger = logging.getLogger(__name__)
+
+
+class BaseModel(nn.Module):
+    def __init__(self):
+        super(BaseModel, self).__init__()
+
+
+def load_model(model_name: str):
+    dir_path = path.dirname(path.realpath(__file__))
+    model_file = path.join(dir_path, "{}.py".format(model_name))
+    if not path.exists(model_file):
+        logger.error("Please specify a valid model.")
+    model_path = "easyfl.models.{}".format(model_name)
+    model_lib = importlib.import_module(model_path)
+    model = getattr(model_lib, "Model")
+    # TODO: maybe return the model class initiator
+    return model
diff --git a/easyfl/models/resnet.py b/easyfl/models/resnet.py
new file mode 100644
index 0000000..4a11e33
--- /dev/null
+++ b/easyfl/models/resnet.py
@@ -0,0 +1,124 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.models.resnet
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(
+            in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion * planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion * planes,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion * planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, self.expansion *
+                               planes, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(self.expansion * planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion * planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion * planes,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion * planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = F.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class ResNet(nn.Module):
+    """ResNet
+    Note two main differences from official pytorch version:
+    1. conv1 kernel size: pytorch version uses kernel_size=7
+    2. average pooling: pytorch version uses AdaptiveAvgPool
+    """
+
+    def __init__(self, block, num_blocks, num_classes=10):
+        super(ResNet, self).__init__()
+        self.in_planes = 64
+        self.feature_dim = 512 * block.expansion
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
+        self.avgpool = nn.AvgPool2d((4, 4))
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        out = self.layer4(out)
+        out = self.avgpool(out)
+        out = out.view(out.size(0), -1)
+        out = self.fc(out)
+        return out
+
+
+def ResNet18(num_classes=10):
+    return ResNet(BasicBlock, [2, 2, 2, 2], num_classes=num_classes)
+
+
+def ResNet34(num_classes=10):
+    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes)
+
+
+def ResNet50(num_classes=10):
+    return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes)
+
+
+def ResNet101(num_classes=10):
+    return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes)
+
+
+def ResNet152(num_classes=10):
+    return ResNet(Bottleneck, [3, 8, 36, 3], num_classes=num_classes)
diff --git a/easyfl/models/resnet18.py b/easyfl/models/resnet18.py
new file mode 100644
index 0000000..65d4cb4
--- /dev/null
+++ b/easyfl/models/resnet18.py
@@ -0,0 +1,102 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from easyfl.models import BaseModel
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(
+            in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion * planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion * planes,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion * planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, self.expansion *
+                               planes, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(self.expansion * planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion * planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion * planes,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion * planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = F.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Model(BaseModel):
+    """ResNet18 model
+    Note two main differences from official pytorch version:
+    1. conv1 kernel size: pytorch version uses kernel_size=7
+    2. average pooling: pytorch version uses AdaptiveAvgPool
+    """
+
+    def __init__(self, block=BasicBlock, num_blocks=[2, 2, 2, 2], num_classes=10):
+        super(Model, self).__init__()
+        self.in_planes = 64
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
+        self.linear = nn.Linear(512 * block.expansion, num_classes)
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        out = self.layer4(out)
+        out = F.avg_pool2d(out, 4)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
diff --git a/easyfl/models/resnet50.py b/easyfl/models/resnet50.py
new file mode 100644
index 0000000..2dd6bd7
--- /dev/null
+++ b/easyfl/models/resnet50.py
@@ -0,0 +1,107 @@
+'''ResNet in PyTorch.
+For Pre-activation ResNet, see 'preact_resnet.py'.
+Reference:
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Deep Residual Learning for Image Recognition. arXiv:1512.03385
+'''
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from easyfl.models import BaseModel
+
+
+class BasicBlock(BaseModel):
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(
+            in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion * planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion * planes,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion * planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Bottleneck(BaseModel):
+    expansion = 4
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, self.expansion *
+                               planes, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(self.expansion * planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion * planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion * planes,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion * planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = F.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Model(BaseModel):
+    def __init__(self, block=Bottleneck, num_blocks=[3, 4, 6, 3], num_classes=10):
+        super(Model, self).__init__()
+        self.in_planes = 64
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,
+                               stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
+        self.linear = nn.Linear(512 * block.expansion, num_classes)
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        out = self.layer4(out)
+        out = F.avg_pool2d(out, 4)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+
+def ResNet50():
+    return Model(Bottleneck, [3, 4, 6, 3])
diff --git a/easyfl/models/rnn.py b/easyfl/models/rnn.py
new file mode 100644
index 0000000..72caea5
--- /dev/null
+++ b/easyfl/models/rnn.py
@@ -0,0 +1,36 @@
+import torch
+import torch.nn as nn
+
+from easyfl.models.model import BaseModel
+
+
+def repackage_hidden(h):
+    """Wraps hidden states in new Tensors, to detach them from their history."""
+
+    if isinstance(h, torch.Tensor):
+        return h.detach()
+    else:
+        return tuple(repackage_hidden(v) for v in h)
+
+
+class Model(BaseModel):
+    def __init__(self, embedding_dim=8, voc_size=80, lstm_unit=256, batch_first=True, n_layers=2):
+        super(Model, self).__init__()
+        self.encoder = nn.Embedding(voc_size, embedding_dim)
+        self.lstm = nn.LSTM(embedding_dim, lstm_unit, n_layers, batch_first=batch_first)
+        self.decoder = nn.Linear(lstm_unit, voc_size)
+        self.init_weights()
+
+    def forward(self, inp):
+        inp = self.encoder(inp)
+        inp, _ = self.lstm(inp)
+        # extract the last state of output for prediction
+        hidden = inp[:, -1]
+        output = self.decoder(hidden)
+        return output
+
+    def init_weights(self):
+        init_range = 0.1
+        self.encoder.weight.data.uniform_(-init_range, init_range)
+        self.decoder.bias.data.zero_()
+        self.decoder.weight.data.uniform_(-init_range, init_range)
diff --git a/easyfl/models/simple_cnn.py b/easyfl/models/simple_cnn.py
new file mode 100644
index 0000000..46645f6
--- /dev/null
+++ b/easyfl/models/simple_cnn.py
@@ -0,0 +1,40 @@
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from easyfl.models import BaseModel
+
+
+class Model(BaseModel):
+    def __init__(self, channels=32):
+        super(Model, self).__init__()
+        self.num_channels = channels
+        self.conv1 = nn.Conv2d(3, self.num_channels, 3, stride=1)
+        self.conv2 = nn.Conv2d(self.num_channels, self.num_channels * 2, 3, stride=1)
+        self.conv3 = nn.Conv2d(self.num_channels * 2, self.num_channels * 2, 3, stride=1)
+
+        # 2 fully connected layers to transform the output of the convolution layers to the final output
+        self.fc1 = nn.Linear(4 * 4 * self.num_channels * 2, self.num_channels * 2)
+        self.fc2 = nn.Linear(self.num_channels * 2, 10)
+
+    def forward(self, s):
+        s = self.conv1(s)  # batch_size x num_channels x 32 x 32
+
+        s = F.relu(F.max_pool2d(s, 2))  # batch_size x num_channels x 16 x 16
+
+        s = self.conv2(s)  # batch_size x num_channels*2 x 16 x 16
+
+        s = F.relu(F.max_pool2d(s, 2))  # batch_size x num_channels*2 x 8 x 8
+
+        s = self.conv3(s)  # batch_size x num_channels*2 x 8 x 8
+
+        # s = F.relu(F.max_pool2d(s, 2))                      # batch_size x num_channels*2 x 4 x 4
+
+        # flatten the output for each image
+        s = s.view(-1, 4 * 4 * self.num_channels * 2)  # batch_size x 4*4*num_channels*4
+
+        # apply 2 fully connected layers with dropout
+        s = F.relu(self.fc1(s))
+        s = self.fc2(s)  # batch_size x 10
+
+        return s
diff --git a/easyfl/models/vgg9.py b/easyfl/models/vgg9.py
new file mode 100644
index 0000000..3b12f11
--- /dev/null
+++ b/easyfl/models/vgg9.py
@@ -0,0 +1,65 @@
+import torch
+import torch.nn as nn
+import math
+from easyfl.models import BaseModel
+
+cfg = {
+    'VGG9': [32, 64, 'M', 128, 128, 'M', 256, 256, 'M'],
+}
+
+
+def make_layers(cfg, batch_norm):
+    layers = []
+    in_channels = 3
+    for v in cfg:
+        if v == 'M':
+            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
+        else:
+            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
+            if batch_norm:
+                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
+
+            else:
+                layers += [conv2d, nn.ReLU(inplace=True)]
+            in_channels = v
+    return nn.Sequential(*layers)
+
+
+class Model(BaseModel):
+    def __init__(self, features=make_layers(cfg['VGG9'], batch_norm=False), num_classes=10):
+        super(Model, self).__init__()
+        self.features = features
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=0.1),
+            nn.Linear(4096, 512),
+            nn.ReLU(True),
+            nn.Dropout(p=0.1),
+            nn.Linear(512, 512),
+            nn.ReLU(True),
+            nn.Linear(512, num_classes),
+        )
+        self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                if m.bias is not None:
+                    m.bias.data.zero_()
+            elif isinstance(m, nn.BatchNorm2d):
+                m.reset_parameters()
+            elif isinstance(m, nn.Linear):
+                m.weight.data.normal_(0, 0.01)
+                m.bias.data.zero_()
+
+
+def VGG9(batch_norm=False, **kwargs):
+    model = Model(make_layers(cfg['VGG9'], batch_norm), **kwargs)
+    return model
diff --git a/easyfl/pb/__init__.py b/easyfl/pb/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/pb/client_service_pb2.py b/easyfl/pb/client_service_pb2.py
new file mode 100644
index 0000000..bdfc4f4
--- /dev/null
+++ b/easyfl/pb/client_service_pb2.py
@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: easyfl/pb/client_service.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from easyfl.pb import common_pb2 as easyfl_dot_pb_dot_common__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x65\x61syfl/pb/client_service.proto\x12\teasyfl.pb\x1a\x16\x65\x61syfl/pb/common.proto\"\x85\x01\n\x0eOperateRequest\x12&\n\x04type\x18\x01 \x01(\x0e\x32\x18.easyfl.pb.OperationType\x12\r\n\x05model\x18\x02 \x01(\x0c\x12\x12\n\ndata_index\x18\x03 \x01(\x05\x12(\n\x06\x63onfig\x18\x04 \x01(\x0b\x32\x18.easyfl.pb.OperateConfig\"\xce\x01\n\rOperateConfig\x12\x12\n\nbatch_size\x18\x01 \x01(\x05\x12\x13\n\x0blocal_epoch\x18\x02 \x01(\x05\x12\x0c\n\x04seed\x18\x03 \x01(\x03\x12\'\n\toptimizer\x18\x04 \x01(\x0b\x32\x14.easyfl.pb.Optimizer\x12\x12\n\nlocal_test\x18\x05 \x01(\x08\x12\x0f\n\x07task_id\x18\x06 \x01(\t\x12\x10\n\x08round_id\x18\x07 \x01(\x05\x12\r\n\x05track\x18\x08 \x01(\x08\x12\x17\n\x0ftest_batch_size\x18\t \x01(\x05\"7\n\tOptimizer\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\n\n\x02lr\x18\x02 \x01(\x02\x12\x10\n\x08momentum\x18\x03 \x01(\x02\"4\n\x0fOperateResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status*4\n\rOperationType\x12\x11\n\rOP_TYPE_TRAIN\x10\x00\x12\x10\n\x0cOP_TYPE_TEST\x10\x01\x32S\n\rClientService\x12\x42\n\x07Operate\x12\x19.easyfl.pb.OperateRequest\x1a\x1a.easyfl.pb.OperateResponse\"\x00\x62\x06proto3')
+
+_OPERATIONTYPE = DESCRIPTOR.enum_types_by_name['OperationType']
+OperationType = enum_type_wrapper.EnumTypeWrapper(_OPERATIONTYPE)
+OP_TYPE_TRAIN = 0
+OP_TYPE_TEST = 1
+
+
+_OPERATEREQUEST = DESCRIPTOR.message_types_by_name['OperateRequest']
+_OPERATECONFIG = DESCRIPTOR.message_types_by_name['OperateConfig']
+_OPTIMIZER = DESCRIPTOR.message_types_by_name['Optimizer']
+_OPERATERESPONSE = DESCRIPTOR.message_types_by_name['OperateResponse']
+OperateRequest = _reflection.GeneratedProtocolMessageType('OperateRequest', (_message.Message,), {
+  'DESCRIPTOR' : _OPERATEREQUEST,
+  '__module__' : 'easyfl.pb.client_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.OperateRequest)
+  })
+_sym_db.RegisterMessage(OperateRequest)
+
+OperateConfig = _reflection.GeneratedProtocolMessageType('OperateConfig', (_message.Message,), {
+  'DESCRIPTOR' : _OPERATECONFIG,
+  '__module__' : 'easyfl.pb.client_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.OperateConfig)
+  })
+_sym_db.RegisterMessage(OperateConfig)
+
+Optimizer = _reflection.GeneratedProtocolMessageType('Optimizer', (_message.Message,), {
+  'DESCRIPTOR' : _OPTIMIZER,
+  '__module__' : 'easyfl.pb.client_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.Optimizer)
+  })
+_sym_db.RegisterMessage(Optimizer)
+
+OperateResponse = _reflection.GeneratedProtocolMessageType('OperateResponse', (_message.Message,), {
+  'DESCRIPTOR' : _OPERATERESPONSE,
+  '__module__' : 'easyfl.pb.client_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.OperateResponse)
+  })
+_sym_db.RegisterMessage(OperateResponse)
+
+_CLIENTSERVICE = DESCRIPTOR.services_by_name['ClientService']
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _OPERATIONTYPE._serialized_start=525
+  _OPERATIONTYPE._serialized_end=577
+  _OPERATEREQUEST._serialized_start=70
+  _OPERATEREQUEST._serialized_end=203
+  _OPERATECONFIG._serialized_start=206
+  _OPERATECONFIG._serialized_end=412
+  _OPTIMIZER._serialized_start=414
+  _OPTIMIZER._serialized_end=469
+  _OPERATERESPONSE._serialized_start=471
+  _OPERATERESPONSE._serialized_end=523
+  _CLIENTSERVICE._serialized_start=579
+  _CLIENTSERVICE._serialized_end=662
+# @@protoc_insertion_point(module_scope)
diff --git a/easyfl/pb/client_service_pb2_grpc.py b/easyfl/pb/client_service_pb2_grpc.py
new file mode 100644
index 0000000..556ea75
--- /dev/null
+++ b/easyfl/pb/client_service_pb2_grpc.py
@@ -0,0 +1,66 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from easyfl.pb import client_service_pb2 as easyfl_dot_pb_dot_client__service__pb2
+
+
+class ClientServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Operate = channel.unary_unary(
+                '/easyfl.pb.ClientService/Operate',
+                request_serializer=easyfl_dot_pb_dot_client__service__pb2.OperateRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_client__service__pb2.OperateResponse.FromString,
+                )
+
+
+class ClientServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def Operate(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_ClientServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Operate': grpc.unary_unary_rpc_method_handler(
+                    servicer.Operate,
+                    request_deserializer=easyfl_dot_pb_dot_client__service__pb2.OperateRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_client__service__pb2.OperateResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'easyfl.pb.ClientService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class ClientService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Operate(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.ClientService/Operate',
+            easyfl_dot_pb_dot_client__service__pb2.OperateRequest.SerializeToString,
+            easyfl_dot_pb_dot_client__service__pb2.OperateResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
diff --git a/easyfl/pb/common_pb2.py b/easyfl/pb/common_pb2.py
new file mode 100644
index 0000000..8e56167
--- /dev/null
+++ b/easyfl/pb/common_pb2.py
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: easyfl/pb/common.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16\x65\x61syfl/pb/common.proto\x12\teasyfl.pb\">\n\x06Status\x12#\n\x04\x63ode\x18\x01 \x01(\x0e\x32\x15.easyfl.pb.StatusCode\x12\x0f\n\x07message\x18\x02 \x01(\t\"4\n\nTaskMetric\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x15\n\rconfiguration\x18\x02 \x01(\t\"\xcf\x02\n\x0bRoundMetric\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12\x15\n\rtest_accuracy\x18\x03 \x01(\x02\x12\x11\n\ttest_loss\x18\x04 \x01(\x02\x12\x12\n\nround_time\x18\x05 \x01(\x02\x12\x12\n\ntrain_time\x18\x06 \x01(\x02\x12\x11\n\ttest_time\x18\x07 \x01(\x02\x12\x1d\n\x15train_distribute_time\x18\x08 \x01(\x02\x12\x1c\n\x14test_distribute_time\x18\t \x01(\x02\x12\x19\n\x11train_upload_size\x18\n \x01(\x02\x12\x1b\n\x13train_download_size\x18\x0b \x01(\x02\x12\x18\n\x10test_upload_size\x18\x0c \x01(\x02\x12\x1a\n\x12test_download_size\x18\r \x01(\x02\x12\r\n\x05\x65xtra\x18\x0e \x01(\t\"\xf3\x02\n\x0c\x43lientMetric\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12\x11\n\tclient_id\x18\x03 \x01(\t\x12\x16\n\x0etrain_accuracy\x18\x04 \x03(\x02\x12\x12\n\ntrain_loss\x18\x05 \x03(\x02\x12\x15\n\rtest_accuracy\x18\x06 \x01(\x02\x12\x11\n\ttest_loss\x18\x07 \x01(\x02\x12\x12\n\ntrain_time\x18\x08 \x01(\x02\x12\x11\n\ttest_time\x18\t \x01(\x02\x12\x19\n\x11train_upload_time\x18\n \x01(\x02\x12\x18\n\x10test_upload_time\x18\x0b \x01(\x02\x12\x19\n\x11train_upload_size\x18\x0c \x01(\x02\x12\x1b\n\x13train_download_size\x18\r \x01(\x02\x12\x18\n\x10test_upload_size\x18\x0e \x01(\x02\x12\x1a\n\x12test_download_size\x18\x0f \x01(\x02\x12\r\n\x05\x65xtra\x18\x10 \x01(\t*\x82\x01\n\nStatusCode\x12\t\n\x05SC_OK\x10\x00\x12\x0e\n\nSC_UNKNOWN\x10\x01\x12\x16\n\x12SC_INVALID_REQUEST\x10\x02\x12\x18\n\x14SC_DEADLINE_EXCEEDED\x10\x03\x12\x10\n\x0cSC_NOT_FOUND\x10\x04\x12\x15\n\x11SC_ALREADY_EXISTS\x10\x05*;\n\x08\x44\x61taType\x12\x14\n\x10\x44\x41TA_TYPE_PARAMS\x10\x00\x12\x19\n\x15\x44\x41TA_TYPE_PERFORMANCE\x10\x01\x62\x06proto3')
+
+_STATUSCODE = DESCRIPTOR.enum_types_by_name['StatusCode']
+StatusCode = enum_type_wrapper.EnumTypeWrapper(_STATUSCODE)
+_DATATYPE = DESCRIPTOR.enum_types_by_name['DataType']
+DataType = enum_type_wrapper.EnumTypeWrapper(_DATATYPE)
+SC_OK = 0
+SC_UNKNOWN = 1
+SC_INVALID_REQUEST = 2
+SC_DEADLINE_EXCEEDED = 3
+SC_NOT_FOUND = 4
+SC_ALREADY_EXISTS = 5
+DATA_TYPE_PARAMS = 0
+DATA_TYPE_PERFORMANCE = 1
+
+
+_STATUS = DESCRIPTOR.message_types_by_name['Status']
+_TASKMETRIC = DESCRIPTOR.message_types_by_name['TaskMetric']
+_ROUNDMETRIC = DESCRIPTOR.message_types_by_name['RoundMetric']
+_CLIENTMETRIC = DESCRIPTOR.message_types_by_name['ClientMetric']
+Status = _reflection.GeneratedProtocolMessageType('Status', (_message.Message,), {
+  'DESCRIPTOR' : _STATUS,
+  '__module__' : 'easyfl.pb.common_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.Status)
+  })
+_sym_db.RegisterMessage(Status)
+
+TaskMetric = _reflection.GeneratedProtocolMessageType('TaskMetric', (_message.Message,), {
+  'DESCRIPTOR' : _TASKMETRIC,
+  '__module__' : 'easyfl.pb.common_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TaskMetric)
+  })
+_sym_db.RegisterMessage(TaskMetric)
+
+RoundMetric = _reflection.GeneratedProtocolMessageType('RoundMetric', (_message.Message,), {
+  'DESCRIPTOR' : _ROUNDMETRIC,
+  '__module__' : 'easyfl.pb.common_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.RoundMetric)
+  })
+_sym_db.RegisterMessage(RoundMetric)
+
+ClientMetric = _reflection.GeneratedProtocolMessageType('ClientMetric', (_message.Message,), {
+  'DESCRIPTOR' : _CLIENTMETRIC,
+  '__module__' : 'easyfl.pb.common_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.ClientMetric)
+  })
+_sym_db.RegisterMessage(ClientMetric)
+
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _STATUSCODE._serialized_start=868
+  _STATUSCODE._serialized_end=998
+  _DATATYPE._serialized_start=1000
+  _DATATYPE._serialized_end=1059
+  _STATUS._serialized_start=37
+  _STATUS._serialized_end=99
+  _TASKMETRIC._serialized_start=101
+  _TASKMETRIC._serialized_end=153
+  _ROUNDMETRIC._serialized_start=156
+  _ROUNDMETRIC._serialized_end=491
+  _CLIENTMETRIC._serialized_start=494
+  _CLIENTMETRIC._serialized_end=865
+# @@protoc_insertion_point(module_scope)
diff --git a/easyfl/pb/common_pb2_grpc.py b/easyfl/pb/common_pb2_grpc.py
new file mode 100644
index 0000000..2daafff
--- /dev/null
+++ b/easyfl/pb/common_pb2_grpc.py
@@ -0,0 +1,4 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
diff --git a/easyfl/pb/server_service_pb2.py b/easyfl/pb/server_service_pb2.py
new file mode 100644
index 0000000..7e3b95e
--- /dev/null
+++ b/easyfl/pb/server_service_pb2.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: easyfl/pb/server_service.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from easyfl.pb import common_pb2 as easyfl_dot_pb_dot_common__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x65\x61syfl/pb/server_service.proto\x12\teasyfl.pb\x1a\x16\x65\x61syfl/pb/common.proto\"p\n\rUploadRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12\x11\n\tclient_id\x18\x03 \x01(\t\x12)\n\x07\x63ontent\x18\x04 \x01(\x0b\x32\x18.easyfl.pb.UploadContent\"\x8b\x01\n\rUploadContent\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\x0c\x12!\n\x04type\x18\x02 \x01(\x0e\x32\x13.easyfl.pb.DataType\x12\x11\n\tdata_size\x18\x03 \x01(\x03\x12\'\n\x06metric\x18\x04 \x01(\x0b\x32\x17.easyfl.pb.ClientMetric\x12\r\n\x05\x65xtra\x18\x63 \x01(\x0c\"-\n\x0bPerformance\x12\x10\n\x08\x61\x63\x63uracy\x18\x01 \x01(\x02\x12\x0c\n\x04loss\x18\x02 \x01(\x02\"3\n\x0eUploadResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\"W\n\nRunRequest\x12\r\n\x05model\x18\x01 \x01(\x0c\x12\"\n\x07\x63lients\x18\x02 \x03(\x0b\x32\x11.easyfl.pb.Client\x12\x16\n\x0e\x65tcd_addresses\x18\x03 \x01(\t\"0\n\x0bRunResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\"\r\n\x0bStopRequest\"1\n\x0cStopResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\";\n\x06\x43lient\x12\x11\n\tclient_id\x18\x01 \x01(\t\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\t\x12\r\n\x05index\x18\x03 \x01(\x05\x32\xc3\x01\n\rServerService\x12?\n\x06Upload\x12\x18.easyfl.pb.UploadRequest\x1a\x19.easyfl.pb.UploadResponse\"\x00\x12\x36\n\x03Run\x12\x15.easyfl.pb.RunRequest\x1a\x16.easyfl.pb.RunResponse\"\x00\x12\x39\n\x04Stop\x12\x16.easyfl.pb.StopRequest\x1a\x17.easyfl.pb.StopResponse\"\x00\x62\x06proto3')
+
+
+
+_UPLOADREQUEST = DESCRIPTOR.message_types_by_name['UploadRequest']
+_UPLOADCONTENT = DESCRIPTOR.message_types_by_name['UploadContent']
+_PERFORMANCE = DESCRIPTOR.message_types_by_name['Performance']
+_UPLOADRESPONSE = DESCRIPTOR.message_types_by_name['UploadResponse']
+_RUNREQUEST = DESCRIPTOR.message_types_by_name['RunRequest']
+_RUNRESPONSE = DESCRIPTOR.message_types_by_name['RunResponse']
+_STOPREQUEST = DESCRIPTOR.message_types_by_name['StopRequest']
+_STOPRESPONSE = DESCRIPTOR.message_types_by_name['StopResponse']
+_CLIENT = DESCRIPTOR.message_types_by_name['Client']
+UploadRequest = _reflection.GeneratedProtocolMessageType('UploadRequest', (_message.Message,), {
+  'DESCRIPTOR' : _UPLOADREQUEST,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.UploadRequest)
+  })
+_sym_db.RegisterMessage(UploadRequest)
+
+UploadContent = _reflection.GeneratedProtocolMessageType('UploadContent', (_message.Message,), {
+  'DESCRIPTOR' : _UPLOADCONTENT,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.UploadContent)
+  })
+_sym_db.RegisterMessage(UploadContent)
+
+Performance = _reflection.GeneratedProtocolMessageType('Performance', (_message.Message,), {
+  'DESCRIPTOR' : _PERFORMANCE,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.Performance)
+  })
+_sym_db.RegisterMessage(Performance)
+
+UploadResponse = _reflection.GeneratedProtocolMessageType('UploadResponse', (_message.Message,), {
+  'DESCRIPTOR' : _UPLOADRESPONSE,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.UploadResponse)
+  })
+_sym_db.RegisterMessage(UploadResponse)
+
+RunRequest = _reflection.GeneratedProtocolMessageType('RunRequest', (_message.Message,), {
+  'DESCRIPTOR' : _RUNREQUEST,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.RunRequest)
+  })
+_sym_db.RegisterMessage(RunRequest)
+
+RunResponse = _reflection.GeneratedProtocolMessageType('RunResponse', (_message.Message,), {
+  'DESCRIPTOR' : _RUNRESPONSE,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.RunResponse)
+  })
+_sym_db.RegisterMessage(RunResponse)
+
+StopRequest = _reflection.GeneratedProtocolMessageType('StopRequest', (_message.Message,), {
+  'DESCRIPTOR' : _STOPREQUEST,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.StopRequest)
+  })
+_sym_db.RegisterMessage(StopRequest)
+
+StopResponse = _reflection.GeneratedProtocolMessageType('StopResponse', (_message.Message,), {
+  'DESCRIPTOR' : _STOPRESPONSE,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.StopResponse)
+  })
+_sym_db.RegisterMessage(StopResponse)
+
+Client = _reflection.GeneratedProtocolMessageType('Client', (_message.Message,), {
+  'DESCRIPTOR' : _CLIENT,
+  '__module__' : 'easyfl.pb.server_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.Client)
+  })
+_sym_db.RegisterMessage(Client)
+
+_SERVERSERVICE = DESCRIPTOR.services_by_name['ServerService']
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _UPLOADREQUEST._serialized_start=69
+  _UPLOADREQUEST._serialized_end=181
+  _UPLOADCONTENT._serialized_start=184
+  _UPLOADCONTENT._serialized_end=323
+  _PERFORMANCE._serialized_start=325
+  _PERFORMANCE._serialized_end=370
+  _UPLOADRESPONSE._serialized_start=372
+  _UPLOADRESPONSE._serialized_end=423
+  _RUNREQUEST._serialized_start=425
+  _RUNREQUEST._serialized_end=512
+  _RUNRESPONSE._serialized_start=514
+  _RUNRESPONSE._serialized_end=562
+  _STOPREQUEST._serialized_start=564
+  _STOPREQUEST._serialized_end=577
+  _STOPRESPONSE._serialized_start=579
+  _STOPRESPONSE._serialized_end=628
+  _CLIENT._serialized_start=630
+  _CLIENT._serialized_end=689
+  _SERVERSERVICE._serialized_start=692
+  _SERVERSERVICE._serialized_end=887
+# @@protoc_insertion_point(module_scope)
diff --git a/easyfl/pb/server_service_pb2_grpc.py b/easyfl/pb/server_service_pb2_grpc.py
new file mode 100644
index 0000000..adc8c14
--- /dev/null
+++ b/easyfl/pb/server_service_pb2_grpc.py
@@ -0,0 +1,132 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from easyfl.pb import server_service_pb2 as easyfl_dot_pb_dot_server__service__pb2
+
+
+class ServerServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Upload = channel.unary_unary(
+                '/easyfl.pb.ServerService/Upload',
+                request_serializer=easyfl_dot_pb_dot_server__service__pb2.UploadRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_server__service__pb2.UploadResponse.FromString,
+                )
+        self.Run = channel.unary_unary(
+                '/easyfl.pb.ServerService/Run',
+                request_serializer=easyfl_dot_pb_dot_server__service__pb2.RunRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_server__service__pb2.RunResponse.FromString,
+                )
+        self.Stop = channel.unary_unary(
+                '/easyfl.pb.ServerService/Stop',
+                request_serializer=easyfl_dot_pb_dot_server__service__pb2.StopRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_server__service__pb2.StopResponse.FromString,
+                )
+
+
+class ServerServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def Upload(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Run(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Stop(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_ServerServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Upload': grpc.unary_unary_rpc_method_handler(
+                    servicer.Upload,
+                    request_deserializer=easyfl_dot_pb_dot_server__service__pb2.UploadRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_server__service__pb2.UploadResponse.SerializeToString,
+            ),
+            'Run': grpc.unary_unary_rpc_method_handler(
+                    servicer.Run,
+                    request_deserializer=easyfl_dot_pb_dot_server__service__pb2.RunRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_server__service__pb2.RunResponse.SerializeToString,
+            ),
+            'Stop': grpc.unary_unary_rpc_method_handler(
+                    servicer.Stop,
+                    request_deserializer=easyfl_dot_pb_dot_server__service__pb2.StopRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_server__service__pb2.StopResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'easyfl.pb.ServerService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class ServerService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Upload(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.ServerService/Upload',
+            easyfl_dot_pb_dot_server__service__pb2.UploadRequest.SerializeToString,
+            easyfl_dot_pb_dot_server__service__pb2.UploadResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def Run(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.ServerService/Run',
+            easyfl_dot_pb_dot_server__service__pb2.RunRequest.SerializeToString,
+            easyfl_dot_pb_dot_server__service__pb2.RunResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def Stop(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.ServerService/Stop',
+            easyfl_dot_pb_dot_server__service__pb2.StopRequest.SerializeToString,
+            easyfl_dot_pb_dot_server__service__pb2.StopResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
diff --git a/easyfl/pb/tracking_service_pb2.py b/easyfl/pb/tracking_service_pb2.py
new file mode 100644
index 0000000..a6c4701
--- /dev/null
+++ b/easyfl/pb/tracking_service_pb2.py
@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: easyfl/pb/tracking_service.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from easyfl.pb import common_pb2 as easyfl_dot_pb_dot_common__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n easyfl/pb/tracking_service.proto\x12\teasyfl.pb\x1a\x16\x65\x61syfl/pb/common.proto\"D\n\x16TrackTaskMetricRequest\x12*\n\x0btask_metric\x18\x01 \x01(\x0b\x32\x15.easyfl.pb.TaskMetric\"<\n\x17TrackTaskMetricResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\"G\n\x17TrackRoundMetricRequest\x12,\n\x0cround_metric\x18\x01 \x01(\x0b\x32\x16.easyfl.pb.RoundMetric\"=\n\x18TrackRoundMetricResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\"K\n\x18TrackClientMetricRequest\x12/\n\x0e\x63lient_metrics\x18\x01 \x03(\x0b\x32\x17.easyfl.pb.ClientMetric\">\n\x19TrackClientMetricResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\"\xd0\x01\n\x1dTrackClientTrainMetricRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12\x11\n\tclient_id\x18\x03 \x01(\t\x12\x12\n\ntrain_loss\x18\x04 \x03(\x02\x12\x12\n\ntrain_time\x18\x05 \x01(\x02\x12\x19\n\x11train_upload_time\x18\x06 \x01(\x02\x12\x1b\n\x13train_download_size\x18\x07 \x01(\x02\x12\x19\n\x11train_upload_size\x18\x08 \x01(\x02\"C\n\x1eTrackClientTrainMetricResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\"\xc7\x01\n\x1cTrackClientTestMetricRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12\x11\n\tclient_id\x18\x03 \x01(\t\x12\x15\n\rtest_accuracy\x18\x04 \x01(\x02\x12\x11\n\ttest_loss\x18\x05 \x01(\x02\x12\x11\n\ttest_time\x18\x06 \x01(\x02\x12\x18\n\x10test_upload_time\x18\x07 \x01(\x02\x12\x1a\n\x12test_download_size\x18\x08 \x01(\x02\"B\n\x1dTrackClientTestMetricResponse\x12!\n\x06status\x18\x01 \x01(\x0b\x32\x11.easyfl.pb.Status\"Q\n\x1cGetRoundTrainTestTimeRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x0e\n\x06rounds\x18\x02 \x01(\x05\x12\x10\n\x08interval\x18\x03 \x01(\x05\"/\n\rTrainTestTime\x12\x10\n\x08round_id\x18\x01 \x01(\x05\x12\x0c\n\x04time\x18\x02 \x01(\x02\"v\n\x1dGetRoundTrainTestTimeResponse\x12\x32\n\x10train_test_times\x18\x01 \x03(\x0b\x32\x18.easyfl.pb.TrainTestTime\x12!\n\x06status\x18\x02 \x01(\x0b\x32\x11.easyfl.pb.Status\"9\n\x16GetRoundMetricsRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x0e\n\x06rounds\x18\x02 \x03(\x05\"\x88\x01\n\x17GetRoundMetricsResponse\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12\'\n\x07metrics\x18\x03 \x03(\x0b\x32\x16.easyfl.pb.RoundMetric\x12!\n\x06status\x18\x04 \x01(\x0b\x32\x11.easyfl.pb.Status\"P\n\x17GetClientMetricsRequest\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12\x12\n\nclient_ids\x18\x03 \x03(\t\"\x8a\x01\n\x18GetClientMetricsResponse\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08round_id\x18\x02 \x01(\x05\x12(\n\x07metrics\x18\x03 \x03(\x0b\x32\x17.easyfl.pb.ClientMetric\x12!\n\x06status\x18\x04 \x01(\x0b\x32\x11.easyfl.pb.Status2\xb6\x06\n\x0fTrackingService\x12Z\n\x0fTrackTaskMetric\x12!.easyfl.pb.TrackTaskMetricRequest\x1a\".easyfl.pb.TrackTaskMetricResponse\"\x00\x12]\n\x10TrackRoundMetric\x12\".easyfl.pb.TrackRoundMetricRequest\x1a#.easyfl.pb.TrackRoundMetricResponse\"\x00\x12`\n\x11TrackClientMetric\x12#.easyfl.pb.TrackClientMetricRequest\x1a$.easyfl.pb.TrackClientMetricResponse\"\x00\x12o\n\x16TrackClientTrainMetric\x12(.easyfl.pb.TrackClientTrainMetricRequest\x1a).easyfl.pb.TrackClientTrainMetricResponse\"\x00\x12l\n\x15TrackClientTestMetric\x12\'.easyfl.pb.TrackClientTestMetricRequest\x1a(.easyfl.pb.TrackClientTestMetricResponse\"\x00\x12Z\n\x0fGetRoundMetrics\x12!.easyfl.pb.GetRoundMetricsRequest\x1a\".easyfl.pb.GetRoundMetricsResponse\"\x00\x12]\n\x10GetClientMetrics\x12\".easyfl.pb.GetClientMetricsRequest\x1a#.easyfl.pb.GetClientMetricsResponse\"\x00\x12l\n\x15GetRoundTrainTestTime\x12\'.easyfl.pb.GetRoundTrainTestTimeRequest\x1a(.easyfl.pb.GetRoundTrainTestTimeResponse\"\x00\x62\x06proto3')
+
+
+
+_TRACKTASKMETRICREQUEST = DESCRIPTOR.message_types_by_name['TrackTaskMetricRequest']
+_TRACKTASKMETRICRESPONSE = DESCRIPTOR.message_types_by_name['TrackTaskMetricResponse']
+_TRACKROUNDMETRICREQUEST = DESCRIPTOR.message_types_by_name['TrackRoundMetricRequest']
+_TRACKROUNDMETRICRESPONSE = DESCRIPTOR.message_types_by_name['TrackRoundMetricResponse']
+_TRACKCLIENTMETRICREQUEST = DESCRIPTOR.message_types_by_name['TrackClientMetricRequest']
+_TRACKCLIENTMETRICRESPONSE = DESCRIPTOR.message_types_by_name['TrackClientMetricResponse']
+_TRACKCLIENTTRAINMETRICREQUEST = DESCRIPTOR.message_types_by_name['TrackClientTrainMetricRequest']
+_TRACKCLIENTTRAINMETRICRESPONSE = DESCRIPTOR.message_types_by_name['TrackClientTrainMetricResponse']
+_TRACKCLIENTTESTMETRICREQUEST = DESCRIPTOR.message_types_by_name['TrackClientTestMetricRequest']
+_TRACKCLIENTTESTMETRICRESPONSE = DESCRIPTOR.message_types_by_name['TrackClientTestMetricResponse']
+_GETROUNDTRAINTESTTIMEREQUEST = DESCRIPTOR.message_types_by_name['GetRoundTrainTestTimeRequest']
+_TRAINTESTTIME = DESCRIPTOR.message_types_by_name['TrainTestTime']
+_GETROUNDTRAINTESTTIMERESPONSE = DESCRIPTOR.message_types_by_name['GetRoundTrainTestTimeResponse']
+_GETROUNDMETRICSREQUEST = DESCRIPTOR.message_types_by_name['GetRoundMetricsRequest']
+_GETROUNDMETRICSRESPONSE = DESCRIPTOR.message_types_by_name['GetRoundMetricsResponse']
+_GETCLIENTMETRICSREQUEST = DESCRIPTOR.message_types_by_name['GetClientMetricsRequest']
+_GETCLIENTMETRICSRESPONSE = DESCRIPTOR.message_types_by_name['GetClientMetricsResponse']
+TrackTaskMetricRequest = _reflection.GeneratedProtocolMessageType('TrackTaskMetricRequest', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKTASKMETRICREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackTaskMetricRequest)
+  })
+_sym_db.RegisterMessage(TrackTaskMetricRequest)
+
+TrackTaskMetricResponse = _reflection.GeneratedProtocolMessageType('TrackTaskMetricResponse', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKTASKMETRICRESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackTaskMetricResponse)
+  })
+_sym_db.RegisterMessage(TrackTaskMetricResponse)
+
+TrackRoundMetricRequest = _reflection.GeneratedProtocolMessageType('TrackRoundMetricRequest', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKROUNDMETRICREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackRoundMetricRequest)
+  })
+_sym_db.RegisterMessage(TrackRoundMetricRequest)
+
+TrackRoundMetricResponse = _reflection.GeneratedProtocolMessageType('TrackRoundMetricResponse', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKROUNDMETRICRESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackRoundMetricResponse)
+  })
+_sym_db.RegisterMessage(TrackRoundMetricResponse)
+
+TrackClientMetricRequest = _reflection.GeneratedProtocolMessageType('TrackClientMetricRequest', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKCLIENTMETRICREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackClientMetricRequest)
+  })
+_sym_db.RegisterMessage(TrackClientMetricRequest)
+
+TrackClientMetricResponse = _reflection.GeneratedProtocolMessageType('TrackClientMetricResponse', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKCLIENTMETRICRESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackClientMetricResponse)
+  })
+_sym_db.RegisterMessage(TrackClientMetricResponse)
+
+TrackClientTrainMetricRequest = _reflection.GeneratedProtocolMessageType('TrackClientTrainMetricRequest', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKCLIENTTRAINMETRICREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackClientTrainMetricRequest)
+  })
+_sym_db.RegisterMessage(TrackClientTrainMetricRequest)
+
+TrackClientTrainMetricResponse = _reflection.GeneratedProtocolMessageType('TrackClientTrainMetricResponse', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKCLIENTTRAINMETRICRESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackClientTrainMetricResponse)
+  })
+_sym_db.RegisterMessage(TrackClientTrainMetricResponse)
+
+TrackClientTestMetricRequest = _reflection.GeneratedProtocolMessageType('TrackClientTestMetricRequest', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKCLIENTTESTMETRICREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackClientTestMetricRequest)
+  })
+_sym_db.RegisterMessage(TrackClientTestMetricRequest)
+
+TrackClientTestMetricResponse = _reflection.GeneratedProtocolMessageType('TrackClientTestMetricResponse', (_message.Message,), {
+  'DESCRIPTOR' : _TRACKCLIENTTESTMETRICRESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrackClientTestMetricResponse)
+  })
+_sym_db.RegisterMessage(TrackClientTestMetricResponse)
+
+GetRoundTrainTestTimeRequest = _reflection.GeneratedProtocolMessageType('GetRoundTrainTestTimeRequest', (_message.Message,), {
+  'DESCRIPTOR' : _GETROUNDTRAINTESTTIMEREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.GetRoundTrainTestTimeRequest)
+  })
+_sym_db.RegisterMessage(GetRoundTrainTestTimeRequest)
+
+TrainTestTime = _reflection.GeneratedProtocolMessageType('TrainTestTime', (_message.Message,), {
+  'DESCRIPTOR' : _TRAINTESTTIME,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.TrainTestTime)
+  })
+_sym_db.RegisterMessage(TrainTestTime)
+
+GetRoundTrainTestTimeResponse = _reflection.GeneratedProtocolMessageType('GetRoundTrainTestTimeResponse', (_message.Message,), {
+  'DESCRIPTOR' : _GETROUNDTRAINTESTTIMERESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.GetRoundTrainTestTimeResponse)
+  })
+_sym_db.RegisterMessage(GetRoundTrainTestTimeResponse)
+
+GetRoundMetricsRequest = _reflection.GeneratedProtocolMessageType('GetRoundMetricsRequest', (_message.Message,), {
+  'DESCRIPTOR' : _GETROUNDMETRICSREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.GetRoundMetricsRequest)
+  })
+_sym_db.RegisterMessage(GetRoundMetricsRequest)
+
+GetRoundMetricsResponse = _reflection.GeneratedProtocolMessageType('GetRoundMetricsResponse', (_message.Message,), {
+  'DESCRIPTOR' : _GETROUNDMETRICSRESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.GetRoundMetricsResponse)
+  })
+_sym_db.RegisterMessage(GetRoundMetricsResponse)
+
+GetClientMetricsRequest = _reflection.GeneratedProtocolMessageType('GetClientMetricsRequest', (_message.Message,), {
+  'DESCRIPTOR' : _GETCLIENTMETRICSREQUEST,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.GetClientMetricsRequest)
+  })
+_sym_db.RegisterMessage(GetClientMetricsRequest)
+
+GetClientMetricsResponse = _reflection.GeneratedProtocolMessageType('GetClientMetricsResponse', (_message.Message,), {
+  'DESCRIPTOR' : _GETCLIENTMETRICSRESPONSE,
+  '__module__' : 'easyfl.pb.tracking_service_pb2'
+  # @@protoc_insertion_point(class_scope:easyfl.pb.GetClientMetricsResponse)
+  })
+_sym_db.RegisterMessage(GetClientMetricsResponse)
+
+_TRACKINGSERVICE = DESCRIPTOR.services_by_name['TrackingService']
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _TRACKTASKMETRICREQUEST._serialized_start=71
+  _TRACKTASKMETRICREQUEST._serialized_end=139
+  _TRACKTASKMETRICRESPONSE._serialized_start=141
+  _TRACKTASKMETRICRESPONSE._serialized_end=201
+  _TRACKROUNDMETRICREQUEST._serialized_start=203
+  _TRACKROUNDMETRICREQUEST._serialized_end=274
+  _TRACKROUNDMETRICRESPONSE._serialized_start=276
+  _TRACKROUNDMETRICRESPONSE._serialized_end=337
+  _TRACKCLIENTMETRICREQUEST._serialized_start=339
+  _TRACKCLIENTMETRICREQUEST._serialized_end=414
+  _TRACKCLIENTMETRICRESPONSE._serialized_start=416
+  _TRACKCLIENTMETRICRESPONSE._serialized_end=478
+  _TRACKCLIENTTRAINMETRICREQUEST._serialized_start=481
+  _TRACKCLIENTTRAINMETRICREQUEST._serialized_end=689
+  _TRACKCLIENTTRAINMETRICRESPONSE._serialized_start=691
+  _TRACKCLIENTTRAINMETRICRESPONSE._serialized_end=758
+  _TRACKCLIENTTESTMETRICREQUEST._serialized_start=761
+  _TRACKCLIENTTESTMETRICREQUEST._serialized_end=960
+  _TRACKCLIENTTESTMETRICRESPONSE._serialized_start=962
+  _TRACKCLIENTTESTMETRICRESPONSE._serialized_end=1028
+  _GETROUNDTRAINTESTTIMEREQUEST._serialized_start=1030
+  _GETROUNDTRAINTESTTIMEREQUEST._serialized_end=1111
+  _TRAINTESTTIME._serialized_start=1113
+  _TRAINTESTTIME._serialized_end=1160
+  _GETROUNDTRAINTESTTIMERESPONSE._serialized_start=1162
+  _GETROUNDTRAINTESTTIMERESPONSE._serialized_end=1280
+  _GETROUNDMETRICSREQUEST._serialized_start=1282
+  _GETROUNDMETRICSREQUEST._serialized_end=1339
+  _GETROUNDMETRICSRESPONSE._serialized_start=1342
+  _GETROUNDMETRICSRESPONSE._serialized_end=1478
+  _GETCLIENTMETRICSREQUEST._serialized_start=1480
+  _GETCLIENTMETRICSREQUEST._serialized_end=1560
+  _GETCLIENTMETRICSRESPONSE._serialized_start=1563
+  _GETCLIENTMETRICSRESPONSE._serialized_end=1701
+  _TRACKINGSERVICE._serialized_start=1704
+  _TRACKINGSERVICE._serialized_end=2526
+# @@protoc_insertion_point(module_scope)
diff --git a/easyfl/pb/tracking_service_pb2_grpc.py b/easyfl/pb/tracking_service_pb2_grpc.py
new file mode 100644
index 0000000..6495eab
--- /dev/null
+++ b/easyfl/pb/tracking_service_pb2_grpc.py
@@ -0,0 +1,297 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from easyfl.pb import tracking_service_pb2 as easyfl_dot_pb_dot_tracking__service__pb2
+
+
+class TrackingServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.TrackTaskMetric = channel.unary_unary(
+                '/easyfl.pb.TrackingService/TrackTaskMetric',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackTaskMetricRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackTaskMetricResponse.FromString,
+                )
+        self.TrackRoundMetric = channel.unary_unary(
+                '/easyfl.pb.TrackingService/TrackRoundMetric',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackRoundMetricRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackRoundMetricResponse.FromString,
+                )
+        self.TrackClientMetric = channel.unary_unary(
+                '/easyfl.pb.TrackingService/TrackClientMetric',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientMetricRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientMetricResponse.FromString,
+                )
+        self.TrackClientTrainMetric = channel.unary_unary(
+                '/easyfl.pb.TrackingService/TrackClientTrainMetric',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTrainMetricRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTrainMetricResponse.FromString,
+                )
+        self.TrackClientTestMetric = channel.unary_unary(
+                '/easyfl.pb.TrackingService/TrackClientTestMetric',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTestMetricRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTestMetricResponse.FromString,
+                )
+        self.GetRoundMetrics = channel.unary_unary(
+                '/easyfl.pb.TrackingService/GetRoundMetrics',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundMetricsRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundMetricsResponse.FromString,
+                )
+        self.GetClientMetrics = channel.unary_unary(
+                '/easyfl.pb.TrackingService/GetClientMetrics',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.GetClientMetricsRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.GetClientMetricsResponse.FromString,
+                )
+        self.GetRoundTrainTestTime = channel.unary_unary(
+                '/easyfl.pb.TrackingService/GetRoundTrainTestTime',
+                request_serializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundTrainTestTimeRequest.SerializeToString,
+                response_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundTrainTestTimeResponse.FromString,
+                )
+
+
+class TrackingServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def TrackTaskMetric(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def TrackRoundMetric(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def TrackClientMetric(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def TrackClientTrainMetric(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def TrackClientTestMetric(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetRoundMetrics(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetClientMetrics(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetRoundTrainTestTime(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_TrackingServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'TrackTaskMetric': grpc.unary_unary_rpc_method_handler(
+                    servicer.TrackTaskMetric,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackTaskMetricRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackTaskMetricResponse.SerializeToString,
+            ),
+            'TrackRoundMetric': grpc.unary_unary_rpc_method_handler(
+                    servicer.TrackRoundMetric,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackRoundMetricRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackRoundMetricResponse.SerializeToString,
+            ),
+            'TrackClientMetric': grpc.unary_unary_rpc_method_handler(
+                    servicer.TrackClientMetric,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientMetricRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientMetricResponse.SerializeToString,
+            ),
+            'TrackClientTrainMetric': grpc.unary_unary_rpc_method_handler(
+                    servicer.TrackClientTrainMetric,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTrainMetricRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTrainMetricResponse.SerializeToString,
+            ),
+            'TrackClientTestMetric': grpc.unary_unary_rpc_method_handler(
+                    servicer.TrackClientTestMetric,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTestMetricRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTestMetricResponse.SerializeToString,
+            ),
+            'GetRoundMetrics': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetRoundMetrics,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundMetricsRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundMetricsResponse.SerializeToString,
+            ),
+            'GetClientMetrics': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetClientMetrics,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.GetClientMetricsRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.GetClientMetricsResponse.SerializeToString,
+            ),
+            'GetRoundTrainTestTime': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetRoundTrainTestTime,
+                    request_deserializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundTrainTestTimeRequest.FromString,
+                    response_serializer=easyfl_dot_pb_dot_tracking__service__pb2.GetRoundTrainTestTimeResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'easyfl.pb.TrackingService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class TrackingService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def TrackTaskMetric(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/TrackTaskMetric',
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackTaskMetricRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackTaskMetricResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def TrackRoundMetric(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/TrackRoundMetric',
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackRoundMetricRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackRoundMetricResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def TrackClientMetric(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/TrackClientMetric',
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackClientMetricRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackClientMetricResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def TrackClientTrainMetric(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/TrackClientTrainMetric',
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTrainMetricRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTrainMetricResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def TrackClientTestMetric(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/TrackClientTestMetric',
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTestMetricRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.TrackClientTestMetricResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetRoundMetrics(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/GetRoundMetrics',
+            easyfl_dot_pb_dot_tracking__service__pb2.GetRoundMetricsRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.GetRoundMetricsResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetClientMetrics(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/GetClientMetrics',
+            easyfl_dot_pb_dot_tracking__service__pb2.GetClientMetricsRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.GetClientMetricsResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetRoundTrainTestTime(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/easyfl.pb.TrackingService/GetRoundTrainTestTime',
+            easyfl_dot_pb_dot_tracking__service__pb2.GetRoundTrainTestTimeRequest.SerializeToString,
+            easyfl_dot_pb_dot_tracking__service__pb2.GetRoundTrainTestTimeResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
diff --git a/easyfl/protocol/__init__.py b/easyfl/protocol/__init__.py
new file mode 100644
index 0000000..25a7bb3
--- /dev/null
+++ b/easyfl/protocol/__init__.py
@@ -0,0 +1,3 @@
+from easyfl.protocol.codec import marshal, unmarshal
+
+__all__ = ['marshal', 'unmarshal']
diff --git a/easyfl/protocol/codec.py b/easyfl/protocol/codec.py
new file mode 100644
index 0000000..16a8614
--- /dev/null
+++ b/easyfl/protocol/codec.py
@@ -0,0 +1,9 @@
+import pickle
+
+
+def marshal(raw_data):
+    return pickle.dumps(raw_data)
+
+
+def unmarshal(data):
+    return pickle.loads(data)
diff --git a/easyfl/registor/Dockerfile b/easyfl/registor/Dockerfile
new file mode 100644
index 0000000..bdeb177
--- /dev/null
+++ b/easyfl/registor/Dockerfile
@@ -0,0 +1,25 @@
+FROM ubuntu:16.04
+MAINTAINER Zhuang Weiming <wingalong@gmail.com>
+
+RUN apt update
+RUN apt -y install software-properties-common
+RUN add-apt-repository ppa:deadsnakes/ppa
+RUN apt update
+RUN apt install -y python3.7
+RUN apt-get update
+RUN apt-get install -y wget python3-pip python3-dev libssl-dev libffi-dev bash
+
+RUN mkdir /app
+WORKDIR /app
+
+RUN wget https://github.com/jwilder/docker-gen/releases/download/0.3.3/docker-gen-linux-amd64-0.3.3.tar.gz
+RUN tar xvzf docker-gen-linux-amd64-0.3.3.tar.gz -C /usr/local/bin
+
+RUN pip3 install --upgrade pip setuptools wheel
+RUN pip3 install etcd3
+
+ADD . /app
+
+ENV DOCKER_HOST unix:///var/run/docker.sock
+
+CMD docker-gen -interval 10 -watch -notify "python3 /tmp/register.py" etcd.tmpl /tmp/register.py
diff --git a/easyfl/registor/README.md b/easyfl/registor/README.md
new file mode 100644
index 0000000..e6875b9
--- /dev/null
+++ b/easyfl/registor/README.md
@@ -0,0 +1,60 @@
+# Docker Register
+
+docker-register sets up a container running [docker-gen][1].  docker-gen dynamically generate a
+python script when containers are started and stopped.  This generated script registers the running
+containers host IP and port in etcd with a TTL.  It works in tandem with docker-discover which
+generates haproxy routes on the host to forward requests to registered containers.
+
+Together, they implement [service discovery][2] for docker containers with a similar architecture
+to [SmartStack][3]. docker-register is analagous to [nerve][4] in the SmartStack system.
+
+See also [Docker Service Discovery Using Etcd and Haproxy][5]
+
+
+### Upgrade
+
+The original [docker-register](https://github.com/jwilder/docker-register) only supports etcd v2.
+
+It has been modified to support etcd v3. 
+
+You can build the docker image with following command and follow the same usage.
+```
+docker build -t docker-register -f Dockerfile .
+```
+
+
+### Usage
+
+To run it:
+
+    $ docker run -d -e HOST_IP=1.2.3.4 -e ETCD_HOST=1.2.3.4:4001 -v /var/run/docker.sock:/var/run/docker.sock -t jwilder/docker-register
+
+Then start any containers you want to be discoverable and publish their exposed port to the host.
+
+    $ docker run -d -P -t ...
+
+If you run the container on multiple hosts, they will be grouped together automatically.
+
+### Limitations
+
+There are a few simplications that were made:
+
+* *Containers can only expose one port* - This is a simplification but if the container `EXPOSE`s
+multiple ports, it won't be registered in etcd.
+* *Exposed ports must be unique to the service* - Each container must expose it's service on a unique
+port.  For example, if you have two different backend web services and they both expose their service
+over port 80, then one will need to use a port 80 and the other a different port.
+
+
+[1]: https://github.com/jwilder/docker-gen
+[2]: http://jasonwilder.com/blog/2014/02/04/service-discovery-in-the-cloud/
+[3]: http://nerds.airbnb.com/smartstack-service-discovery-cloud/
+[4]: https://github.com/airbnb/nerve
+[5]: http://jasonwilder.com/blog/2014/07/15/docker-service-discovery/
+
+### TODO
+
+* Support http, udp proxying
+* Support multiple ports
+* Make ETCD prefix configurable
+* Support other backends (consul, zookeeper, redis, etc.)
diff --git a/easyfl/registor/docker-register.service b/easyfl/registor/docker-register.service
new file mode 100644
index 0000000..d170016
--- /dev/null
+++ b/easyfl/registor/docker-register.service
@@ -0,0 +1,15 @@
+[Unit]
+Description=docker-register
+After=docker.service
+
+[Service]
+EnvironmentFile=/etc/environment
+TimeoutStartSec=0
+ExecStartPre=-/usr/bin/docker kill docker-register
+ExecStartPre=-/usr/bin/docker rm docker-register
+ExecStartPre=/usr/bin/docker pull jwilder/docker-register
+ExecStart=/usr/bin/docker run --name docker-register -e HOST_IP=${COREOS_PRIVATE_IPV4} -e ETCD_HOST=${COREOS_PRIVATE_IPV4}:4001 -v /var/run/docker.sock:/var/run/docker.sock jwilder/docker-register
+ExecStop=/usr/bin/docker stop docker-register
+
+[X-Fleet]
+Global=true
diff --git a/easyfl/registor/etcd.tmpl b/easyfl/registor/etcd.tmpl
new file mode 100644
index 0000000..324a2ad
--- /dev/null
+++ b/easyfl/registor/etcd.tmpl
@@ -0,0 +1,37 @@
+
+#!/usr/bin/python
+
+import etcd3
+import sys
+
+etcd_host = "{{ .Env.ETCD_HOST }}"
+if not etcd_host:
+    print("ETCD_HOST not set")
+    sys.exit(1)
+
+port = 2379
+host = etcd_host
+
+if ":" in etcd_host:
+    host, port = etcd_host.split(":")
+
+print("{}:{}".format(host, port))
+
+client = etcd3.client(host=host, port=int(port))
+
+{{ $local := . }}
+{{ range $key, $value := . }}
+
+    {{ $addrLen := len $value.Addresses }}
+
+    {{ if gt $addrLen 0 }}
+
+        {{ with $address := index $value.Addresses 0 }}
+            {{ if $address.HostPort}}
+
+client.put("/backends/{{ $value.Image.Repository }}/{{ $local.Env.HOST_IP }}:{{ $address.HostPort }}", "{{ $value.Name }}")
+
+            {{end}}
+        {{end}}
+    {{end}}
+{{end}}
diff --git a/easyfl/registry/__init__.py b/easyfl/registry/__init__.py
new file mode 100644
index 0000000..40776e7
--- /dev/null
+++ b/easyfl/registry/__init__.py
@@ -0,0 +1,4 @@
+from easyfl.registry.registry import get_clients, SOURCES
+from easyfl.registry.etcd_client import EtcdClient
+
+__all__ = ['get_clients', 'EtcdClient']
diff --git a/easyfl/registry/etcd_client.py b/easyfl/registry/etcd_client.py
new file mode 100644
index 0000000..6f51c1c
--- /dev/null
+++ b/easyfl/registry/etcd_client.py
@@ -0,0 +1,207 @@
+import random
+import threading
+from contextlib import contextmanager
+
+import etcd3
+
+from easyfl.registry import mock_etcd
+from easyfl.registry.vclient import VirtualClient
+
+
+class EtcdClient(object):
+    """Etcd client to connect and communicate with etcd service.
+    Etcd is the serves as the registry for remote training.
+    Clients register themselves in etcd and server queries etcd to get client addresses.
+
+    Args:
+        name (str): The name of etcd.
+        addrs (str): Etcd addresses, format: "<ip>:<port>,<ip>:<port>".
+        base_dir (str): The prefix of all etcd requests, default to "backends".
+        use_mock_etcd (bool): Whether use mocked etcd for testing.
+    """
+
+    ETCD_CLIENT_POOL_LOCK = threading.Lock()
+    ETCD_CLIENT_POOL = {}
+    ETCD_CLIENT_POOL_DESTROY = False
+
+    class Event(object):
+        def __init__(self, event, base_dir):
+            self._event = event
+            self._base_dir = base_dir
+
+        def __getattr__(self, attr):
+            return getattr(self._event, attr)
+
+        @property
+        def key(self):
+            return EtcdClient.normalize_output_key(self._event.key, self._base_dir)
+
+    def __init__(self, name, addrs, base_dir, use_mock_etcd=False):
+        self._name = name
+        self._base_dir = '/' + EtcdClient._normalize_input_key(base_dir)
+        self._addrs = self._normalize_addr(addrs)
+        if len(self._addrs) == 0:
+            raise ValueError('Empty hosts EtcdClient')
+        self._cur_addr_idx = random.randint(0, len(self._addrs) - 1)
+        self._use_mock_etcd = use_mock_etcd
+
+    def get_data(self, key):
+        addr = self._get_next_addr()
+        with EtcdClient.closing(self._name, addr, self._use_mock_etcd) as clnt:
+            return clnt.get(self._generate_path(key))[0]
+
+    def set_data(self, key, data):
+        addr = self._get_next_addr()
+        with EtcdClient.closing(self._name, addr, self._use_mock_etcd) as clnt:
+            clnt.put(self._generate_path(key), data)
+
+    def delete(self, key):
+        addr = self._get_next_addr()
+        with EtcdClient.closing(self._name, addr, self._use_mock_etcd) as clnt:
+            return clnt.delete(self._generate_path(key))
+
+    def delete_prefix(self, key):
+        addr = self._get_next_addr()
+        with EtcdClient.closing(self._name, addr, self._use_mock_etcd) as clnt:
+            return clnt.delete_prefix(self._generate_path(key))
+
+    def cas(self, key, old_data, new_data):
+        addr = self._get_next_addr()
+        with EtcdClient.closing(self._name, addr, self._use_mock_etcd) as clnt:
+            etcd_path = self._generate_path(key)
+            if old_data is None:
+                return clnt.put_if_not_exists(etcd_path, new_data)
+            return clnt.replace(etcd_path, old_data, new_data)
+
+    def watch_key(self, key):
+        addr = self._get_next_addr()
+        with EtcdClient.closing(self._name, addr, self._use_mock_etcd) as clnt:
+            notifier, cancel = clnt.watch(self._generate_path(key))
+
+            def prefix_extractor(notifier, base_dir):
+                while True:
+                    try:
+                        yield EtcdClient.Event(next(notifier), base_dir)
+                    except StopIteration:
+                        break
+
+            return prefix_extractor(notifier, self._base_dir), cancel
+
+    def get_prefix_kvs(self, prefix, ignore_prefix=False):
+        addr = self._get_next_addr()
+        kvs = []
+        path = self._generate_path(prefix)
+        with EtcdClient.closing(self._name, addr, self._use_mock_etcd) as clnt:
+            for (data, key) in clnt.get_prefix(path, sort_order='ascend'):
+                if ignore_prefix and key.key == path.encode():
+                    continue
+                nkey = EtcdClient.normalize_output_key(key.key, self._base_dir)
+                kvs.append((nkey, data))
+        return kvs
+
+    def get_clients(self, prefix):
+        """Retrieve client addresses from etcd using prefix.
+
+        Args:
+            prefix (str): the prefix of clients addresses; default is the docker image name "easyfl-client"
+
+        Returns:
+            list[:obj:`VirtualClient`]: A list of clients.
+        """
+        key_value_tuples = self.get_prefix_kvs(prefix)
+        clients = []
+        index = 0
+        for (key_byte, value_byte) in key_value_tuples:
+            key, value = key_byte.decode("utf-8"), value_byte.decode("utf-8")
+            parts = key.split("/")
+            if len(parts) <= 1:
+                continue
+
+            addr = parts[1]
+            if not self._is_addr(addr):
+                continue
+
+            clients.append(VirtualClient(value, addr, index))
+            index += 1
+        return clients
+
+    def _is_addr(self, address):
+        return len(address.split(":")) > 1
+
+    def _generate_path(self, key):
+        return '/'.join([self._base_dir, self._normalize_input_key(key)])
+
+    def _get_next_addr(self):
+        return self._addrs[random.randint(0, len(self._addrs) - 1)]
+
+    @staticmethod
+    def _normalize_addr(addrs):
+        naddrs = []
+        for raw_addr in addrs.split(','):
+            (host, port_str) = raw_addr.split(':')
+            try:
+                port = int(port_str)
+                if port < 0 or port > 65535:
+                    raise ValueError('port {} is out of range')
+            except ValueError:
+                raise ValueError('{} is not a valid port'.format(port_str))
+            naddrs.append((host, port))
+        return naddrs
+
+    @staticmethod
+    def _normalize_input_key(key):
+        skip_cnt = 0
+        while key[skip_cnt] == '.' or key[skip_cnt] == '/':
+            skip_cnt += 1
+        if skip_cnt > 0:
+            return key[skip_cnt:]
+        return key
+
+    @staticmethod
+    def normalize_output_key(key, base_dir):
+        if isinstance(base_dir, str):
+            assert key.startswith(base_dir.encode())
+        else:
+            assert key.startswith(base_dir)
+        return key[len(base_dir) + 1:]
+
+    @classmethod
+    @contextmanager
+    def closing(cls, name, addr, use_mock_etcd):
+        clnt = None
+        with cls.ETCD_CLIENT_POOL_LOCK:
+            if (name in cls.ETCD_CLIENT_POOL and
+                    len(cls.ETCD_CLIENT_POOL[name]) > 0):
+                clnt = cls.ETCD_CLIENT_POOL[name][0]
+                cls.ETCD_CLIENT_POOL[name] = cls.ETCD_CLIENT_POOL[name][1:]
+        if clnt is None:
+            try:
+                if use_mock_etcd:
+                    clnt = mock_etcd.MockEtcdClient(addr[0], addr[1])
+                else:
+                    clnt = etcd3.client(host=addr[0], port=addr[1])
+            except Exception as e:
+                clnt.close()
+                raise e
+        try:
+            yield clnt
+        except Exception as e:
+            clnt.close()
+            raise e
+        else:
+            with cls.ETCD_CLIENT_POOL_LOCK:
+                if cls.ETCD_CLIENT_POOL_DESTROY:
+                    clnt.close()
+                else:
+                    if name not in cls.ETCD_CLIENT_POOL:
+                        cls.ETCD_CLIENT_POOL[name] = [clnt]
+                    else:
+                        cls.ETCD_CLIENT_POOL[name].append(clnt)
+
+    @classmethod
+    def destory_client_pool(cls):
+        with cls.ETCD_CLIENT_POOL_LOCK:
+            cls.ETCD_CLIENT_POOL_DESTROY = True
+            for _, clnts in cls.ETCD_CLIENT_POOL.items():
+                for clnt in clnts:
+                    clnt.close()
diff --git a/easyfl/registry/k8s.py b/easyfl/registry/k8s.py
new file mode 100644
index 0000000..04a2a55
--- /dev/null
+++ b/easyfl/registry/k8s.py
@@ -0,0 +1,29 @@
+from kubernetes import client, config
+from easyfl.registry.vclient import VirtualClient
+
+
+def get_clients():
+    """Get clients in kubernetes based on client field selector.
+
+    Returns:
+        list[:obj:`VirtualClient`]: A list of clients.
+    """
+    config.load_kube_config()
+
+    v1 = client.CoreV1Api()
+
+    ret = v1.list_namespaced_endpoints('easyfl', watch=False, field_selector="metadata.name=easyfl-client-svc")
+    
+    clients = []
+    for record in ret.items:
+        for subset in record.subsets:
+            port = subset.ports[0].port            
+            for index, address in enumerate(subset.addresses):
+                addr = "{}:{}".format(address.ip, port)
+                c = VirtualClient(address.target_ref.name, addr, index)
+                clients.append(c)
+    return clients
+    
+
+if __name__ == '__main__':
+    get_clients()
diff --git a/easyfl/registry/mock_etcd.py b/easyfl/registry/mock_etcd.py
new file mode 100644
index 0000000..ed578c7
--- /dev/null
+++ b/easyfl/registry/mock_etcd.py
@@ -0,0 +1,155 @@
+import threading
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+
+
+class MockEtcd(object):
+    class KV(object):
+        def __init__(self, key, value):
+            self._key = key
+            self._value = value
+
+        @property
+        def key(self):
+            if isinstance(self._key, str):
+                return self._key.encode()
+            return self._key
+
+        @property
+        def value(self):
+            if isinstance(self._value, str):
+                return self._value.encode()
+            return self._value
+
+    class EventNotifier(object):
+        def __init__(self, clnt):
+            self._queue = queue.Queue()
+            self._clnt = clnt
+
+        def get_client_belongto(self):
+            return self._clnt
+
+        def notify(self, key, value):
+            self._queue.put(MockEtcd.KV(key, value))
+
+        def wait_for_event(self):
+            while True:
+                event = self._queue.get()
+                if event is None:
+                    return
+                yield event
+
+        def cancel(self):
+            self._queue.put(None)
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._data = {}
+        self._event_notifier = {}
+
+    def get(self, key):
+        with self._lock:
+            if key in self._data:
+                if isinstance(self._data[key], str):
+                    return self._data[key].encode(), None
+                return self._data[key], None
+            return None, None
+
+    def put(self, key, value):
+        with self._lock:
+            self._data[key] = value
+            self._notify_if_need(key)
+
+    def delete(self, key):
+        with self._lock:
+            self._data.pop(key, None)
+            self._notify_if_need(key)
+
+    def delete_prefix(self, prefix):
+        with self._lock:
+            deleted = []
+            for key in self._data:
+                if key.startswith(prefix):
+                    deleted.append(key)
+            for key in deleted:
+                self._data.pop(key, None)
+                self._notify_if_need(key)
+
+    def put_if_not_exists(self, key, value):
+        with self._lock:
+            if key in self._data:
+                return False
+            self._data[key] = value
+            self._notify_if_need(key)
+            return True
+
+    def replace(self, key, old_value, new_value):
+        with self._lock:
+            stored = None
+            if key in self._data:
+                stored = self._data[key]
+            if stored != old_value:
+                return False
+            self._data[key] = new_value
+            self._notify_if_need(key)
+            return True
+
+    def watch(self, key, clnt):
+        with self._lock:
+            en = MockEtcd.EventNotifier(clnt)
+            if key not in self._event_notifier:
+                self._event_notifier[key] = [en]
+            else:
+                self._event_notifier[key].append(en)
+            return en.wait_for_event(), en.cancel
+
+    def close(self, clnt):
+        with self._lock:
+            for key in self._event_notifier:
+                self._event_notifier[key] = [
+                        en for en in self._event_notifier[key] if
+                        en.get_client_belongto() == clnt
+                    ]
+
+    def get_prefix(self, prefix, sort_order='ascend'):
+        kvs = []
+        with self._lock:
+            for key, value in self._data.items():
+                if key.startswith(prefix):
+                    kvs.append((value.encode(), MockEtcd.KV(key, None)))
+            if sort_order == 'descend':
+                kvs = sorted(kvs, key=lambda kv: kv[1].key, reverse=True)
+            elif sort_order == 'ascend':
+                kvs = sorted(kvs, key=lambda kv: kv[1].key, reverse=False)
+            return kvs
+
+    def _notify_if_need(self, key):
+        if key in self._event_notifier:
+            value = None
+            if key in self._data:
+                value = self._data[key]
+            for en in self._event_notifier[key]:
+                en.notify(key, value)
+
+
+class MockEtcdClient(object):
+    POOL_LOCK = threading.Lock()
+    MOCK_ETCD_POOL = {}
+
+    def __init__(self, host, port):
+        key = '{}:{}'.format(host, port)
+        with self.POOL_LOCK:
+            if key not in self.MOCK_ETCD_POOL:
+                self.MOCK_ETCD_POOL[key] = MockEtcd()
+            self._mock_etcd = self.MOCK_ETCD_POOL[key]
+
+    def __getattr__(self, attr):
+        return getattr(self._mock_etcd, attr)
+
+    def watch(self, key):
+        return self._mock_etcd.watch(key, self)
+
+    def close(self):
+        self._mock_etcd.close(self)
diff --git a/easyfl/registry/registry.py b/easyfl/registry/registry.py
new file mode 100644
index 0000000..f8fc4fb
--- /dev/null
+++ b/easyfl/registry/registry.py
@@ -0,0 +1,31 @@
+from easyfl.registry import etcd_client
+from easyfl.registry import k8s
+from easyfl.registry.vclient import VirtualClient
+
+SOURCE_MANUAL = "manual"
+SOURCE_ETCD = "etcd"
+SOURCE_K8S = "kubernetes"
+SOURCES = [SOURCE_MANUAL, SOURCE_ETCD, SOURCE_K8S]
+
+CLIENT_DOCKER_IMAGE = "easyfl-client"
+
+
+def get_clients(source, etcd_addresses=None):
+    """Get clients from registry.
+
+    Args:
+        source (str): Registry source, options: manual, etcd, kubernetes.
+        etcd_addresses (str, optional): The addresses of etcd service.
+    Returns:
+        list[:obj:`VirtualClient`]: A list of clients with addresses.
+    """
+
+    if source == SOURCE_MANUAL:
+        return [VirtualClient("1", "localhost:23400", 0), VirtualClient("2", "localhost:23401", 1)]
+    elif source == SOURCE_ETCD:
+        etcd = etcd_client.EtcdClient("server", etcd_addresses, "backends")
+        return etcd.get_clients(CLIENT_DOCKER_IMAGE)
+    elif source == SOURCE_K8S:
+        return k8s.get_clients()
+    else:
+        raise ValueError("Not supported source type")
diff --git a/easyfl/registry/vclient.py b/easyfl/registry/vclient.py
new file mode 100644
index 0000000..6cb8b1e
--- /dev/null
+++ b/easyfl/registry/vclient.py
@@ -0,0 +1,5 @@
+class VirtualClient(object):
+    def __init__(self, name, address, index):
+        self.id = name
+        self.address = address
+        self.index = index
diff --git a/easyfl/server/__init__.py b/easyfl/server/__init__.py
new file mode 100644
index 0000000..8f101cd
--- /dev/null
+++ b/easyfl/server/__init__.py
@@ -0,0 +1,7 @@
+from easyfl.server.base import BaseServer
+from easyfl.server.service import ServerService
+from easyfl.server.strategies import federated_averaging, federated_averaging_only_params, \
+    weighted_sum, weighted_sum_only_params
+
+__all__ = ['BaseServer', 'ServerService', 'federated_averaging', 'federated_averaging_only_params',
+           'weighted_sum', 'weighted_sum_only_params']
diff --git a/easyfl/server/base.py b/easyfl/server/base.py
new file mode 100644
index 0000000..faa9818
--- /dev/null
+++ b/easyfl/server/base.py
@@ -0,0 +1,917 @@
+import argparse
+import concurrent.futures
+import copy
+import logging
+import os
+import threading
+import time
+
+import numpy as np
+import torch
+import torch.distributed as dist
+from omegaconf import OmegaConf
+
+from easyfl.communication import grpc_wrapper
+from easyfl.datasets import TEST_IN_SERVER
+from easyfl.distributed import grouping, reduce_models, reduce_models_only_params, \
+    reduce_value, reduce_values, reduce_weighted_values, gather_value
+from easyfl.distributed.distributed import CPU, GREEDY_GROUPING
+from easyfl.pb import client_service_pb2 as client_pb
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.protocol import codec
+from easyfl.registry.etcd_client import EtcdClient
+from easyfl.server import strategies
+from easyfl.server.service import ServerService
+from easyfl.tracking import metric
+from easyfl.tracking.client import init_tracking
+from easyfl.utils.float import rounding
+
+logger = logging.getLogger(__name__)
+
+# train and test params
+MODEL = "model"
+DATA_SIZE = "data_size"
+ACCURACY = "accuracy"
+LOSS = "loss"
+CLIENT_METRICS = "client_metrics"
+
+FEDERATED_AVERAGE = "FedAvg"
+EQUAL_AVERAGE = "equal"
+
+AGGREGATION_CONTENT_ALL = "all"
+AGGREGATION_CONTENT_PARAMS = "parameters"
+
+
+def create_argument_parser():
+    """Create argument parser with arguments/configurations for starting server service.
+
+    Returns:
+        argparse.ArgumentParser: The parser with server service arguments.
+    """
+    parser = argparse.ArgumentParser(description='Federated Server')
+    parser.add_argument('--local-port',
+                        type=int,
+                        default=22999,
+                        help='Listen port of the client')
+    parser.add_argument('--tracker-addr',
+                        type=str,
+                        default="localhost:12666",
+                        help='Address of tracking service in [IP]:[PORT] format')
+    parser.add_argument('--is-remote',
+                        type=bool,
+                        default=False,
+                        help='Whether start as a remote server.')
+
+    return parser
+
+
+class BaseServer(object):
+    """Default implementation of federated learning server.
+
+    Args:
+        conf (omegaconf.dictconfig.DictConfig): Configurations of EasyFL.
+        test_data (:obj:`FederatedDataset`): Test dataset for centralized testing in server, optional.
+        val_data (:obj:`FederatedDataset`): Validation dataset for centralized validation in server, optional.
+        is_remote (bool): A flag to indicate whether start remote training.
+        local_port (int): The port of remote server service.
+
+    Override the class and functions to implement customized server.
+
+    Example:
+        >>> from easyfl.server import BaseServer
+        >>> class CustomizedServer(BaseServer):
+        >>>     def __init__(self, conf, test_data=None, val_data=None, is_remote=False, local_port=22999):
+        >>>         super(CustomizedServer, self).__init__(conf, test_data, val_data, is_remote, local_port)
+        >>>         pass  # more initialization of attributes.
+        >>>
+        >>>     def aggregation(self):
+        >>>         # Implement customized aggregation method, which overwrites the default aggregation method.
+        >>>         pass
+    """
+
+    def __init__(self,
+                 conf,
+                 test_data=None,
+                 val_data=None,
+                 is_remote=False,
+                 local_port=22999):
+        self.conf = conf
+        self.test_data = test_data
+        self.val_data = val_data
+        self.is_remote = is_remote
+        self.local_port = local_port
+        self._is_training = False
+        self._should_stop = False
+
+        self._current_round = -1
+        self._client_uploads = {}
+        self._model = None
+        self._compressed_model = None
+        self._clients = None
+        self._etcd = None
+        self.selected_clients = []
+        self.grouped_clients = []
+
+        self._server_metric = None
+        self._round_time = None
+        self._begin_train_time = None  # training begin time for a round
+        self._start_time = None  # training start time for a task
+        self.client_stubs = {}
+
+        if self.conf.is_distributed:
+            self.default_time = self.conf.resource_heterogeneous.initial_default_time
+
+        self._cumulative_times = []  # cumulative training after each test
+        self._accuracies = []
+
+        self._condition = threading.Condition()
+
+        self._tracker = None
+        self.init_tracker()
+
+    def start(self, model, clients):
+        """Start federated learning process, including training and testing.
+
+        Args:
+            model (nn.Module): The model to train.
+            clients (list[:obj:`BaseClient`]|list[str]): Available clients.
+                Clients are actually client grpc addresses when in remote training.
+        """
+        # Setup
+        self._start_time = time.time()
+        self._reset()
+        self.set_model(model)
+        self.set_clients(clients)
+
+        if self._should_track():
+            self._tracker.create_task(self.conf.task_id, OmegaConf.to_container(self.conf))
+
+        # Get initial testing accuracies
+        if self.conf.server.test_all:
+            if self._should_track():
+                self._tracker.set_round(self._current_round)
+            self.test()
+            self.save_tracker()
+
+        while not self.should_stop():
+            self._round_time = time.time()
+
+            self._current_round += 1
+            self.print_("\n-------- round {} --------".format(self._current_round))
+
+            # Train
+            self.pre_train()
+            self.train()
+            self.post_train()
+
+            # Test
+            if self._do_every(self.conf.server.test_every, self._current_round, self.conf.server.rounds):
+                self.pre_test()
+                self.test()
+                self.post_test()
+
+            # Save Model
+            self.save_model()
+
+            self.track(metric.ROUND_TIME, time.time() - self._round_time)
+            self.save_tracker()
+
+        self.print_("Accuracies: {}".format(rounding(self._accuracies, 4)))
+        self.print_("Cumulative training time: {}".format(rounding(self._cumulative_times, 2)))
+
+    def stop(self):
+        """Set the flag to indicate training should stop."""
+        self._should_stop = True
+
+    def pre_train(self):
+        """Preprocessing before training."""
+        pass
+
+    def train(self):
+        """Training process of federated learning."""
+        self.print_("--- start training ---")
+
+        self.selection(self._clients, self.conf.server.clients_per_round)
+        self.grouping_for_distributed()
+        self.compression()
+
+        begin_train_time = time.time()
+
+        self.distribution_to_train()
+        self.aggregation()
+
+        train_time = time.time() - begin_train_time
+        self.print_("Server train time: {}".format(train_time))
+        self.track(metric.TRAIN_TIME, train_time)
+
+    def post_train(self):
+        """Postprocessing after training."""
+        pass
+
+    def pre_test(self):
+        """Preprocessing before testing."""
+        pass
+
+    def test(self):
+        """Testing process of federated learning."""
+        self.print_("--- start testing ---")
+
+        test_begin_time = time.time()
+
+        test_results = {metric.TEST_ACCURACY: 0, metric.TEST_LOSS: 0, metric.TEST_TIME: 0}
+        if self.conf.test_mode == TEST_IN_SERVER:
+            if self.is_primary_server():
+                test_results = self.test_in_server(self.conf.device)
+        else:
+            test_results = self.test_in_client()
+
+        test_results[metric.TEST_TIME] = time.time() - test_begin_time
+        self.track_test_results(test_results)
+
+    def post_test(self):
+        """Postprocessing after testing."""
+        pass
+
+    def should_stop(self):
+        """Check whether should stop training. Stops the training under two conditions:
+        1. Reach max number of training rounds
+        2. TODO: Accuracy higher than certain amount.
+
+        Returns:
+            bool: A flag to indicate whether should stop training.
+        """
+        if self._should_stop or (self.conf.server.rounds and self._current_round + 1 >= self.conf.server.rounds):
+            self._is_training = False
+            return True
+        return False
+
+    def test_in_client(self):
+        """Conduct testing in clients.
+        Currently, it supports testing on the selected clients for training.
+        TODO: Add optionals to select clients for testing.
+
+        Returns:
+            dict: Test metrics, {"test_loss": value, "test_accuracy": value, "test_time": value}.
+        """
+        self.compression()
+        self.distribution_to_test()
+        return self.aggregation_test()
+
+    def test_in_server(self, device=CPU):
+        """Conduct testing in the server.
+
+        Args:
+            device (str): The hardware device to conduct testing, either cpu or cuda devices.
+
+        Returns:
+            dict: Test metrics, {"test_loss": value, "test_accuracy": value, "test_time": value}.
+        """
+        self._model.eval()
+        self._model.to(device)
+        test_loss = 0
+        correct = 0
+        loss_fn = torch.nn.CrossEntropyLoss().to(device)
+        with torch.no_grad():
+            for batched_x, batched_y in self.test_data.loader(self.conf.server.batch_size, seed=self.conf.seed):
+                x = batched_x.to(device)
+                y = batched_y.to(device)
+                log_probs = self._model(x)
+                loss = loss_fn(log_probs, y)
+                _, y_pred = torch.max(log_probs, -1)
+                correct += y_pred.eq(y.data.view_as(y_pred)).long().cpu().sum()
+                test_loss += loss.item()
+            test_data_size = self.test_data.size()
+            test_loss /= test_data_size
+            accuracy = 100.00 * correct / test_data_size
+
+            test_results = {
+                metric.TEST_ACCURACY: float(accuracy),
+                metric.TEST_LOSS: float(test_loss)
+            }
+            return test_results
+
+    def selection(self, clients, clients_per_round):
+        """Select a fraction of total clients for training.
+        Two selection strategies are implemented: 1. random selection; 2. select the first K clients.
+
+        Args:
+            clients (list[:obj:`BaseClient`]|list[str]): Available clients.
+            clients_per_round (int): Number of clients to participate in training each round.
+
+        Returns:
+            (list[:obj:`BaseClient`]|list[str]): The selected clients.
+        """
+        if clients_per_round > len(clients):
+            logger.warning("Available clients for selection are smaller than required clients for each round")
+
+        clients_per_round = min(clients_per_round, len(clients))
+        if self.conf.server.random_selection:
+            np.random.seed(self._current_round)
+            self.selected_clients = np.random.choice(clients, clients_per_round, replace=False)
+        else:
+            self.selected_clients = clients[:clients_per_round]
+
+        return self.selected_clients
+
+    def grouping_for_distributed(self):
+        """Divide the selected clients into groups for distributed training.
+        Each group of clients is assigned to conduct training in one GPU. The number of groups = the number of gpus.
+
+        Not in distributed training, selected clients are in the same group.
+        In distributed, selected clients are grouped with different strategies: greedy and random.
+        """
+        if self.conf.is_distributed:
+            groups = grouping(self.selected_clients,
+                              self.conf.distributed.world_size,
+                              self.default_time,
+                              self.conf.resource_heterogeneous.grouping_strategy,
+                              self._current_round)
+            # assign a group for each rank to train with current device.
+            self.grouped_clients = groups[self.conf.distributed.rank]
+            grouping_info = [(c.cid, c.round_time) for c in self.grouped_clients]
+            logger.info("Grouping Result for rank {}: {}".format(self.conf.distributed.rank, grouping_info))
+        else:
+            self.grouped_clients = self.selected_clients
+
+        rank = 0 if len(self.grouped_clients) == len(self.selected_clients) else self.conf.distributed.rank
+
+    def compression(self):
+        """Model compression to reduce communication cost."""
+        self._compressed_model = self._model
+
+    def distribution_to_train(self):
+        """Distribute model and configurations to selected clients to train."""
+        if self.is_remote:
+            self.distribution_to_train_remotely()
+        else:
+            self.distribution_to_train_locally()
+
+            # Adaptively update the training time of clients for greedy grouping.
+            if self.conf.is_distributed and self.conf.resource_heterogeneous.grouping_strategy == GREEDY_GROUPING:
+                self.profile_training_speed()
+                self.update_default_time()
+
+    def distribution_to_train_locally(self):
+        """Conduct training sequentially for selected clients in the group."""
+        uploaded_models = {}
+        uploaded_weights = {}
+        uploaded_metrics = []
+        for client in self.grouped_clients:
+            # Update client config before training
+            self.conf.client.task_id = self.conf.task_id
+            self.conf.client.round_id = self._current_round
+
+            uploaded_request = client.run_train(self._compressed_model, self.conf.client)
+            uploaded_content = uploaded_request.content
+
+            model = self.decompression(codec.unmarshal(uploaded_content.data))
+            uploaded_models[client.cid] = model
+            uploaded_weights[client.cid] = uploaded_content.data_size
+            uploaded_metrics.append(metric.ClientMetric.from_proto(uploaded_content.metric))
+
+        self.set_client_uploads_train(uploaded_models, uploaded_weights, uploaded_metrics)
+
+    def distribution_to_train_remotely(self):
+        """Distribute training requests to remote clients through multiple threads.
+        The main thread waits for signal to proceed. The signal can be triggered via notification, as below example.
+
+        Example to trigger signal:
+            >>> with self.condition():
+            >>>     self.notify_all()
+        """
+        start_time = time.time()
+        should_track = self._tracker is not None and self.conf.client.track
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            for client in self.grouped_clients:
+                request = client_pb.OperateRequest(
+                    type=client_pb.OP_TYPE_TRAIN,
+                    model=codec.marshal(self._compressed_model),
+                    data_index=client.index,
+                    config=client_pb.OperateConfig(
+                        batch_size=self.conf.client.batch_size,
+                        local_epoch=self.conf.client.local_epoch,
+                        seed=self.conf.seed,
+                        local_test=self.conf.client.local_test,
+                        optimizer=client_pb.Optimizer(
+                            type=self.conf.client.optimizer.type,
+                            lr=self.conf.client.optimizer.lr,
+                            momentum=self.conf.client.optimizer.momentum,
+                        ),
+                        task_id=self.conf.task_id,
+                        round_id=self._current_round,
+                        track=should_track,
+                    ),
+                )
+                executor.submit(self._distribution_remotely, client.client_id, request)
+
+            distribute_time = time.time() - start_time
+            self.track(metric.TRAIN_DISTRIBUTE_TIME, distribute_time)
+            logger.info("Distribute to clients, time: {}".format(distribute_time))
+        with self._condition:
+            self._condition.wait()
+
+    def distribution_to_test(self):
+        """Distribute to conduct testing on clients."""
+        if self.is_remote:
+            self.distribution_to_test_remotely()
+        else:
+            self.distribution_to_test_locally()
+
+    def distribution_to_test_locally(self):
+        """Conduct testing sequentially for selected testing clients."""
+        uploaded_accuracies = []
+        uploaded_losses = []
+        uploaded_data_sizes = []
+        uploaded_metrics = []
+
+        test_clients = self.get_test_clients()
+        for client in test_clients:
+            # Update client config before testing
+            self.conf.client.task_id = self.conf.task_id
+            self.conf.client.round_id = self._current_round
+
+            uploaded_request = client.run_test(self._compressed_model, self.conf.client)
+            uploaded_content = uploaded_request.content
+            performance = codec.unmarshal(uploaded_content.data)
+
+            uploaded_accuracies.append(performance.accuracy)
+            uploaded_losses.append(performance.loss)
+            uploaded_data_sizes.append(uploaded_content.data_size)
+            uploaded_metrics.append(metric.ClientMetric.from_proto(uploaded_content.metric))
+
+        self.set_client_uploads_test(uploaded_accuracies, uploaded_losses, uploaded_data_sizes, uploaded_metrics)
+
+    def distribution_to_test_remotely(self):
+        """Distribute testing requests to remote clients through multiple threads.
+        The main thread waits for signal to proceed. The signal can be triggered via notification, as below example.
+
+        Example to trigger signal:
+            >>> with self.condition():
+            >>>     self.notify_all()
+        """
+        start_time = time.time()
+        should_track = self._tracker is not None and self.conf.client.track
+        test_clients = self.get_test_clients()
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            for client in test_clients:
+                request = client_pb.OperateRequest(
+                    type=client_pb.OP_TYPE_TEST,
+                    model=codec.marshal(self._compressed_model),
+                    data_index=client.index,
+                    config=client_pb.OperateConfig(
+                        batch_size=self.conf.client.batch_size,
+                        test_batch_size=self.conf.client.test_batch_size,
+                        seed=self.conf.seed,
+                        task_id=self.conf.task_id,
+                        round_id=self._current_round,
+                        track=should_track,
+                    )
+                )
+                executor.submit(self._distribution_remotely, client.client_id, request)
+
+            distribute_time = time.time() - start_time
+            self.track(metric.TEST_DISTRIBUTE_TIME, distribute_time)
+            logger.info("Distribute to test clients, time: {}".format(distribute_time))
+        with self._condition:
+            self._condition.wait()
+
+    def get_test_clients(self):
+        """Get clients to run testing.
+
+        Returns:
+            (list[:obj:`BaseClient`]|list[str]): Clients to test.
+        """
+        if self.conf.server.test_all:
+            if self.conf.is_distributed:
+                # Group and assign clients to different hardware devices to test.
+                test_clients = grouping(self._clients,
+                                        self.conf.distributed.world_size,
+                                        default_time=self.default_time,
+                                        strategy=self.conf.resource_heterogeneous.grouping_strategy)
+                test_clients = test_clients[self.conf.distributed.rank]
+            else:
+                test_clients = self._clients
+        else:
+            # For the initial testing, if no clients are selected, test all clients
+            test_clients = self.grouped_clients if self.grouped_clients is not None else self._clients
+        return test_clients
+
+    def _distribution_remotely(self, cid, request):
+        """Distribute request to the assigned client to conduct operations.
+
+        Args:
+            cid (str): Client id.
+            request (:obj:`OperateRequest`): gRPC request of specific operations.
+        """
+        resp = self.client_stubs[cid].Operate(request)
+        if resp.status.code != common_pb.SC_OK:
+            logger.error("Failed to train/test in client {}, error: {}".format(cid, resp.status.message))
+        else:
+            logger.info("Distribute to train/test remotely successfully, client: {}".format(cid))
+
+    def aggregation_test(self):
+        """Aggregate testing results from clients.
+
+        Returns:
+            dict: Test metrics, format in {"test_loss": value, "test_accuracy": value}
+        """
+        accuracies = self._client_uploads[ACCURACY]
+        losses = self._client_uploads[LOSS]
+        test_sizes = self._client_uploads[DATA_SIZE]
+
+        if self.conf.test_method == "average":
+            loss = self._mean_value(losses)
+            accuracy = self._mean_value(accuracies)
+        elif self.conf.test_method == "weighted":
+            loss = self._weighted_value(losses, test_sizes)
+            accuracy = self._weighted_value(accuracies, test_sizes)
+        else:
+            raise ValueError("test_method not supported, please use average or weighted")
+
+        test_results = {
+            metric.TEST_ACCURACY: float(accuracy),
+            metric.TEST_LOSS: float(loss)
+        }
+        return test_results
+
+    def _mean_value(self, values):
+        if self.conf.is_distributed:
+            return reduce_values(values, self.conf.device)
+        else:
+            return np.mean(values)
+
+    def _weighted_value(self, values, weights):
+        if self.conf.is_distributed:
+            return reduce_weighted_values(values, weights, self.conf.device)
+        else:
+            return np.average(values, weights=weights)
+
+    def decompression(self, model):
+        """Decompression the models from clients"""
+        return model
+
+    def aggregation(self):
+        """Aggregate training updates from clients.
+        Server aggregates trained models from clients via federated averaging.
+        """
+        uploaded_content = self.get_client_uploads()
+        models = list(uploaded_content[MODEL].values())
+        weights = list(uploaded_content[DATA_SIZE].values())
+
+        model = self.aggregate(models, weights)
+        self.set_model(model, load_dict=True)
+
+    def aggregate(self, models, weights):
+        """Aggregate models uploaded from clients via federated averaging.
+
+        Args:
+            models (list[nn.Module]): List of models.
+            weights (list[float]): List of weights, corresponding to each model.
+                Weights are dataset size of clients by default.
+        Returns
+            nn.Module: Aggregated model.
+        """
+        if self.conf.server.aggregation_strategy == EQUAL_AVERAGE:
+            weights = [1 for _ in range(len(models))]
+
+        fn_average = strategies.federated_averaging
+        fn_sum = strategies.weighted_sum
+        fn_reduce = reduce_models
+        if self.conf.server.aggregation_content == AGGREGATION_CONTENT_PARAMS:
+            fn_average = strategies.federated_averaging_only_params
+            fn_sum = strategies.weighted_sum_only_params
+            fn_reduce = reduce_models_only_params
+
+        if self.conf.is_distributed:
+            dist.barrier()
+            model, sample_sum = fn_sum(models, weights)
+            fn_reduce(model, torch.tensor(sample_sum).to(self.conf.device))
+        else:
+            model = fn_average(models, weights)
+        return model
+
+    def _reset(self):
+        self._current_round = -1
+        self._should_stop = False
+        self._is_training = True
+
+    def is_training(self):
+        """Check whether the server is in training or has stopped training.
+
+        Returns:
+            bool: A flag to indicate whether server is in training.
+        """
+        return self._is_training
+
+    def set_model(self, model, load_dict=False):
+        """Update the universal model in the server.
+
+        Args:
+            model (nn.Module): New model.
+            load_dict (bool): A flag to indicate whether load state dict or copy the model.
+        """
+        if load_dict:
+            self._model.load_state_dict(model.state_dict())
+        else:
+            self._model = copy.deepcopy(model)
+
+    def set_clients(self, clients):
+        self._clients = clients
+
+    def num_of_clients(self):
+        return len(self._clients)
+
+    def save_model(self):
+        """Save the model in the server."""
+        if self._do_every(self.conf.server.save_model_every, self._current_round, self.conf.server.rounds) and \
+                self.is_primary_server():
+            save_path = self.conf.server.save_model_path
+            if save_path == "":
+                save_path = os.path.join(os.getcwd(), "saved_models")
+            os.makedirs(save_path, exist_ok=True)
+            save_path = os.path.join(save_path,
+                                     "{}_global_model_r_{}.pth".format(self.conf.task_id, self._current_round))
+            torch.save(self._model.cpu().state_dict(), save_path)
+            self.print_("Model saved at {}".format(save_path))
+
+    def set_client_uploads_train(self, models, weights, metrics=None):
+        """Set training updates uploaded from clients.
+
+        Args:
+            models (dict): A collection of models.
+            weights (dict): A collection of weights.
+            metrics (dict): Client training metrics.
+        """
+        self.set_client_uploads(MODEL, models)
+        self.set_client_uploads(DATA_SIZE, weights)
+        if self._should_gather_metrics():
+            metrics = self.gather_client_train_metrics()
+        self.set_client_uploads(CLIENT_METRICS, metrics)
+
+    def set_client_uploads_test(self, accuracies, losses, test_sizes, metrics=None):
+        """Set testing results uploaded from clients.
+
+        Args:
+            accuracies (list[float]): Testing accuracies of clients.
+            losses (list[float]): Testing losses of clients.
+            test_sizes (list[float]): Test dataset sizes of clients.
+            metrics (dict): Client testing metrics.
+        """
+        self.set_client_uploads(ACCURACY, accuracies)
+        self.set_client_uploads(LOSS, losses)
+        self.set_client_uploads(DATA_SIZE, test_sizes)
+        if self._should_gather_metrics() and CLIENT_METRICS in self._client_uploads:
+            train_metrics = self.get_client_uploads()[CLIENT_METRICS]
+            metrics = metric.ClientMetric.merge_train_to_test_metrics(train_metrics, metrics)
+        self.set_client_uploads(CLIENT_METRICS, metrics)
+
+    def set_client_uploads(self, key, value):
+        """A general function to set uploaded content from clients.
+
+        Args:
+            key (str): Dictionary key.
+            value (*): Uploaded content.
+        """
+        self._client_uploads[key] = value
+
+    def get_client_uploads(self):
+        """Get client uploaded contents.
+
+        Returns:
+            dict: A dictionary that contains client uploaded contents.
+        """
+        return self._client_uploads
+
+    def _do_every(self, every, current_round, rounds):
+        return (current_round + 1) % every == 0 or (current_round + 1) == rounds
+
+    def print_(self, content):
+        """print only the server is primary server.
+
+        Args:
+            content (str): The content to log.
+        """
+        if self.is_primary_server():
+            logger.info(content)
+
+    def is_primary_server(self):
+        """Check whether the current process is the primary server.
+        In standalone or remote training, the server is primary.
+        In distributed training, the server on rank0 is primary.
+
+        Returns:
+            bool: A flag to indicate whether current process is the primary server.
+        """
+        return not self.conf.is_distributed or self.conf.distributed.rank == 0
+
+    # Functions for remote training
+
+    def start_service(self):
+        """Start federated learning server GRPC service."""
+        if self.is_remote:
+            grpc_wrapper.start_service(grpc_wrapper.TYPE_SERVER, ServerService(self), self.local_port)
+            logger.info("GRPC server started at :{}".format(self.local_port))
+
+    def connect_remote_clients(self, clients):
+        # TODO: This client should be consistent with client started separately.
+        for client in clients:
+            if client.client_id not in self.client_stubs:
+                self.client_stubs[client.client_id] = grpc_wrapper.init_stub(grpc_wrapper.TYPE_CLIENT, client.address)
+                logger.info("Successfully connected to gRPC client {}".format(client.address))
+
+    def init_etcd(self, addresses):
+        """Initialize etcd as the registry for client registration.
+
+        Args:
+            addresses (str): The etcd addresses split by ","
+        """
+        self._etcd = EtcdClient("server", addresses, "backends")
+
+    def start_remote_training(self, model, clients):
+        """Start federated learning in the remote training mode.
+        Server establishes gPRC connection with clients that are not connected first before training.
+
+        Args:
+            model (nn.Module): The model to train.
+            clients (list[str]): Client addresses.
+        """
+        self.connect_remote_clients(clients)
+        self.start(model, clients)
+
+    # Functions for tracking
+
+    def init_tracker(self):
+        """Initialize tracking"""
+        if self.conf.server.track:
+            self._tracker = init_tracking(self.conf.tracking.database, self.conf.tracker_addr)
+
+    def track(self, metric_name, value):
+        """Track a metric.
+
+        Args:
+            metric_name (str): Name of the metric of a round.
+            value (str|int|float|bool|dict|list): Value of the metric.
+        """
+        if not self._should_track():
+            return
+        self._tracker.track_round(metric_name, value)
+
+    def track_test_results(self, results):
+        """Track test results collected from clients.
+
+        Args:
+            results (dict): Test metrics, format in {"test_loss": value, "test_accuracy": value, "test_time": value}
+        """
+        self._cumulative_times.append(time.time() - self._start_time)
+        self._accuracies.append(results[metric.TEST_ACCURACY])
+
+        for metric_name in results:
+            self.track(metric_name, results[metric_name])
+
+        self.print_('Test time {:.2f}s, Test loss: {:.2f}, Test accuracy: {:.2f}%'.format(
+            results[metric.TEST_TIME], results[metric.TEST_LOSS], results[metric.TEST_ACCURACY]))
+
+    def save_tracker(self):
+        """Save metrics in the tracker to database."""
+        if self._tracker:
+            self.track_communication_cost()
+            if self.is_primary_server():
+                self._tracker.save_round()
+            # In distributed training, each server saves their clients separately.
+            self._tracker.save_clients(self._client_uploads[CLIENT_METRICS])
+
+    def track_communication_cost(self):
+        """Track communication cost among server and clients.
+        Communication cost occurs in `training` and `testing` with downlink and uplink costs.
+        """
+        train_upload_size = 0
+        train_download_size = 0
+        test_upload_size = 0
+        test_download_size = 0
+        for client_metric in self._client_uploads[CLIENT_METRICS]:
+            if client_metric.round_id == self._current_round and client_metric.task_id == self.conf.task_id:
+                train_upload_size += client_metric.train_upload_size
+                train_download_size += client_metric.train_download_size
+                test_upload_size += client_metric.test_upload_size
+                test_download_size += client_metric.test_download_size
+        if self.conf.is_distributed:
+            train_upload_size = reduce_value(train_upload_size, self.conf.device).item()
+            train_download_size = reduce_value(train_download_size, self.conf.device).item()
+            test_upload_size = reduce_value(test_upload_size, self.conf.device).item()
+            test_download_size = reduce_value(test_download_size, self.conf.device).item()
+        self._tracker.track_round(metric.TRAIN_UPLOAD_SIZE, train_upload_size)
+        self._tracker.track_round(metric.TRAIN_DOWNLOAD_SIZE, train_download_size)
+        self._tracker.track_round(metric.TEST_UPLOAD_SIZE, test_upload_size)
+        self._tracker.track_round(metric.TEST_DOWNLOAD_SIZE, test_download_size)
+
+    def _should_track(self):
+        """Check whether server should track metrics.
+        Server tracks metrics only when tracking is enabled and it is the primary server.
+
+        Returns:
+            bool: A flag indicate whether server should track metrics.
+        """
+        return self._tracker is not None and self.is_primary_server()
+
+    def _should_gather_metrics(self):
+        """Check whether the server should gather metrics from GPUs.
+        Gather metrics only when testing all in `distributed` training.
+
+        Testing all resets clients' training metrics, thus,
+        server needs to gather train metrics to construct full client metrics.
+
+        Returns:
+            bool: A flag indicate whether server should gather metrics.
+        """
+        return self.conf.is_distributed and self.conf.server.test_all and self._tracker
+
+    def gather_client_train_metrics(self):
+        """Gather client train metrics from other ranks for distributed training, when testing all clients (test_all).
+        When testing all clients, the trained metrics may be override by the test metrics
+        because clients may be placed in different GPUs in training and testing, leading to losses of train metrics.
+        So we gather train metrics and set them in test metrics.
+        TODO: gather is not progressing. Need fix.
+        """
+        world_size = self.conf.distributed.world_size
+        device = self.conf.device
+        uploads = self.get_client_uploads()
+        client_id_list = []
+        train_accuracy_list = []
+        train_loss_list = []
+        train_time_list = []
+        train_upload_time_list = []
+        train_upload_size_list = []
+        train_download_size_list = []
+
+        for m in uploads[CLIENT_METRICS]:
+            # client_id_list += gather_value(m.client_id, world_size, device).tolist()
+            train_accuracy_list += gather_value(m.train_accuracy, world_size, device)
+            train_loss_list += gather_value(m.train_loss, world_size, device)
+            train_time_list += gather_value(m.train_time, world_size, device)
+            train_upload_time_list += gather_value(m.train_upload_time, world_size, device)
+            train_upload_size_list += gather_value(m.train_upload_size, world_size, device)
+            train_download_size_list += gather_value(m.train_download_size, world_size, device)
+        metrics = []
+        # Note: Client id may not match with its training stats because all_gather string is not supported.
+        client_id_list = [c.cid for c in self.selected_clients]
+        for i, client_id in enumerate(client_id_list):
+            m = metric.ClientMetric(self.conf.task_id, self._current_round, client_id)
+            m.add(metric.TRAIN_ACCURACY, train_accuracy_list[i])
+            m.add(metric.TRAIN_LOSS, train_loss_list[i])
+            m.add(metric.TRAIN_TIME, train_time_list[i])
+            m.add(metric.TRAIN_UPLOAD_TIME, train_upload_time_list[i])
+            m.add(metric.TRAIN_UPLOAD_SIZE, train_upload_size_list[i])
+            m.add(metric.TRAIN_DOWNLOAD_SIZE, train_download_size_list[i])
+            metrics.append(m)
+        return metrics
+
+    # Functions for remote training.
+
+    def condition(self):
+        return self._condition
+
+    def notify_all(self):
+        self._condition.notify_all()
+
+    # Functions for distributed training optimization.
+
+    def profile_training_speed(self):
+        """Manage profiling of client training speeds for distributed training optimization."""
+        profile_required = []
+        for client in self.selected_clients:
+            if not client.profiled:
+                profile_required.append(client)
+        if len(profile_required) > 0:
+            original = torch.FloatTensor([c.round_time for c in profile_required]).to(self.conf.device)
+            time_update = torch.FloatTensor([c.train_time for c in profile_required]).to(self.conf.device)
+            dist.barrier()
+            dist.all_reduce(time_update)
+            for i in range(len(profile_required)):
+                old_round_time = original[i]
+                current_round_time = time_update[i]
+                if old_round_time == 0 or self._should_update_round_time(old_round_time, current_round_time):
+                    profile_required[i].round_time = float(current_round_time)
+                    profile_required[i].train_time = 0
+                else:
+                    profile_required[i].profiled = True
+
+    def update_default_time(self):
+        """Update the estimated default training time of clients using actual training time from profiled clients."""
+        default_momentum = self.conf.resource_heterogeneous.default_time_momentum
+        current_round_average = np.mean([float(c.round_time) for c in self.selected_clients])
+        self.default_time = default_momentum * current_round_average + self.default_time * (1 - default_momentum)
+
+    def _should_update_round_time(self, old_round_time, new_round_time, threshold=0.3):
+        """Check whether assign a new estimated round time to client or set it to profiled.
+
+        Args:
+            old_round_time (float): previous estimated round time.
+            new_round_time (float): Currently profiled round time.
+            threshold (float): Tolerance threshold of difference between old and new times.
+        Returns:
+            bool: A flag to indicate whether should update round time.
+        """
+        if new_round_time < old_round_time:
+            return ((old_round_time - new_round_time) / new_round_time) >= threshold
+        else:
+            return ((new_round_time - old_round_time) / old_round_time) >= threshold
diff --git a/easyfl/server/service.py b/easyfl/server/service.py
new file mode 100644
index 0000000..cedd203
--- /dev/null
+++ b/easyfl/server/service.py
@@ -0,0 +1,143 @@
+import logging
+import threading
+
+from easyfl.pb import server_service_pb2_grpc as server_grpc, server_service_pb2 as server_pb, common_pb2 as common_pb
+from easyfl.protocol import codec
+from easyfl.tracking import metric
+
+logger = logging.getLogger(__name__)
+
+
+class ServerService(server_grpc.ServerServiceServicer):
+    """"Remote gRPC server service.
+
+    Args:
+        server (:obj:`BaseServer`): Federated learning server instance.
+    """
+    def __init__(self, server):
+        self._base = server
+
+        self._clients_per_round = 0
+
+        self._train_client_count = 0
+        self._uploaded_models = {}
+        self._uploaded_weights = {}
+        self._uploaded_metrics = []
+
+        self._test_client_count = 0
+        self._accuracies = []
+        self._losses = []
+        self._test_sizes = []
+
+    def Run(self, request, context):
+        """Trigger federated learning process."""
+        response = server_pb.RunResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+
+        if self._base.is_training():
+            response = server_pb.RunResponse(
+                status=common_pb.Status(
+                    code=common_pb.SC_ALREADY_EXISTS,
+                    message="Training in progress, please stop current training or wait for completion",
+                ),
+            )
+        else:
+            model = codec.unmarshal(request.model)
+            self._base.start_remote_training(model, request.clients)
+
+        return response
+
+    def Stop(self, request, context):
+        """Stop federated learning process."""
+        response = server_pb.StopResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+
+        if self._base.is_training():
+            self._base.stop()
+        else:
+            response = server_pb.RunResponse(
+                status=common_pb.Status(
+                    code=common_pb.SC_NOT_FOUND,
+                    message="No existing training",
+                ),
+            )
+        return response
+
+    def Upload(self, request, context):
+        """Handle upload from clients."""
+        # TODO: put train and test logic in a separate thread and add thread lock to ensure atomicity.
+        t = threading.Thread(target=self._handle_upload, args=[request, context])
+        t.start()
+        response = server_pb.UploadResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        return response
+
+    def _handle_upload(self, request, context):
+        # if not self._base.upload_event.is_set():
+        data = codec.unmarshal(request.content.data)
+        data_size = request.content.data_size
+        client_metric = metric.ClientMetric.from_proto(request.content.metric)
+
+        clients_per_round = self._base.conf.server.clients_per_round
+        num_of_clients = self._base.num_of_clients()
+        if num_of_clients < clients_per_round:
+            # TODO: use a more appropriate way to handle this situation
+            logger.warning(
+                "Available number of clients {} is smaller than clients per round {}".format(num_of_clients,
+                                                                                             clients_per_round))
+            self._clients_per_round = num_of_clients
+        else:
+            self._clients_per_round = clients_per_round
+
+        if request.content.type == common_pb.DATA_TYPE_PARAMS:
+            self._handle_upload_train(request.client_id, data, data_size, client_metric)
+        elif request.content.type == common_pb.DATA_TYPE_PERFORMANCE:
+            self._handle_upload_test(data, data_size, client_metric)
+
+    def _handle_upload_train(self, client_id, data, data_size, client_metric):
+        model = self._base.decompression(data)
+        self._uploaded_models[client_id] = model
+        self._uploaded_weights[client_id] = data_size
+        self._uploaded_metrics.append(client_metric)
+        self._train_client_count += 1
+        self._trigger_aggregate_train()
+
+    def _handle_upload_test(self, data, data_size, client_metric):
+        self._accuracies.append(data.accuracy)
+        self._losses.append(data.loss)
+        self._test_sizes.append(data_size)
+        self._uploaded_metrics.append(client_metric)
+        self._test_client_count += 1
+        self._trigger_aggregate_test()
+
+    def _trigger_aggregate_train(self):
+        logger.info("train_client_count: {}/{}".format(self._train_client_count, self._clients_per_round))
+        if self._train_client_count == self._clients_per_round:
+            self._base.set_client_uploads_train(self._uploaded_models, self._uploaded_weights, self._uploaded_metrics)
+            self._train_client_count = 0
+            self._reset_train_cache()
+            with self._base.condition():
+                self._base.notify_all()
+
+    def _trigger_aggregate_test(self):
+        # TODO: determine the testing clients not only by the selected number of clients
+        if self._test_client_count == self._clients_per_round:
+            self._base.set_client_uploads_test(self._accuracies, self._losses, self._test_sizes, self._uploaded_metrics)
+            self._test_client_count = 0
+            self._reset_test_cache()
+            with self._base.condition():
+                self._base.notify_all()
+
+    def _reset_train_cache(self):
+        self._uploaded_models = {}
+        self._uploaded_weights = {}
+        self._uploaded_metrics = []
+
+    def _reset_test_cache(self):
+        self._accuracies = []
+        self._losses = []
+        self._test_sizes = []
+        self._uploaded_metrics = []
diff --git a/easyfl/server/strategies.py b/easyfl/server/strategies.py
new file mode 100644
index 0000000..a1898ec
--- /dev/null
+++ b/easyfl/server/strategies.py
@@ -0,0 +1,119 @@
+import copy
+
+import torch
+
+
+def federated_averaging(models, weights):
+    """Compute weighted average of model parameters and persistent buffers.
+    Using state_dict of model, including persistent buffers like BN stats.
+
+    Args:
+        models (list[nn.Module]): List of models to average.
+        weights (list[float]): List of weights, corresponding to each model.
+            Weights are dataset size of clients by default.
+    Returns
+        nn.Module: Weighted averaged model.
+    """
+    if models == [] or weights == []:
+        return None
+
+    model, total_weights = weighted_sum(models, weights)
+    model_params = model.state_dict()
+    with torch.no_grad():
+        for name, params in model_params.items():
+            model_params[name] = torch.div(params, total_weights)
+    model.load_state_dict(model_params)
+    return model
+
+
+def federated_averaging_only_params(models, weights):
+    """Compute weighted average of model parameters. Use model parameters only.
+
+    Args:
+        models (list[nn.Module]): List of models to average.
+        weights (list[float]): List of weights, corresponding to each model.
+            Weights are dataset size of clients by default.
+    Returns
+        nn.Module: Weighted averaged model.
+    """
+    if models == [] or weights == []:
+        return None
+
+    model, total_weights = weighted_sum_only_params(models, weights)
+    model_params = dict(model.named_parameters())
+    with torch.no_grad():
+        for name, params in model_params.items():
+            model_params[name].set_(model_params[name] / total_weights)
+
+    return model
+
+
+def weighted_sum(models, weights):
+    """Compute weighted sum of model parameters and persistent buffers.
+    Using state_dict of model, including persistent buffers like BN stats.
+
+    Args:
+        models (list[nn.Module]): List of models to average.
+        weights (list[float]): List of weights, corresponding to each model.
+            Weights are dataset size of clients by default.
+    Returns
+        nn.Module: Weighted averaged model.
+        float: Sum of weights.
+    """
+    if models == [] or weights == []:
+        return None
+    model = copy.deepcopy(models[0])
+    model_sum_params = copy.deepcopy(models[0].state_dict())
+
+    with torch.no_grad():
+        for name, params in model_sum_params.items():
+            params *= weights[0]
+            for i in range(1, len(models)):
+                model_params = dict(models[i].state_dict())
+                params += model_params[name] * weights[i]
+            model_sum_params[name] = params
+    model.load_state_dict(model_sum_params)
+    return model, sum(weights)
+
+
+def weighted_sum_only_params(models, weights):
+    """Compute weighted sum of model parameters. Use model parameters only.
+
+    Args:
+        models (list[nn.Module]): List of models to average.
+        weights (list[float]): List of weights, corresponding to each model.
+            Weights are dataset size of clients by default.
+    Returns
+        nn.Module: Weighted averaged model.
+        float: Sum of weights.
+    """
+    if models == [] or weights == []:
+        return None
+
+    model_sum = copy.deepcopy(models[0])
+    model_sum_params = dict(model_sum.named_parameters())
+
+    with torch.no_grad():
+        for name, params in model_sum_params.items():
+            params *= weights[0]
+            for i in range(1, len(models)):
+                model_params = dict(models[i].named_parameters())
+                params += model_params[name] * weights[i]
+            model_sum_params[name].set_(params)
+    return model_sum, sum(weights)
+
+
+def equal_weight_averaging(models):
+    if models == []:
+        return None
+
+    model_avg = copy.deepcopy(models[0])
+    model_avg_params = dict(model_avg.named_parameters())
+
+    with torch.no_grad():
+        for name, params in model_avg_params.items():
+            for i in range(1, len(models)):
+                model_params = dict(models[i].named_parameters())
+                params += model_params[name]
+            model_avg_params[name].set_(params / len(models))
+    return model_avg
diff --git a/easyfl/service.py b/easyfl/service.py
new file mode 100644
index 0000000..edc528b
--- /dev/null
+++ b/easyfl/service.py
@@ -0,0 +1,71 @@
+import os
+
+import easyfl
+from easyfl.client import base as client_base
+from easyfl.server import base as server_base
+
+
+def start_remote_client(conf=None, train_data=None, test_data=None, model=None, client=None):
+    """Start a remote client.
+
+    Args:
+        conf (dict): Configurations. optional, Use the configuration loaded from file if not provided. It overwrites the
+            configurations from file.
+        train_data (:obj:`FederatedDataset`): Training dataset.
+        test_data (:obj:`FederatedDataset`): Testing dataset.
+        model (nn.Module): Model used in client training.
+        client (:obj:`BaseClient`): Customized federated learning client class.
+    """
+    parser = client_base.create_argument_parser()
+    parser.add_argument('--index', type=int, default=0, help='Client index for quick testing')
+    parser.add_argument('--config', type=str, default="client_config.yaml", help='Client config file')
+    args = parser.parse_args()
+
+    if os.path.isfile(args.config):
+        conf = easyfl.load_config(args.config, conf)
+
+    if train_data and test_data:
+        easyfl.register_dataset(train_data, test_data)
+    elif train_data:
+        easyfl.register_dataset(train_data, None)
+    elif test_data:
+        easyfl.register_dataset(None, test_data)
+
+    if model:
+        easyfl.register_model(model)
+
+    if client:
+        easyfl.register_client(client)
+
+    easyfl.init(conf, init_all=False)
+    easyfl.start_client(args)
+
+
+def start_remote_server(conf=None, test_data=None, model=None, server=None):
+    """Start a remote server.
+
+    Args:
+        conf (dict): Configurations. optional, Use the configuration loaded from file if not provided. It overwrites the
+            configurations from file.
+        test_data (:obj:`FederatedDataset`): Test dataset for centralized testing on server.
+        model (nn.Module): Model used in client training.
+        server (:obj:`BaseServer`): Customized federated learning server class.
+    """
+    parser = server_base.create_argument_parser()
+    parser.add_argument('--config', type=str, default="server_config.yaml", help='Server config file')
+    args = parser.parse_args()
+
+    if os.path.isfile(args.config):
+        conf = easyfl.load_config(args.config, conf)
+
+    if test_data:
+        easyfl.register_dataset(None, test_data)
+
+    if model:
+        easyfl.register_model(model)
+
+    if server:
+        easyfl.register_server(server)
+
+    easyfl.init(conf, init_all=False)
+    easyfl.start_server(args)
diff --git a/easyfl/simulation/__init__.py b/easyfl/simulation/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/simulation/mobile_ratio.py b/easyfl/simulation/mobile_ratio.py
new file mode 100644
index 0000000..476effb
--- /dev/null
+++ b/easyfl/simulation/mobile_ratio.py
@@ -0,0 +1,6 @@
+"""
+Speed of mobile to represent the ratio of waiting time.
+Data is retrieved from http://ai-benchmark.com/ranking_detailed.html, using values from MobileNet-V2, NN-FP16.
+"""
+
+MOBILE_RATIO = {"vivo iQOO Z1": "4.2", "Xiaomi Redmi Note 10": "8.1", "Huawei P40 Pro+": "4.4", "Honor 30 Pro+": "4.3", "Huawei P40": "4.3", "Huawei Mate 30 5G": "4.4", "Honor V30 Pro 5G": "4.3", "Realme X50 Pro 5G": "9.8", "Realme X2 Pro": "8.6", "Xiaomi Mi 10 Pro 5G": "8.1", "Oppo Find X2 Pro": "11", "Samsung Galaxy S20+ 5G": "9.7", "Samsung Galaxy S20": "12", "Samsung Galaxy S20 Ultra 5G": "9.9", "Samsung Galaxy S20+": "12", "Samsung Galaxy S20 5G": "9.9", "LG V60 ThinQ 5G": "8.1", "Motorola Edge+": "9.1", "Xiaomi Poco F2 Pro": "9.3", "OnePlus 8": "9", "Oppo Find X2": "9.6", "Xiaomi Redmi K30 Pro Zoom": "9.9", "vivo X50 Pro+": "9.9", "vivo iQOO 3 5G": "9.9", "Xiaomi Mi 10 5G": "9.5", "OnePlus 8 Pro": "9.8", "Asus ROG Phone II": "6.2", "vivo iQOO": "11", "Sony Xperia 1 II": "10", "OnePlus 7T Pro": "9.6", "Samsung Galaxy Note10+ 5G": "11", "OnePlus 7T": "11", "Lenovo Z6 Pro": "9.8", "Samsung Tab S6 WiFi": "10", "Samsung Galaxy S10": "11", "Samsung Galaxy Note10": "13", "Samsung Galaxy S10+": "12", "OnePlus 7": "11", "Samsung Galaxy Note10+": "12", "Xiaomi Mi 9": "11", "Samsung Galaxy S10e": "12", "Xiaomi Mi 9T Pro": "11", "OnePlus 7 Pro": "10", "Asus Zenfone 6": "11", "LG G8 ThinQ": "11", "Samsung Galaxy S10 Lite": "11", "ZTE Axon 10 Pro 5G": "11", "Oppo Reno 5G": "11", "LG V50 ThinQ 5G": "9.8", "Xiaomi Redmi K20 Pro": "12", "Samsung Galaxy A90 5G": "10", "Lenovo Z5 Pro GT": "10", "Sony Xperia 1": "8.5", "Oppo Reno 10x zoom": "9.8", "Sony Xperia 5": "11", "Xiaomi Mi Mix 3 5G": "13", "Meizu 16s": "15", "Samsung Galaxy Z Flip": "9.9", "LG G8S ThinQ": "13", "Huawei Mate 30 Pro": "4.8", "Huawei MatePad Pro": "5", "Honor 30": "5.5", "Honor X10 5G": "5.7", "Huawei nova 7 SE": "5.8", "Honor 30s": "6.1", "Xiaomi Redmi K30 5G Racing": "14", "LG V60 ThinQ (V600N)": "27", "Oppo Find X2 Lite": "12", "Oppo Reno3 Pro 5G": "13", "Asus Zenfone 5z": "7.5", "Google Pixel 4": "19", "Google Pixel 4 XL": "19", "Razer Phone 2": "9.7", "Oppo Find X2 Neo": "14", "Xiaomi Redmi K30 5G": "14", "vivo X50 Pro": "14", "Huawei P30 Pro": "18", "vivo S6 5G": "17", "Honor 20": "17", "Honor 20 Pro": "17", "Huawei Mate 20": "19", "OnePlus 6": "11", "OnePlus 6T": "11", "LG Velvet": "14", "Samsung Galaxy S9+": "59", "Huawei P30": "18", "Xiaomi Pocophone F1": "10", "Honor Magic 2": "19", "Huawei Mate 20 Pro": "19", "Sony Xperia XZ2": "9.8", "Huawei nova 5T": "17", "Sony Xperia XZ3": "11", "Honor View 20": "23", "Samsung Galaxy S9": "11", "Sony Xperia XZ2 Compact": "11", "Xiaomi Mi 10 Youth 5G": "15", "Xiaomi Mi Mix 3": "9.3", "Huawei Mate 20 X": "15", "Xiaomi Mi Mix 2S": "9.2", "Sony Xperia XZ2 Premium": "11", "Xiaomi Mi 8": "11", "Sharp Aquos R2": "12", "Honor 9X Pro": "9", "Huawei P40 lite": "9.2", "Honor 20S": "9.5", "Realme X2": "13", "Samsung Galaxy Note9": "62", "LG G7 ThinQ": "11", "Realme 6 Pro": "13", "Samsung Galaxy A71 5G": "22", "Meizu 16": "16", "LG V40 ThinQ": "13", "Xiaomi Mi Note 10 Pro": "14", "Xiaomi Redmi Note 9 Pro": "13", "Xiaomi Redmi Note 9S": "13", "Oppo Reno2": "14", "Samsung Galaxy A71": "14", "Samsung Galaxy A80": "14", "Xiaomi Mi Note 10": "15", "Oppo Reno2 Z": "28", "Xiaomi Mi Note 10 Lite": "14", "Xiaomi Redmi K30": "14", "Xiaomi Poco X2": "14", "Xiaomi Mi 9T": "15", "Oppo Reno Z": "23", "Motorola Z2 Force": "13", "Realme XT": "14", "Nokia 8": "14", "LG V30": "13", "Xiaomi Mi Mix 2": "15", "Realme X": "17", "Xiaomi Mi 6": "15", "Samsung Galaxy Note8": "170", "vivo V17": "21", "HTC U11": "18", "HTC U11 Plus": "18", "Samsung Galaxy S8": "172", "Motorola One Hyper": "20", "Huawei nova 4": "14", "Honor View 10": "14", "Samsung Galaxy S8+": "205", "Honor 10": "14", "Huawei P20 Pro": "14", "Huawei Mate 10 Pro": "14", "Xiaomi Redmi Note 7 Pro": "22", "vivo Z1 Pro": "20", "vivo U20": "22", "vivo V19": "18", "Meizu 16Xs": "23", "Xiaomi Mi 9 SE": "17", "Meizu Note 9": "22", "OnePlus 3T": "20", "HTC U12 Plus": "17", "Lenovo ZUK Z2": "21", "LG G6": "25", "Samsung Galaxy A70": "23", "Oppo RX17 Pro": "20", "vivo Z5x": "18", "Xiaomi Mi 9 Lite": "19", "Samsung Galaxy A60": "21", "Sony Xperia XZ": "23", "Blackview BV9900": "39", "Ulefone Armor 7": "42", "Xiaomi Mi CC9": "19", "Realme 3 Pro": "23", "vivo Z1x": "18", "Doogee S95 Pro": "44", "Motorola Z4": "24", "Oppo Reno A": "20", "Ulefone Armor 7E": "47", "Lenovo Z6 Youth": "19", "Samsung Galaxy S7": "199", "Lenovo Z5s": "19", "Xiaomi Mi 8 SE": "19", "Blackview BV9900 Pro": "48", "Motorola One Zoom": "24", "HTC 10": "19", "Samsung Galaxy S7 edge": "200", "OnePlus 5T": "18", "OnePlus 5": "20", "Google Pixel 3": "24", "Sony Xperia XZ1": "17", "Sony Xperia XZ1 Compact": "17", "Google Pixel 3 XL": "32", "Xiaomi Redmi Note 8 Pro": "25", "Oppo Reno3": "56", "Realme 6": "21", "Google Pixel 3a": "33", "Google Pixel 3a XL": "35", "Realme 5i": "26", "UMIDIGI S5 Pro": "38", "Oppo Reno": "24", "Realme 5": "27", "Xiaomi Mi Pad 4 Plus": "22", "TCL 10L": "28", "Xiaomi Mi Note 3": "22", "Sharp Aquos S2": "189", "Motorola G Pro": "29", "Motorola G8 Power": "29", "Motorola G Power": "29", "Oppo A5 (2020)": "28", "Xiaomi Mi A3": "29", "Sony Xperia 10 II": "32", "Oppo A92": "28", "Zebra TC57": "24", "Oppo A9 (2020)": "30", "vivo S1 Pro": "32", "Xiaomi Redmi Note 8": "29", "Xiaomi Redmi Note 8T": "29", "Motorola G8": "29", "vivo Y50": "28", "Motorola G8 Plus": "30", "Huawei P40 lite E": "37", "Huawei P Smart Z": "39", "Meizu X8": "22", "Meizu 16X": "23", "Honor Play 4T": "38", "Huawei P30 lite": "38", "Huawei P smart": "38", "Xiaomi Mi 8 Lite": "24", "Motorola Moto Z": "60", "Sony Xperia Z5 Compact": "27", "Realme 2 Pro": "21", "Samsung Galaxy A9": "26", "Xiaomi Mi A2": "26", "vivo V15": "195", "Xiaomi Redmi Note 7": "26", "LG G5": "62", "Ulefone Armor 6E": "81", "Xiaomi Redmi Note 7S": "25", "Essential Phone": "50", "Samsung Galaxy Note10 Lite": "63", "Asus Zenfone 5": "27", "Motorola G7 Plus": "30", "vivo S1": "50", "Xiaomi Mi Max 3": "31", "Sony Xperia 10 Plus": "32", "vivo V11i": "209", "vivo Y19": "60", "Oppo F11": "145", "Lenovo S5 Pro": "31", "OPPO F9 Pro": "137", "Motorola Z3 Play": "32", "T-Mobile Revvlry+": "33", "Umidigi Power 3": "49", "Samsung Galaxy A51": "101", "Xiaomi Redmi Note 5 Pro": "32", "Xiaomi Redmi Note 9": "59", "Google Pixel XL": "96", "Asus Zenfone Max Pro (M1)": "32", "Realme 3": "35", "Google Pixel": "100", "Google Pixel 2 XL": "125", "Google Pixel 2": "119", "Oppo F11 Pro": "60", "Google Pixel C": "101", "Honor 8": "172", "Motorola Moto G6 Plus": "31", "Motorola Moto X4": "31", "Realme 6i": "94", "Sony Xperia 10": "28", "Realme C3": "94", "Huawei P9": "168", "Motorola G7 Power": "122", "Huawei P10": "172", "Samsung Galaxy C9 Pro": "125", "Samsung Galaxy Note5": "146", "Sony Xperia X Compact": "121", "Huawei Mate 9": "227", "Fairphone 3": "143", "Huawei P10 Plus": "178", "Samsung Galaxy S6": "151", "Samsung Galaxy M30": "129", "Motorola One Action": "124", "Motorola One Vision": "124", "Samsung Galaxy A40": "127", "Samsung Galaxy A30s": "128", "Motorola One Macro": "172", "Samsung Galaxy M20": "130", "Samsung Galaxy A30": "129", "Xiaomi Redmi 7": "149", "Samsung Galaxy S6 edge": "153", "Samsung Galaxy A20": "134", "Samsung Galaxy S5": "216", "Samsung Galaxy Note FE": "87", "Sony Xperia Z3": "124", "Sony Xperia Z3 Compact": "132", "BlackBerry Keyone": "199", "Meizu Pro 7 Plus": "347", "Wiko WIM": "189", "Motorola G8 Play": "173", "Lenovo P2": "190", "Samsung Galaxy A21s": "132", "HTC One (M8)": "181", "LG Nexus 5": "111", "Xiaomi Redmi Note 4": "194", "Xiaomi Mi A1": "153", "Xiaomi Mi Max 2": "195", "Asus Zenfone 3": "202", "vivo V5 Plus": "198", "Huawei nova": "194", "Xiaomi Redmi 5 Plus": "195", "Motorola G7 Play": "172", "Sharp Aquos C10": "204", "Alcatel 1S": "172", "Motorola P30 Play": "199", "Honor 6X": "209", "Meizu M6 Note": "192", "Lenovo S5": "207", "Huawei P20 lite": "160", "Samsung Galaxy A8": "247", "Huawei P10 Lite": "202", "Huawei P8 Lite": "205", "Samsung Galaxy A10": "151", "Huawei Y7 Pro": "212", "Xiaomi Mi Play": "325", "ZTE Blade V10 Vita": "182", "Wiko Y80": "176", "Huawei Y7": "216", "LG G4": "258", "Huawei Y7 Prime": "218", "Xiaomi Mi A2 Lite": "203", "ZTE Blade V9": "222", "Huawei P9 lite": "205", "Samsung Galaxy A5": "243", "LG Stylo 5": "146", "Xiaomi Redmi 5": "216", "LG V10": "207", "Xiaomi Mi Pad": "134", "Lenovo K3 Note": "199", "Samsung Galaxy A20s": "217", "YU Yutopia": "164", "Samsung Galaxy A10e": "335", "Samsung Galaxy Tab A 8.0": "160", "Nokia 3 V": "212", "Motorola G8 Power Lite": "267", "Sony Xperia XA1": "259", "LG Stylo 6": "247", "Xiaomi Redmi 8": "262", "Xiaomi Mi Pad 2": "199", "ZTE Blade V9 Vita": "283", "UMIDIGI A3X": "234", "Samsung Galaxy A01": "244", "vivo Y15": "260", "Motorola E6 Plus": "265", "Xiaomi Redmi Y1": "286", "Lenovo K6 Note": "283", "Sony Xperia L4": "279", "Asus Zenfone 3 Max": "251", "HTC One": "194", "Wiko View2": "287", "Motorola G6": "180", "Xiaomi Redmi 4X": "282", "Asus Zenfone Max Plus": "330", "Sony Xperia Z": "215", "Samsung Galaxy A6+": "278", "Raspberry Pi 4": "173", "Xiaomi Redmi 6": "253", "Samsung Galaxy A10s": "280", "Samsung Galaxy A11": "280", "Samsung Galaxy M11": "280", "Samsung Galaxy J7 Prime": "317", "Samsung Galaxy J7": "318", "Xiaomi Redmi 5A": "242", "Xiaomi Mi 5c": "233", "Honor 8S": "230", "Samsung Galaxy A6": "286", "Samsung Galaxy J5": "376", "Xiaomi Redmi 6A": "153", "Huawei Y5": "236", "Samsung Galaxy J7 Pro": "733", "Xiaomi Redmi 3": "269", "Blackview A80 Pro": "300", "Alcatel 3x": "343", "Samsung Galaxy J6": "307", "Samsung Galaxy S5 Neo": "303", "Umidigi A5 Pro": "370", "Ulefone Armor X5": "356", "Sony Xperia L1": "237", "Samsung Galaxy Note 3": "202", "Meizu M2": "281", "Huawei Y5 Prime": "271", "Sony Xperia M4 Aqua": "334", "Xiaomi Redmi 7A": "485", "Xiaomi Redmi 8A": "516", "Motorola Moto X Play": "312", "Samsung Galaxy J3": "643", "Samsung Galaxy J5 Prime": "336", "Motorola G6 Play": "263", "Lenovo Vibe P1m": "328", "Motorola E4 Plus": "386", "ZTE Blade X3": "319", "ZTE Blade A452": "322", "Asus Zenfone 2": "548", "Asus Zenpad 10": "664", "Nokia 1": "331", "Samsung Galaxy Xcover 3": "669", "Asus Live G500TG": "668", "Asus Google Nexus 7": "622", "Samsung Galaxy S5 mini": "745", "Motorola Moto G2": "695", "Huawei Y560": "797", "Sony Xperia M2 Aqua": "807"}
\ No newline at end of file
diff --git a/easyfl/simulation/system_hetero.py b/easyfl/simulation/system_hetero.py
new file mode 100644
index 0000000..4d72a88
--- /dev/null
+++ b/easyfl/simulation/system_hetero.py
@@ -0,0 +1,71 @@
+import logging
+
+import numpy as np
+
+from easyfl.simulation.mobile_ratio import MOBILE_RATIO
+from easyfl.datasets.simulation import equal_division
+
+logger = logging.getLogger(__name__)
+
+SIMULATE_ISO = "iso"  # isometric sleep time distribution among selected clients
+SIMULATE_DIR = "dir"  # use symmetric dirichlet process to sample sleep time heterogenous
+SIMULATE_REAL = "real"  # use real speed ratio of main stream smartphones to simulate sleep time heterogenous
+
+
+def assign_value_to_group(groups, values):
+    assert len(groups) == len(values)
+    result = []
+    for i in range(len(groups)):
+        result.extend([values[i]] * len(groups[i]))
+    return result
+
+
+def sample_real_ratio(num_values):
+    value_pool = list(MOBILE_RATIO.values())
+    idxs = np.random.randint(0, len(value_pool), size=num_values)
+    return np.array([value_pool[i] for i in idxs]).astype(float)
+
+
+def resource_hetero_simulation(fraction, hetero_type, sleep_group_num, level, total_time, num_clients):
+    """Simulated resource heterogeneous by add sleeping time to clients.
+
+    Args:
+        fraction (float): The fraction of clients attending heterogeneous simulation.
+        hetero_type (str): The type of heterogeneous simulation, options: iso, dir or real.
+        sleep_group_num (int): The number of groups with different sleep time.
+        level (int): The level of heterogeneous (0-5), 0 means no heterogeneous among clients.
+        total_time (float): The total sleep time of all clients.
+        num_clients (int): The total number of clients.
+
+    Returns:
+        list[float]: A list of sleep time with distribution according to heterogeneous type.
+    """
+    sleep_clients = int(fraction * num_clients)
+    unsleep_clients = [0] * (num_clients - sleep_clients)
+    sleep_group_num = sleep_group_num
+    if sleep_group_num > sleep_clients:
+        logger.warning("sleep_group_num {} is more than sleep_clients number {}, \
+        so we set sleep_group_num to sleep_clients".format(sleep_group_num, sleep_clients))
+        sleep_group_num = sleep_clients
+    groups, _ = equal_division(sleep_group_num, np.arange(sleep_clients))
+    if level == 0:
+        distribution = np.array([1] * sleep_clients)
+    elif hetero_type == SIMULATE_DIR:
+        alpha = 1 / (level * level)
+        values = np.random.dirichlet(np.repeat(alpha, sleep_group_num))
+        distribution = assign_value_to_group(groups, values)
+    elif hetero_type == SIMULATE_ISO:
+        if level > 5:
+            raise ValueError("level cannot be more than 5")
+        begin = 0.5 - level * 0.1
+        end = 0.5 + level * 0.1
+        values = np.arange(begin, end, (end - begin) / sleep_group_num)
+        distribution = assign_value_to_group(groups, values)
+    elif hetero_type == SIMULATE_REAL:
+        values = sample_real_ratio(sleep_group_num)
+        distribution = assign_value_to_group(groups, values)
+    else:
+        raise ValueError("sleep type not supported, please use either dir or iso")
+    distribution += unsleep_clients
+    np.random.shuffle(distribution)
+    return distribution / sum(distribution) * total_time
diff --git a/easyfl/tracking/__init__.py b/easyfl/tracking/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/tracking/client.py b/easyfl/tracking/client.py
new file mode 100644
index 0000000..9166136
--- /dev/null
+++ b/easyfl/tracking/client.py
@@ -0,0 +1,242 @@
+from easyfl.tracking.metric import TaskMetric, RoundMetric, ClientMetric
+from easyfl.tracking.storage import get_store
+
+
+class TrackingClient(object):
+    """Client for tracking task metrics, round metrics, and client metrics.
+    Task Tracking:
+    client.create_task(task_id, conf)
+
+    Round Tracking:
+    client.track_round(name, value)
+    client.save_round() # auto increment to next round
+    client.track_round(name, value)
+
+    Client Tracking:
+    client.set_client_context(task_id, round_id, client_id)
+    client.track_client(name, value)
+    """
+
+    def __init__(self, db_path=None, db_address=None, init_store=True):
+        """If storage is not initialized, the tracking client can only collect metrics but not save them.
+        """
+        self._task_id = None
+        self._round_id = None
+        self._client_id = None
+        self._current_task = None
+        self._current_round = None
+        self._current_client = None
+        self._cached_task_metrics = {}
+        self._cached_round_metrics = {}
+
+        if init_store:
+            self._storage = get_store(db_path, db_address)
+
+    def get_task_metric(self, task_id):
+        """Get task from storage
+        """
+        task_metric = self._storage.get_task_metric(task_id)
+        if task_metric is None:
+            return
+        return TaskMetric.from_sql(task_metric)
+
+    def get_round_metric(self, round_id, task_id):
+        if task_id == self._task_id and round_id == self._round_id:
+            return self._current_round
+        return self._storage.get_round_metrics(task_id, [round_id])
+
+    def get_client_metric(self, client_id=None, round_id=None, task_id=None):
+        if (task_id == self._task_id and round_id == self._round_id and client_id == self._client_id) or \
+                (client_id is None and round_id is None and task_id is None):
+            return self._current_client
+        return self._storage.get_client_metrics(task_id, round_id, [client_id])
+
+    def get_client_metrics(self, client_ids, round_id, task_id):
+        """Get list of client metrics.
+        :param client_ids: list of client ids.
+        :param round_id: round id.
+        :param task_id: task id.
+        """
+        return self._storage.get_client_metrics(task_id, round_id, client_ids)
+
+    def create_task(self, task_id, conf=None, save=True):
+        if task_id is None:
+            raise ValueError("task_id cannot be None to create task")
+        self._task_id = task_id
+        self._current_task = TaskMetric(task_id, conf)
+        if save:
+            self._storage.store_task_metric(self._current_task)
+
+    def create_round(self, round_id, task_id=None):
+        if task_id is None:
+            task_id = self._task_id
+
+        if round_id is None:
+            raise ValueError("round_id cannot be None to create round")
+
+        if round_id != self._round_id:
+            self._round_id = round_id
+            self._current_round = RoundMetric(task_id, self._round_id)
+
+    def create_client(self, client_id, reset=True):
+        """Create client under current round of task.
+        Current implementation requires round and task exist to create client.
+        """
+        self._check_context()
+
+        if client_id is None:
+            raise ValueError("client_id cannot be None to create client.")
+
+        if reset or not self._current_client or client_id != self._client_id:
+            self._current_client = ClientMetric(self._task_id, self._round_id, client_id)
+            self._client_id = client_id
+            return
+
+        self._current_client.task_id = self._task_id
+        self._current_client.round_id = self._round_id
+
+    def track_task(self, name, value, task_id=None):
+        if self._diff_task_id(task_id):
+            self._cached_task_metrics[self._task_id] = self._current_task
+            self._task_id = task_id
+            self._current_task = TaskMetric(task_id)
+
+        self._current_task.add(name, value)
+        self._storage.store_task_metric(self._current_task)
+
+    def track_round(self, name, value, round_id=None, task_id=None):
+        if self._diff_task_id(task_id):
+            create_task(task_id)
+
+        if self._diff_round_id(round_id):
+            # self._cached_round_metrics[self.unique_round_id] = self._current_round
+            self.create_round(round_id)
+
+        if self._current_round is None:
+            self.create_round(0)
+
+        self._current_round.add(name, value)
+
+    def track_client(self, name, value, client_id=None):
+        """Track client under current round and task.
+        Current implementation requires round and task exist to track client.
+        """
+        self._check_context()
+
+        if self._diff_client_id(client_id) or self._current_client is None:
+            self.create_client(client_id)
+
+        self._current_client.add(name, value)
+
+    def save_round(self, increment=True, cache=False):
+        if self._current_round is None:
+            raise ValueError("Round metric is not initialized")
+        self._storage.store_round_metric(self._current_round)
+        if cache:
+            self._cached_round_metrics[self.unique_round_id] = self._current_round
+        if increment:
+            self.create_round(self._round_id + 1)
+
+    def save_client(self):
+        if self._current_client is None:
+            raise ValueError("Client metric is not initialized")
+
+        self._storage.store_client_metrics([self._current_client])
+
+    def save_clients(self, client_metrics):
+        self._storage.store_client_metrics(client_metrics)
+
+    def set_task(self, task_id):
+        if self._current_task is None:
+            self.create_task(task_id, save=False)
+
+    def set_round(self, round_id):
+        self.create_round(round_id)
+
+    def set_client_context(self, task_id, round_id, client_id, reset_client=True):
+        """Set the client context for tracking.
+        :param task_id: task id, indicating current the training task
+        :param round_id: round id, indicating current round of training/testing
+        :param client_id: client id
+        :param reset_client: resets and creates a new client.
+        """
+        self.set_task(task_id)
+        self.set_round(round_id)
+        self.create_client(client_id, reset=reset_client)
+
+    @property
+    def unique_round_id(self):
+        return f"{self._task_id}_{self._round_id}"
+
+    def _diff_task_id(self, task_id):
+        return task_id is not None and task_id != self._task_id
+
+    def _diff_round_id(self, round_id):
+        return round_id is not None and round_id != self._round_id
+
+    def _diff_client_id(self, client_id):
+        return client_id is not None and client_id != self._client_id
+
+    def _check_context(self):
+        if self._task_id is None or self._round_id is None:
+            raise LookupError("task_id or round_id of the client is not set")
+
+
+_client = TrackingClient(init_store=False)
+"""easyfl.tracking.TrackingClient: The global tracking client object"""
+
+
+def init_tracking(path=None, address=None, init_store=True):
+    """Initialize tracking client. This tracking client is isolated from the global tracking client.
+    This is useful when an application need to run multiple tasks.
+    :param path: database path
+    :param address: remote address of tracking service to connect to
+    :param init_store: whether initialize storage
+    """
+    return TrackingClient(path, address, init_store)
+
+
+# ------ following methods are not well tested yet ------
+
+
+def setup_tracking(path=None, address=None):
+    """Setup tracking with global tracking client.
+    """
+    global _client
+    _client = init_tracking(path, address)
+
+
+def get_task(task_id):
+    return _client.get_task_metric(task_id)
+
+
+def get_round(round_id, task_id):
+    return _client.get_round_metric(round_id, task_id)
+
+
+def create_task(task_id, conf=None):
+    _client.create_task(task_id, conf)
+
+
+def track_task(name, value, task_id=None):
+    _client.track_task(name, value, task_id)
+
+
+def track_round(name, value, round_id=None, task_id=None):
+    _client.track_round(name, value, round_id, task_id)
+
+
+def track_client(name, value, client_id=None):
+    _client.track_client(name, value, client_id)
+
+
+def set_task(task_id):
+    _client.set_task(task_id)
+
+
+def set_round(round_id):
+    _client.set_round(round_id)
+
+
+def save_round():
+    _client.save_round()
diff --git a/easyfl/tracking/client_test.py b/easyfl/tracking/client_test.py
new file mode 100644
index 0000000..932552b
--- /dev/null
+++ b/easyfl/tracking/client_test.py
@@ -0,0 +1,136 @@
+import os
+import unittest
+
+from easyfl.tracking import client
+from easyfl.tracking import metric
+from easyfl.tracking import storage
+
+
+class TrackingClientTest(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TrackingClientTest, self).__init__(*args, **kwargs)
+        self._database = os.path.join(os.getcwd(), "tracker", "easyfl_test.db")
+        self._store = storage.get_store(self._database)
+        self._store.truncate_task_metric()
+        self._store.truncate_round_metric()
+        self._store.truncate_client_metric()
+
+    def test_task(self):
+        task_id = "test_task"
+        conf = {"task_id": task_id}
+        tracker = client.init_tracking(self._database)
+        tracker.create_task(task_id, conf)
+        m = tracker.get_task_metric(task_id)
+        self.assertEqual(m.task_id, task_id)
+        self.assertEqual(m.configuration, conf)
+        m = tracker.get_task_metric("not_exist_task")
+        self.assertEqual(m, None)
+
+    def test_round(self):
+        task_id = "test_round"
+        round_id = 0
+        want_accuracy = 0.9
+        want_loss = 0.1
+        want_train_upload_size = 10
+        want_train_time = 20
+        want_extra = {"extra": "information"}
+        tracker = client.init_tracking(self._database)
+        tracker.create_task(task_id)
+        tracker.track_round(metric.TEST_ACCURACY, want_accuracy)
+        tracker.track_round(metric.TEST_LOSS, want_loss)
+        m = tracker.get_round_metric(round_id, task_id)
+        self.assertEqual(m.task_id, task_id)
+        self.assertEqual(m.round_id, round_id)
+        self.assertEqual(m.test_accuracy, want_accuracy)
+        self.assertEqual(m.test_loss, want_loss)
+
+        tracker.save_round(increment=False)
+        round_metrics = self._store.get_round_metrics(task_id, [round_id])
+        m = metric.RoundMetric.from_sql(next(round_metrics))
+        self.assertEqual(m.task_id, task_id)
+        self.assertEqual(m.round_id, round_id)
+        self.assertEqual(m.test_accuracy, want_accuracy)
+        self.assertEqual(m.test_loss, want_loss)
+
+        # round 1
+        tracker.set_round(round_id + 1)
+        tracker.track_round(metric.TRAIN_UPLOAD_SIZE, want_train_upload_size)
+        tracker.track_round(metric.EXTRA, want_extra)
+        tracker.save_round()
+        round_metrics = self._store.get_round_metrics(task_id, [round_id + 1])
+        m = metric.RoundMetric.from_sql(next(round_metrics))
+        self.assertEqual(m.task_id, task_id)
+        self.assertEqual(m.round_id, round_id + 1)
+        self.assertEqual(m.test_accuracy, 0)
+        self.assertEqual(m.test_loss, 0)
+        self.assertEqual(m.train_upload_size, want_train_upload_size)
+        self.assertEqual(m.extra["extra"], want_extra["extra"])
+
+        # round 2
+        tracker.track_round(metric.TRAIN_TIME, want_train_time)
+        m = tracker.get_round_metric(round_id + 2, task_id)
+        self.assertEqual(m.task_id, task_id)
+        self.assertEqual(m.round_id, round_id + 2)
+        self.assertEqual(m.train_time, want_train_time)
+        self.assertEqual(m.test_accuracy, 0)
+        self.assertEqual(m.test_loss, 0)
+        self.assertEqual(m.extra, {})
+
+    def test_client(self):
+        task_id = "test_client"
+        round_id = 1
+        client_id = "client_id_test"
+        client_id_2 = "client_id_test_2"
+        want_accuracy = 0.9123456789
+        want_mAP = 0.8
+        want_rank1 = 0.7
+        want_loss = 0.1
+        want_extra = {"extra": "information"}
+
+        # test error
+        tracker = client.init_tracking(self._database)
+        self.assertRaises(LookupError, tracker.create_client, client_id)
+        self.assertRaises(LookupError, tracker.track_client, metric.TEST_ACCURACY, [want_accuracy])
+
+        # test track and get client
+        tracker.set_client_context(task_id, round_id, client_id)
+        tracker.track_client(metric.TRAIN_ACCURACY, [want_accuracy])
+        tracker.track_client("mAP", want_mAP)
+        m = tracker.get_client_metric(client_id, round_id, task_id)
+        self.assertEqual(m.train_accuracy, [round(want_accuracy, 4)])
+        self.assertEqual(m.extra["mAP"], want_mAP)
+
+        # test save client
+        tracker.save_client()
+        client_metrics = self._store.get_client_metrics(task_id, round_id, [client_id])
+        m = metric.ClientMetric.from_sql(next(client_metrics))
+        self.assertEqual(m.task_id, task_id)
+        self.assertEqual(m.round_id, round_id)
+        self.assertEqual(m.client_id, client_id)
+        self.assertEqual(m.train_accuracy, [round(want_accuracy, 4)])
+        self.assertEqual(m.extra["mAP"], want_mAP)
+        self._store.truncate_client_metric()
+
+        # test save multiple clients
+        tracker2 = client.init_tracking(self._database)
+        tracker2.set_client_context(task_id, round_id, client_id_2)
+        tracker2.track_client(metric.TRAIN_LOSS, [want_loss])
+        tracker2.track_client("rank1", want_rank1)
+        tracker2.track_client(metric.EXTRA, want_extra)
+
+        client_metrics = [tracker.get_client_metric(), tracker2.get_client_metric()]
+        tracker.save_clients(client_metrics)
+        results = self._store.get_client_metrics(task_id, round_id, [client_id, client_id_2])
+        metrics = [metric.ClientMetric.from_sql(r) for r in results]
+        self.assertEqual(len(metrics), 2)
+        self.assertEqual(len(metrics[1].extra), 2)
+        self.assertEqual(metrics[1].task_id, task_id)
+        self.assertEqual(metrics[1].round_id, round_id)
+        self.assertEqual(metrics[1].client_id, client_id_2)
+        self.assertEqual(metrics[1].train_loss, [want_loss])
+        self.assertEqual(metrics[1].extra["rank1"], want_rank1)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/easyfl/tracking/evaluation.py b/easyfl/tracking/evaluation.py
new file mode 100644
index 0000000..f66d667
--- /dev/null
+++ b/easyfl/tracking/evaluation.py
@@ -0,0 +1,17 @@
+def model_size(model, param_size=32):
+    """Calculate the model parameter sizes, including non-trainable parameters
+
+    Args:
+        model (nn.Module): A PyTorch model.
+        param_size (int): The size of a parameter, default using float32.
+
+    Returns:
+        float: The model size in MB.
+    """
+    # sum(p.numel() for p in model.parameters() if p.requires_grad) for only trainable parameters
+    params = sum(p.numel() for p in model.parameters())
+    return bit_to_megabyte(params * param_size)
+
+
+def bit_to_megabyte(bits):
+    return bits / (8 * 1024 * 1024)
diff --git a/easyfl/tracking/metric.py b/easyfl/tracking/metric.py
new file mode 100644
index 0000000..30e3002
--- /dev/null
+++ b/easyfl/tracking/metric.py
@@ -0,0 +1,486 @@
+import json
+import logging
+import random
+import string
+import time
+
+import numpy as np
+
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.utils.float import rounding
+
+PREFIX_TASK_ID = "task"
+
+CONFIGURATION = "configuration"
+
+# clients
+SELECTED_CLIENTS = 'selected_clients'
+GROUPED_CLIENTS = 'grouped_clients'
+
+# communication cost
+DOWNLOAD_SIZE = 'download_size'
+TRAIN_DOWNLOAD_SIZE = 'train_download_size'
+TRAIN_UPLOAD_SIZE = 'train_upload_size'
+TEST_DOWNLOAD_SIZE = 'test_download_size'
+TEST_UPLOAD_SIZE = 'test_upload_size'
+
+# distribute time
+UPLOAD_TIME = "upload_time"
+TRAIN_UPLOAD_TIME = "train_upload_time"
+TEST_UPLOAD_TIME = "test_upload_time"
+TRAIN_DISTRIBUTE_TIME = "train_distribute_time"
+TEST_DISTRIBUTE_TIME = "test_distribute_time"
+
+# time
+ROUND_TIME = "round_time"
+TRAIN_TIME = 'train_time'
+TEST_TIME = 'test_time'
+TRAIN_EPOCH_TIME = 'train_epoch_time'
+
+# performance
+TRAIN_ACCURACY = 'train_accuracy'
+TRAIN_LOSS = 'train_loss'
+AVG_TRAIN_LOSS = 'avg_train_loss'
+
+TEST_ACCURACY = 'test_accuracy'
+TEST_LOSS = 'test_loss'
+
+TEST_LOCAL_ACCURACY = 'test_local_accuracy'
+TEST_LOCAL_LOSS = 'test_local_loss'
+
+# general
+EXTRA = "extra"  # for not specifically defined metrics
+DEFAULT_FOLDER = "metrics"
+PREFIX_METRIC_ID = "metric"
+
+logger = logging.getLogger(__name__)
+
+
+class Metric(object):
+    def __init__(self):
+        self.metrics = {
+            EXTRA: {}
+        }
+
+    def add(self, metric_name, metric_value, convert=True):
+        """Add metrics. Add to "extra" if the metric is not predefined.
+        """
+        if self.predefined_metrics() and metric_name in self.predefined_metrics():
+            if convert:
+                metric_value = self._value_conversion(metric_value)
+            self.metrics[metric_name] = metric_value
+        elif metric_name == EXTRA:
+            self.metrics[EXTRA].update(metric_value)
+        else:
+            self.metrics[EXTRA][metric_name] = metric_value
+
+    def get(self, metric_name, default=0):
+        if metric_name in self.metrics:
+            return self.metrics[metric_name]
+        return default
+
+    @classmethod
+    def predefined_metrics(cls):
+        return []
+
+    @property
+    def extra(self):
+        """Retrieve extra information, not specifically defined metric, stored in the metrics.
+        :return dictionary of metrics, return {} if extra stored.
+        """
+        return self.metrics[EXTRA]
+
+    @staticmethod
+    def _value_conversion(value):
+        """Convert float to keep only 4 decimal points
+        """
+        if isinstance(value, float):
+            value = np.around(value, 4)
+        elif isinstance(value, list) and len(value) > 0 and isinstance(value[0], float):
+            value = rounding(value, 4)
+        return value
+
+
+class TaskMetric(object):
+    def __init__(self, task_id, conf=None):
+        self._task_id = task_id
+        self._conf = conf
+
+    def add(self, name, value):
+        if name == CONFIGURATION:
+            self.add_configuration(value)
+
+    def add_configuration(self, conf):
+        self._conf = conf
+
+    @classmethod
+    def from_sql(cls, sql_result):
+        task_id, conf = sql_result
+        conf = {} if conf == "" else json.loads(conf)
+        return cls(task_id, conf)
+
+    def to_sql_param(self):
+        conf = json.dumps(self.configuration) if self.configuration is not None else ""
+        return self.task_id, conf
+
+    @property
+    def task_id(self):
+        return self._task_id
+
+    @property
+    def configuration(self):
+        return self._conf
+
+    def to_proto(self):
+        return common_pb.TaskMetric(
+            task_id=self.task_id,
+            configuration=json.dumps(self.configuration)
+        )
+
+    @classmethod
+    def from_proto(cls, proto):
+        return cls(proto.task_id, json.loads(proto.configuration))
+
+
+class RoundMetric(Metric):
+    """Metrics of a training round
+    Note: testing related metrics may not be available in every round.
+    """
+
+    def __init__(self, task_id, round_id):
+        super().__init__()
+        self.task_id = task_id
+        self.round_id = round_id
+
+    @property
+    def test_accuracy(self):
+        return self.get(TEST_ACCURACY)
+
+    @property
+    def test_loss(self):
+        return self.get(TEST_LOSS)
+
+    @property
+    def train_time(self):
+        return self.get(TRAIN_TIME)
+
+    @property
+    def test_time(self):
+        return self.get(TEST_TIME)
+
+    @property
+    def round_time(self):
+        return self.get(ROUND_TIME)
+
+    @property
+    def train_distribute_time(self):
+        return self.get(TRAIN_DISTRIBUTE_TIME, 0)
+
+    @property
+    def test_distribute_time(self):
+        return self.get(TEST_DISTRIBUTE_TIME, 0)
+
+    @property
+    def train_upload_size(self):
+        """Communication cost of uploading content from client to server
+        """
+        return self.get(TRAIN_UPLOAD_SIZE)
+
+    @property
+    def train_download_size(self):
+        """Communication cost of distributing content from server to client
+        """
+        return self.get(TRAIN_DOWNLOAD_SIZE)
+
+    @property
+    def test_upload_size(self):
+        """Communication cost of uploading content from client to server
+        """
+        return self.get(TEST_UPLOAD_SIZE)
+
+    @property
+    def test_download_size(self):
+        """Communication cost of distributing content from server to client
+        """
+        return self.get(TEST_DOWNLOAD_SIZE)
+
+    @property
+    def communication_cost(self):
+        return self.train_upload_size + self.train_download_size + self.test_upload_size + self.test_download_size
+
+    @classmethod
+    def predefined_metrics(cls):
+        return [TEST_ACCURACY,
+                TEST_LOSS,
+                ROUND_TIME,
+                TRAIN_TIME,
+                TEST_TIME,
+                TRAIN_DISTRIBUTE_TIME,
+                TEST_DISTRIBUTE_TIME,
+                TRAIN_UPLOAD_SIZE,
+                TRAIN_DOWNLOAD_SIZE,
+                TEST_UPLOAD_SIZE,
+                TEST_DOWNLOAD_SIZE]
+
+    @classmethod
+    def from_sql(cls, sql_result):
+        task_id = sql_result[0]
+        round_id = sql_result[1]
+        m = cls(task_id, round_id)
+        metrics = cls.predefined_metrics()
+        for name, value in zip(metrics, sql_result[2:-1]):
+            m.add(name, value)
+        m.add(EXTRA, json.loads(sql_result[-1]))
+        return m
+
+    def to_sql_param(self):
+        return (self.task_id,
+                self.round_id,
+                self.test_accuracy,
+                self.test_loss,
+                self.round_time,
+                self.train_time,
+                self.test_time,
+                self.train_distribute_time,
+                self.test_distribute_time,
+                self.train_upload_size,
+                self.train_download_size,
+                self.test_upload_size,
+                self.test_download_size,
+                json.dumps(self.extra))
+
+    def to_proto(self):
+        return common_pb.RoundMetric(
+            task_id=self.task_id,
+            round_id=self.round_id,
+            test_accuracy=self.test_accuracy,
+            test_loss=self.test_loss,
+            round_time=self.round_time,
+            train_time=self.train_time,
+            test_time=self.test_time,
+            train_distribute_time=self.train_distribute_time,
+            test_distribute_time=self.test_distribute_time,
+            train_upload_size=self.train_upload_size,
+            train_download_size=self.train_download_size,
+            test_upload_size=self.test_upload_size,
+            test_download_size=self.test_download_size,
+            extra=json.dumps(self.extra)
+        )
+
+    @classmethod
+    def from_proto(cls, proto):
+        m = cls(proto.task_id, proto.round_id)
+        metrics = cls.predefined_metrics()
+        values = [proto.test_accuracy,
+                  proto.test_loss,
+                  proto.round_time,
+                  proto.train_time,
+                  proto.test_time,
+                  proto.train_distribute_time,
+                  proto.test_distribute_time,
+                  proto.train_upload_size,
+                  proto.train_download_size,
+                  proto.test_upload_size,
+                  proto.test_download_size]
+        for name, value in zip(metrics, values):
+            m.add(name, value)
+
+        if proto.extra:
+            m.add(EXTRA, json.loads(proto.extra))
+
+        return m
+
+
+class ClientMetric(Metric):
+    """Metrics for a client in a round of training.
+    """
+
+    def __init__(self, task_id, round_id, client_id):
+        super().__init__()
+        self.task_id = task_id
+        self.round_id = round_id
+        self.client_id = client_id
+
+    @property
+    def train_accuracy(self):
+        return self.get(TRAIN_ACCURACY)
+
+    @property
+    def test_accuracy(self):
+        return self.get(TEST_ACCURACY)
+
+    @property
+    def train_loss(self):
+        return self.get(TRAIN_LOSS)
+
+    @property
+    def test_loss(self):
+        return self.get(TEST_LOSS)
+
+    @property
+    def train_time(self):
+        return self.get(TRAIN_TIME)
+
+    @property
+    def test_time(self):
+        return self.get(TEST_TIME)
+
+    @property
+    def train_upload_time(self):
+        return self.get(TRAIN_UPLOAD_TIME)
+
+    @property
+    def test_upload_time(self):
+        return self.get(TEST_UPLOAD_TIME)
+
+    @property
+    def train_upload_size(self):
+        return self.get(TRAIN_UPLOAD_SIZE)
+
+    @property
+    def train_download_size(self):
+        return self.get(TRAIN_DOWNLOAD_SIZE)
+
+    @property
+    def test_upload_size(self):
+        return self.get(TEST_UPLOAD_SIZE)
+
+    @property
+    def test_download_size(self):
+        return self.get(TEST_DOWNLOAD_SIZE)
+
+    @property
+    def communication_cost(self):
+        return self.train_upload_size + self.train_download_size + self.test_upload_size + self.test_download_size
+
+    @classmethod
+    def predefined_metrics(cls):
+        return [TRAIN_ACCURACY,
+                TRAIN_LOSS,
+                TEST_ACCURACY,
+                TEST_LOSS,
+                TRAIN_TIME,
+                TEST_TIME,
+                TRAIN_UPLOAD_TIME,
+                TEST_UPLOAD_TIME,
+                TRAIN_UPLOAD_SIZE,
+                TRAIN_DOWNLOAD_SIZE,
+                TEST_UPLOAD_SIZE,
+                TEST_DOWNLOAD_SIZE]
+
+    @classmethod
+    def from_sql(cls, sql_result):
+        task_id = sql_result[0]
+        round_id = sql_result[1]
+        client_id = sql_result[2]
+        m = cls(task_id, round_id, client_id)
+        metrics = cls.predefined_metrics() + [EXTRA]
+        for name, value in zip(metrics, sql_result[3:]):
+            if name in [TRAIN_ACCURACY, TRAIN_LOSS, EXTRA]:
+                value = json.loads(value)
+            m.add(name, value)
+        return m
+
+    def to_sql_param(self):
+        return (self.task_id,
+                self.round_id,
+                self.client_id,
+                json.dumps(self.train_accuracy),
+                json.dumps(self.train_loss),
+                self.test_accuracy,
+                self.test_loss,
+                self.train_time,
+                self.test_time,
+                self.train_upload_time,
+                self.test_upload_time,
+                self.train_upload_size,
+                self.train_download_size,
+                self.test_upload_size,
+                self.test_download_size,
+                json.dumps(self.extra))
+
+    def to_proto(self):
+        return common_pb.ClientMetric(
+            task_id=self.task_id,
+            round_id=self.round_id,
+            client_id=self.client_id,
+            train_accuracy=self.train_accuracy,
+            train_loss=self.train_loss,
+            test_accuracy=self.test_accuracy,
+            test_loss=self.test_loss,
+            train_time=self.train_time,
+            test_time=self.test_time,
+            train_upload_time=self.train_upload_time,
+            test_upload_time=self.test_upload_time,
+            train_upload_size=self.train_upload_size,
+            train_download_size=self.train_download_size,
+            test_upload_size=self.test_upload_size,
+            test_download_size=self.test_download_size,
+            extra=json.dumps(self.extra)
+        )
+
+    @classmethod
+    def from_proto(cls, proto):
+        m = cls(proto.task_id, proto.round_id, proto.client_id)
+        train_accuracy = [x for x in proto.train_accuracy]
+        train_loss = [x for x in proto.train_loss]
+        metrics = cls.predefined_metrics()
+        values = [train_accuracy,
+                  train_loss,
+                  proto.test_accuracy,
+                  proto.test_loss,
+                  proto.train_time,
+                  proto.test_time,
+                  proto.train_upload_time,
+                  proto.test_upload_time,
+                  proto.train_upload_size,
+                  proto.train_download_size,
+                  proto.test_upload_size,
+                  proto.test_download_size]
+        for name, value in zip(metrics, values):
+            m.add(name, value)
+
+        if proto.extra:
+            m.add(EXTRA, json.loads(proto.extra))
+
+        return m
+
+    def set_train_metrics(self, m):
+        if self.is_same_metric(m):
+            self.metrics[TRAIN_ACCURACY] = m.train_accuracy
+            self.metrics[TRAIN_LOSS] = m.train_loss
+            self.metrics[TRAIN_TIME] = m.train_time
+            self.metrics[TRAIN_UPLOAD_TIME] = m.train_upload_time
+            self.metrics[TRAIN_UPLOAD_SIZE] = m.train_upload_size
+            self.metrics[TRAIN_DOWNLOAD_SIZE] = m.train_download_size
+
+    def set_test_metrics(self, m):
+        if self.is_same_metric(m):
+            self.metrics[TEST_ACCURACY] = m.test_accuracy
+            self.metrics[TEST_LOSS] = m.test_loss
+            self.metrics[TEST_TIME] = m.test_time
+            self.metrics[TEST_UPLOAD_TIME] = m.test_upload_time
+            self.metrics[TEST_UPLOAD_SIZE] = m.test_upload_size
+            self.metrics[TEST_DOWNLOAD_SIZE] = m.test_download_size
+
+    def is_same_metric(self, m):
+        return self.task_id == m.task_id and self.round_id == m.round_id and self.client_id == m.client_id
+
+    @classmethod
+    def merge_train_to_test_metrics(cls, train_metrics, test_metrics):
+        """Merge train metrics to test_metrics
+        """
+        train_metrics_ = {m.client_id: m for m in train_metrics}
+        for test_metric in test_metrics:
+            client_id = test_metric.client_id
+            if client_id in train_metrics_:
+                test_metric.set_train_metrics(train_metrics_[client_id])
+        return test_metrics
+
+
+def generate_tid():
+    length = 6
+    letters = string.ascii_lowercase
+    random.seed(time.time())
+    result = "".join(random.choice(letters) for i in range(length))
+    return "{}_{}".format(PREFIX_TASK_ID, result)
diff --git a/easyfl/tracking/service.py b/easyfl/tracking/service.py
new file mode 100644
index 0000000..0229344
--- /dev/null
+++ b/easyfl/tracking/service.py
@@ -0,0 +1,157 @@
+import argparse
+import logging
+
+from easyfl.communication import grpc_wrapper
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.pb import tracking_service_pb2 as tracking_pb
+from easyfl.pb import tracking_service_pb2_grpc as tracking_grpc
+from easyfl.tracking import metric
+from easyfl.tracking.storage import SqliteStorage
+
+logger = logging.getLogger(__name__)
+
+
+def create_argument_parser():
+    parser = argparse.ArgumentParser(description='Federated Tracker')
+    parser.add_argument('--local-port',
+                        type=int,
+                        default=12666,
+                        help='Listen port of the client')
+    return parser
+
+
+class TrackingService(tracking_grpc.TrackingServiceServicer):
+    def __init__(self, storage=SqliteStorage):
+        self._storage = storage()
+        logger.info("Tracking service is online")
+        self._storage.setup()
+
+    def TrackTaskMetric(self, request, context):
+        response = tracking_pb.TrackTaskMetricResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+
+        try:
+            self._storage.store_task_metric(metric.TaskMetric.from_proto(request.task_metric))
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = f"Failed to track task metric, err: {e}"
+            logger.error(response.status.message)
+
+        return response
+
+    def TrackRoundMetric(self, request, context):
+        response = tracking_pb.TrackRoundMetricResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        try:
+            self._storage.store_round_metric(metric.RoundMetric.from_proto(request.round_metric))
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = f"Failed to track round metric, err: {e}"
+            logger.error(response.status.message)
+
+        return response
+
+    def TrackClientMetric(self, request, context):
+        response = tracking_pb.TrackClientMetricResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        try:
+            metrics = [metric.ClientMetric.from_proto(m) for m in request.client_metrics]
+            self._storage.store_client_metrics(metrics)
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = f"Failed to track client metric, err: {e}"
+            logger.error(response.status.message)
+
+        return response
+
+    def TrackClientTrainMetric(self, request, context):
+        response = tracking_pb.TrackClientTrainMetricResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        try:
+            self._storage.store_client_train_metric(request.task_id,
+                                                    request.round_id,
+                                                    request.client_id,
+                                                    request.train_loss,
+                                                    request.train_time,
+                                                    request.train_upload_time,
+                                                    request.train_download_size,
+                                                    request.train_upload_size)
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = "Tracking client train failed, err: {}".format(e)
+            logger.error("Tracking client train failed, err: {}".format(e))
+
+        return response
+
+    def TrackClientTestMetric(self, request, context):
+        response = tracking_pb.TrackClientTestMetricResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+
+        try:
+            self._storage.store_client_test_metric(request.task_id,
+                                                   request.round_id,
+                                                   request.client_id,
+                                                   request.test_accuracy,
+                                                   request.test_loss,
+                                                   request.test_time,
+                                                   request.test_upload_time,
+                                                   request.test_download_size)
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = "Tracking client test failed, err: {}".format(e)
+            logger.error("Tracking client test failed, err: {}".format(e))
+
+        return response
+
+    def GetRoundTrainTestTime(self, request, context):
+        response = tracking_pb.GetRoundTrainTestTimeResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        try:
+            resp = self._storage.get_round_train_test_time(request.task_id,
+                                                           request.rounds,
+                                                           request.interval)
+            for i in resp:
+                train_test_time = tracking_pb.TrainTestTime(round_id=i[0], time=i[1])
+                response.train_test_times.append(train_test_time)
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = "get round train_test time failed, err: {}".format(e)
+            logger.error("get round train_test time failed, err: {}".format(e))
+        return response
+
+    def GetRoundMetrics(self, request, context):
+        response = tracking_pb.GetRoundMetricsResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        try:
+            resp = self._storage.get_round_metrics(request.task_id, request.rounds)
+            response.metrics = [metric.RoundMetric.from_sql(r) for r in resp]
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = f"Failed to get round metrics, err: {e}"
+            logger.error(response.status.message)
+        return response
+
+    def GetClientMetrics(self, request, context):
+        response = tracking_pb.GetClientMetricsResponse(
+            status=common_pb.Status(code=common_pb.SC_OK),
+        )
+        try:
+            resp = self._storage.get_client_metrics(request.task_id, request.round_id, request.client_ids)
+            response.metrics = [metric.ClientMetric.from_sql(r) for r in resp]
+        except Exception as e:
+            response.status.code = common_pb.SC_UNKNOWN
+            response.status.message = f"Failed to get client metrics failed, err: {e}"
+            logger.error(response.status.message)
+        return response
+
+
+def start_tracking_service(local_port=12666):
+    logger.info("Tracking GRPC server started at :{}".format(local_port))
+    grpc_wrapper.start_service(grpc_wrapper.TYPE_TRACKING, TrackingService(), local_port)
diff --git a/easyfl/tracking/storage.py b/easyfl/tracking/storage.py
new file mode 100644
index 0000000..a781b94
--- /dev/null
+++ b/easyfl/tracking/storage.py
@@ -0,0 +1,340 @@
+import logging
+import os
+import random
+import sqlite3
+import time
+
+from easyfl.communication import grpc_wrapper
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.pb import tracking_service_pb2 as tracking_pb
+from easyfl.protocol.codec import marshal
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SQLITE_DB = "easyfl.db"
+
+STORAGE_SQLITE = "sqlite"
+STORAGE_REMOTE = "remote"
+
+TYPE_ROUND = "round"
+TYPE_CLIENT = "client"
+
+DEFAULT_TIMEOUT = 10
+
+CREATE_TASK_METRIC_SQL = '''
+CREATE TABLE IF NOT EXISTS task_metric 
+(task_id       CHAR(50)    NOT NULL PRIMARY KEY,
+config         TEXT);'''
+
+CREATE_ROUND_METRIC_SQL = '''
+CREATE TABLE IF NOT EXISTS round_metric 
+(task_id              CHAR(50)    NOT NULL,
+round_id              INT         NOT NULL,
+accuracy              REAL        NOT NULL,
+loss                  REAL        NOT NULL,
+round_time            REAL        NOT NULL,
+train_time            REAL        NOT NULL,
+test_time             REAL        NOT NULL,
+train_distribute_time REAL,
+test_distribute_time  REAL,
+train_upload_size     REAL,
+train_download_size   REAL,
+test_upload_size      REAL,
+test_download_size    REAL,
+extra                 TEXT,
+PRIMARY KEY (task_id, round_id));'''
+
+CREATE_CLIENT_METRIC_SQL = '''
+CREATE TABLE IF NOT EXISTS client_metric 
+(task_id            CHAR(50)    NOT NULL,
+round_id            INT         NOT NULL,
+client_id           CHAR(20)    NOT NULL,
+train_accuracy      TEXT        ,
+train_loss          TEXT        ,
+test_accuracy       REAL        ,
+test_loss           REAL        ,
+train_time          REAL        ,
+test_time           REAL        ,
+train_upload_time   REAL        ,
+test_upload_time    REAL        ,
+train_upload_size   REAL        ,
+train_download_size REAL        ,
+test_upload_size    REAL        ,
+test_download_size  REAL        ,
+extra               TEXT        ,
+PRIMARY KEY (task_id, round_id, client_id));'''
+
+
+def get_store(path=None, address=None):
+    if address:
+        return RemoteStorage(address)
+    else:
+        return SqliteStorage(path)
+
+
+def get_storage_type(is_remote=True):
+    if is_remote:
+        return STORAGE_REMOTE
+    else:
+        return STORAGE_SQLITE
+
+
+class SqliteStorage(object):
+    """SqliteStorage uses sqlite to save tracking metrics
+
+    """
+
+    def __init__(self, database=None):
+        if database is None:
+            database = os.path.join(os.getcwd(), "tracker", DEFAULT_SQLITE_DB)
+        self._conn = sqlite3.connect(database, check_same_thread=False)
+        self.setup()
+
+    def __del__(self):
+        self._conn.close()
+
+    def setup(self):
+        with self._conn:
+            try:
+                self._retry_execute(CREATE_TASK_METRIC_SQL)
+                logger.info("Setup task metric table")
+                self._retry_execute(CREATE_ROUND_METRIC_SQL)
+                logger.info("Setup round metric table")
+                self._retry_execute(CREATE_CLIENT_METRIC_SQL)
+                logger.info("Setup client metric table")
+            except sqlite3.OperationalError as e:
+                logger.error(f"Failed to setup table, error: {e}")
+
+    # ------------------ store metrics ------------------
+
+    def store_task_metric(self, metric):
+        sql = "INSERT INTO task_metric(task_id, config) VALUES (?, ?)"
+        try:
+            self._retry_execute(sql, metric.to_sql_param())
+            logger.debug("Task metric saved successfully")
+        except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+            logger.error(f"Failed to store round metric, error: {e}")
+
+    def store_round_metric(self, metric):
+        sql = '''
+        INSERT INTO round_metric (
+        task_id,
+        round_id,
+        accuracy,
+        loss,
+        round_time,
+        train_time,
+        test_time,
+        train_distribute_time,
+        test_distribute_time,
+        train_upload_size,
+        train_download_size,
+        test_upload_size,
+        test_download_size,
+        extra) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);'''
+
+        try:
+            self._retry_execute(sql, metric.to_sql_param())
+            logger.debug("Round metric saved successfully")
+        except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+            logger.error(f"Failed to store round metric {metric.task_id} {metric.round_id}, error: {e}")
+
+    def store_client_metrics(self, metrics):
+        """Store a list of client metrics. If the client exists, replace the values.
+        :param metrics, list of client metrics to store, [].
+        """
+        sql = '''
+        INSERT INTO client_metric (
+        task_id,
+        round_id,
+        client_id,
+        train_accuracy,
+        train_loss,
+        test_accuracy,
+        test_loss,
+        train_time,
+        test_time,
+        train_upload_time,   
+        test_upload_time,    
+        train_upload_size,   
+        train_download_size, 
+        test_upload_size,    
+        test_download_size,  
+        extra) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);'''
+
+        params = [metric.to_sql_param() for metric in metrics]
+
+        try:
+            with self._conn:
+                self._conn.executemany(sql, params)
+            logger.debug("Client metrics saved successfully")
+        except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+            logger.error(f"Failed to store client metrics, error: {e}")
+
+    def store_client_train_metric(self, tid, rid, cid, train_loss, train_time, train_upload_time,
+                                  train_download_size, train_upload_size):
+
+        sql = "INSERT INTO client_metric (task_id, round_id, client_id, train_loss, train_time, " \
+              "train_upload_size, train_download_size, train_upload_size) VALUES (?, ? ,? ,?, ?, ?, ?, ?);"
+
+        param = (tid, rid, cid, train_loss, train_time, train_upload_time, train_download_size, train_upload_size)
+        try:
+            self._retry_execute(sql, param)
+        except sqlite3.OperationalError as e:
+            logger.error("Failed to store client train metric, error: {}".format(e))
+
+    def store_client_test_metric(self, tid, rid, cid, test_acc, test_loss, test_time,
+                                 test_upload_time, test_download_size):
+        sql = "UPDATE client_metric SET test_accuracy=?, test_loss=?, test_time=? ,test_upload_size=?, " \
+              "test_download_size=? WHERE task_id=? AND round_id=? AND client_id=?;"
+        param = (test_acc, test_loss, test_time, test_upload_time, test_download_size, tid, rid, cid)
+        try:
+            self._retry_execute(sql, param)
+        except sqlite3.OperationalError as e:
+            logger.error("Failed to store client test metric, error: {}".format(e))
+
+    # ------------------ get metrics ------------------
+
+    def get_task_metric(self, task_id):
+        sql = "SELECT * FROM task_metric WHERE task_id=?"
+        with self._conn:
+            result = self._conn.execute(sql, (task_id,))
+            for r in result:
+                return r
+
+    def get_round_metrics(self, task_id, rounds):
+        if rounds:
+            sql = "SELECT * FROM round_metric WHERE task_id=? AND round_id IN (%s)" % ("?," * len(rounds))[:-1]
+            param = [task_id] + rounds
+        else:
+            sql = "SELECT * FROM round_metric WHERE task_id=?"
+            param = (task_id,)
+        with self._conn:
+            result = self._conn.execute(sql, param)
+        return result
+
+    def get_client_metrics(self, task_id, round_id, client_ids=None):
+        if client_ids:
+            sql = "SELECT * FROM client_metric WHERE task_id=? AND round_id=?  \
+                   AND client_id IN (%s)" % ("?," * len(client_ids))[:-1]
+            param = [task_id, round_id] + client_ids
+        else:
+            sql = "SELECT * FROM client_metric WHERE task_id=? AND round_id=?"
+            param = (task_id, round_id)
+        with self._conn:
+            result = self._conn.execute(sql, param)
+        return result
+
+    def get_round_train_test_time(self, tid, rounds, interval=1):
+        sql = "SELECT SUM(train_time+test_time) FROM round_metric WHERE task_id=? AND round_id<?"
+        result = []
+        for r in range(interval, rounds + interval, interval):
+            param = (tid, r)
+            with self._conn:
+                res = self._conn.execute(sql, param)
+            for i in res:
+                result.append((r, i[0]))
+        return result
+
+    # ------------------ delete metrics ------------------
+    def truncate_task_metric(self):
+        sql = "DELETE FROM task_metric"
+        try:
+            self._retry_execute(sql)
+        except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+            logger.error(f"Failed to truncate task metric, error: {e}")
+
+    def truncate_round_metric(self):
+        sql = "DELETE FROM round_metric"
+        try:
+            self._retry_execute(sql)
+        except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+            logger.error(f"Failed to truncate round metric, error: {e}")
+
+    def truncate_client_metric(self):
+        sql = "DELETE FROM client_metric"
+        try:
+            self._retry_execute(sql)
+        except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+            logger.error(f"Failed to truncate round metric, error: {e}")
+
+    def delete_round_metric(self, task_id, round_id):
+        sql = "DELETE FROM round_metric WHERE task_id=? AND round_id=?"
+        try:
+            self._retry_execute(sql, (task_id, round_id))
+        except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+            logger.error(f"Failed to delete round metric {task_id} {round_id}, error: {e}")
+
+    def _retry_execute(self, sql, param=(), timeout=DEFAULT_TIMEOUT):
+        for t in range(0, timeout + 1):
+            try:
+                with self._conn:
+                    self._conn.execute(sql, param)
+                break
+            except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+                logger.info("retry tracking, error: {}".format(e))
+                if t == timeout:
+                    raise e
+                sleep_time = random.uniform(0, 0.2)
+                time.sleep(sleep_time)
+                continue
+
+
+class RemoteStorage(object):
+    """RemoteStorage sends request to remote service to store tracking metrics
+    """
+
+    def __init__(self, address="localhost:12666"):
+        # TODO: put the remote address in config
+        self.tracking_stub = grpc_wrapper.init_stub(grpc_wrapper.TYPE_TRACKING, address)
+
+    def store_task_metric(self, metric):
+        response = self.tracking_stub.TrackTaskMetric(tracking_pb.TrackTaskMetricRequest(task_metric=metric.to_proto()))
+        if response.status == common_pb.SC_UNKNOWN:
+            logger.error("Failed to store task metric.")
+        return response.status
+
+    def store_round_metric(self, metric):
+        req = tracking_pb.TrackRoundMetricRequest(round_metric=metric.to_proto())
+        response = self.tracking_stub.TrackRoundMetric(req)
+        if response.status == common_pb.SC_UNKNOWN:
+            logger.error(f"Failed to store round metric, task_id: {metric.task_id} round_id: {metric.round_id}.")
+        return response.status
+
+    def store_client_metrics(self, metrics):
+        client_metrics = [m.to_proto() for m in metrics]
+        req = tracking_pb.TrackClientMetricRequest(client_metrics=client_metrics)
+        response = self.tracking_stub.TrackClientMetric(req)
+        if response.status == common_pb.SC_UNKNOWN:
+            logger.error(f"Failed to store client metrics.")
+        return response.status
+
+    def store_client_train_metric(self, tid, rid, cid, train_loss, train_time, train_upload_time,
+                                  train_download_size, train_upload_size):
+        req = tracking_pb.TrackClientTrainMetricRequest(task_id=tid,
+                                                        round_id=rid,
+                                                        client_id=cid,
+                                                        train_loss=train_loss,
+                                                        train_time=train_time,
+                                                        train_upload_time=train_upload_time,
+                                                        train_download_size=train_download_size,
+                                                        train_upload_size=train_upload_size)
+        response = self.tracking_stub.TrackClientTrainMetric(req)
+        if response.status == common_pb.SC_UNKNOWN:
+            logger.error("Failed to store client metric, task id: {} round id: {} client id: {}.".format(tid, rid, cid))
+        return response.status
+
+    def store_client_test_metric(self, tid, rid, cid, test_acc, test_loss, test_time,
+                                 test_upload_time, test_download_size):
+        req = tracking_pb.TrackClientTestMetricRequest(task_id=tid,
+                                                       round_id=rid,
+                                                       client_id=cid,
+                                                       test_accuracy=test_acc,
+                                                       test_loss=test_loss,
+                                                       test_time=test_time,
+                                                       test_upload_time=test_upload_time,
+                                                       test_download_size=test_download_size)
+        response = self.tracking_stub.TrackClientTestMetric(req)
+        if response.status == common_pb.SC_UNKNOWN:
+            logger.error("Failed to store client metric, task id: {} round id: {} client id: {}.".format(tid, rid, cid))
+        return response.status
diff --git a/easyfl/utils/__init__.py b/easyfl/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/easyfl/utils/float.py b/easyfl/utils/float.py
new file mode 100644
index 0000000..2cdf226
--- /dev/null
+++ b/easyfl/utils/float.py
@@ -0,0 +1,5 @@
+import numpy as np
+
+
+def rounding(array, num):
+    return list(np.around(np.array(array), num))
diff --git a/easyfl/version.py b/easyfl/version.py
new file mode 100644
index 0000000..7ba30ed
--- /dev/null
+++ b/easyfl/version.py
@@ -0,0 +1,17 @@
+__version__ = '0.1.2'
+short_version = __version__
+
+
+def parse_version_info(version_str):
+    version_info = []
+    for x in version_str.split('.'):
+        if x.isdigit():
+            version_info.append(int(x))
+        elif x.find('rc') != -1:
+            patch_version = x.split('rc')
+            version_info.append(int(patch_version[0]))
+            version_info.append(f'rc{patch_version[1]}')
+    return tuple(version_info)
+
+
+version_info = parse_version_info(__version__)
diff --git a/examples/cifar10.py b/examples/cifar10.py
new file mode 100644
index 0000000..754e9e9
--- /dev/null
+++ b/examples/cifar10.py
@@ -0,0 +1,9 @@
+import easyfl
+
+config = {
+    "data": {"dataset": "cifar10"},
+    "model": "simple_cnn",
+    "test_mode": "test_in_server"
+}
+easyfl.init(config)
+easyfl.run()
diff --git a/examples/dataset_registration.py b/examples/dataset_registration.py
new file mode 100644
index 0000000..277b130
--- /dev/null
+++ b/examples/dataset_registration.py
@@ -0,0 +1,50 @@
+import torch.nn.functional as F
+from torch import nn
+from torchvision import transforms
+
+import easyfl
+from easyfl.datasets import FederatedImageDataset
+from easyfl.models import BaseModel
+
+
+class TestModel(BaseModel):
+    def __init__(self):
+        super(TestModel, self).__init__()
+        self.conv1 = nn.Conv2d(3, 32, 224, padding=(2, 2))
+        self.conv2 = nn.Conv2d(32, 64, 5, padding=(2, 2))
+        self.fc1 = nn.Linear(64, 128)
+        self.fc2 = nn.Linear(128, 42)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = x.view(-1, 64)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+
+        return x
+
+
+default_transfrom = transforms.Compose([
+    # images are of different size, reshape them to same size. Up to you to decide what size to use.
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),  # convert image to torch tensor
+    transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))])  # normalizing images helps improve convergence
+root = "/Users/sg0014000170m/Downloads/shopee-product-detection-student/train/train/train"
+train_data = FederatedImageDataset(root,
+                                   simulated=False,
+                                   do_simulate=True,
+                                   transform=default_transfrom,
+                                   num_of_clients=100)
+test_data = FederatedImageDataset(root,
+                                  simulated=False,
+                                  do_simulate=False,
+                                  transform=default_transfrom,
+                                  num_of_clients=100)
+
+easyfl.register_model(TestModel)
+easyfl.register_dataset(train_data, test_data)
+easyfl.init()
+easyfl.run()
diff --git a/examples/distributed_slurm.py b/examples/distributed_slurm.py
new file mode 100644
index 0000000..da9668a
--- /dev/null
+++ b/examples/distributed_slurm.py
@@ -0,0 +1,21 @@
+import easyfl
+
+from easyfl.distributed import slurm
+
+rank, local_rank, world_size, host_addr = slurm.setup()
+
+configs = {
+    "gpu": 4,
+    "distributed": {
+        "rank": rank,
+        "local_rank": local_rank,
+        "world_size": world_size,
+        "init_method": host_addr,
+    },
+    "server": {
+        "clients_per_round": 20,
+    }
+}
+
+easyfl.init(configs)
+easyfl.run()
diff --git a/examples/femnist.py b/examples/femnist.py
new file mode 100644
index 0000000..9a778bc
--- /dev/null
+++ b/examples/femnist.py
@@ -0,0 +1,12 @@
+import easyfl
+
+config = {
+    "task_id": "femnist",
+    "data": {"dataset": "femnist", "split_type": "iid"},
+    "server": {"rounds": 5, "clients_per_round": 2, "test_all": True},
+    "client": {"local_epoch": 5},
+    "model": "lenet",
+    "test_mode": "test_in_client",
+}
+easyfl.init(config)
+easyfl.run()
diff --git a/examples/remote_client.py b/examples/remote_client.py
new file mode 100644
index 0000000..aa6f0a4
--- /dev/null
+++ b/examples/remote_client.py
@@ -0,0 +1,3 @@
+import easyfl
+
+easyfl.start_remote_client()
diff --git a/examples/remote_run.py b/examples/remote_run.py
new file mode 100644
index 0000000..99b9357
--- /dev/null
+++ b/examples/remote_run.py
@@ -0,0 +1,58 @@
+import argparse
+
+import easyfl
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.pb import server_service_pb2 as server_pb
+from easyfl.protocol import codec
+from easyfl.communication import grpc_wrapper
+from easyfl.registry import get_clients, SOURCES
+
+
+parser = argparse.ArgumentParser(description='Federated Server')
+parser.add_argument('--server-addr',
+                    type=str,
+                    default="172.18.0.1:23501",
+                    help='Server address')
+parser.add_argument('--etcd-addrs',
+                    type=str,
+                    default="172.17.0.1:2379",
+                    help='Etcd address, or list of etcd addrs separated by ","')
+parser.add_argument('--source',
+                    type=str,
+                    default="manual",
+                    choices=SOURCES,
+                    help='Source to get the clients')
+args = parser.parse_args()
+
+
+def send_run_request():
+    config = {
+        "data": {"dataset": "femnist"},
+        "model": "lenet",
+        "test_mode": "test_in_client"
+    }
+
+    print("Server address: {}".format(args.server_addr))
+    print("Etcd address: {}".format(args.etcd_addrs))
+
+    easyfl.init(config)
+    model = easyfl.init_model()
+    stub = grpc_wrapper.init_stub(grpc_wrapper.TYPE_SERVER, args.server_addr)
+
+    request = server_pb.RunRequest(
+        model=codec.marshal(model),
+    )
+
+    clients = get_clients(args.source, args.etcd_addrs)
+    for c in clients:
+        request.clients.append(server_pb.Client(client_id=c.id, index=c.index, address=c.address))
+
+    response = stub.Run(request)
+    if response.status.code == common_pb.SC_OK:
+        print("Success")
+    else:
+        print(response)
+
+
+if __name__ == '__main__':
+    send_run_request()
diff --git a/examples/remote_server.py b/examples/remote_server.py
new file mode 100644
index 0000000..7e39e36
--- /dev/null
+++ b/examples/remote_server.py
@@ -0,0 +1,11 @@
+import easyfl
+
+config = {
+    "data": {"dataset": "femnist"},
+    "model": "lenet",
+    "test_mode": "test_in_client",
+    "server": {"rounds": 5, "clients_per_round": 2},
+    "client": {"track": True},
+}
+
+easyfl.start_remote_server(config)
diff --git a/examples/remote_stop.py b/examples/remote_stop.py
new file mode 100644
index 0000000..7fafbff
--- /dev/null
+++ b/examples/remote_stop.py
@@ -0,0 +1,26 @@
+import argparse
+
+from easyfl.communication import grpc_wrapper
+from easyfl.pb import common_pb2 as common_pb
+from easyfl.pb import server_service_pb2 as server_pb
+
+parser = argparse.ArgumentParser(description='Federated Server')
+parser.add_argument('--server-addr',
+                    type=str,
+                    default="172.18.0.1:23501",
+                    help='Server address')
+
+args = parser.parse_args()
+
+
+def send_stop_request():
+    stub = grpc_wrapper.init_stub(grpc_wrapper.TYPE_SERVER, args.server_addr)
+    response = stub.Stop(server_pb.StopRequest())
+    if response.status.code == common_pb.SC_OK:
+        print("Success")
+    else:
+        print(response)
+
+
+if __name__ == '__main__':
+    send_stop_request()
diff --git a/examples/remote_tracker.py b/examples/remote_tracker.py
new file mode 100644
index 0000000..86fcc5f
--- /dev/null
+++ b/examples/remote_tracker.py
@@ -0,0 +1,6 @@
+from easyfl.tracking import service
+
+parser = service.create_argument_parser()
+args = parser.parse_args()
+
+service.start_tracking_service(args.local_port)
diff --git a/examples/shakespeare.py b/examples/shakespeare.py
new file mode 100644
index 0000000..2f7e3b2
--- /dev/null
+++ b/examples/shakespeare.py
@@ -0,0 +1,9 @@
+import easyfl
+
+config = {
+    "data": {"dataset": "shakespeare"},
+    "model": "rnn", 
+    "test_mode": "test_in_client"
+}
+easyfl.init(config)
+easyfl.run()
diff --git a/kubernetes/client.yml b/kubernetes/client.yml
new file mode 100644
index 0000000..6f345f6
--- /dev/null
+++ b/kubernetes/client.yml
@@ -0,0 +1,38 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: easyfl-client
+  namespace: easyfl
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: easyfl-client
+  template:
+    metadata:
+      labels:
+        app: easyfl-client
+    spec:
+      containers:
+      - name: easyfl-client
+        image: easyfl-client
+        imagePullPolicy: IfNotPresent
+        env:
+        - name: PYTHONUNBUFFERED
+          value: "1"
+        args: ["--is-remote", "True", "--local-port", "23400", "--server-addr", "easyfl-server-svc.easyfl:23501", "--tracker-addr", "easyfl-tracker-svc.easyfl:12666"]
+        ports:
+        - containerPort: 23501
+        volumeMounts:
+          - mountPath: /app/easyfl/datasets/femnist/data
+            name: data-volume
+      volumes:
+      - name: data-volume
+        hostPath:
+          path: /home/zwm/easyfl/easyfl/datasets/femnist/data
+      tolerations:
+      - key: "node-role.kubernetes.io/master"
+        operator: "Exists"
+        effect: "NoSchedule"
+      nodeSelector:
+        kubernetes.io/hostname: "node1"
\ No newline at end of file
diff --git a/kubernetes/namespace.yml b/kubernetes/namespace.yml
new file mode 100644
index 0000000..2724419
--- /dev/null
+++ b/kubernetes/namespace.yml
@@ -0,0 +1,10 @@
+{
+  "apiVersion": "v1",
+  "kind": "Namespace",
+  "metadata": {
+    "name": "easyfl",
+    "labels": {
+      "name": "easyfl"
+    }
+  }
+}
\ No newline at end of file
diff --git a/kubernetes/server.yml b/kubernetes/server.yml
new file mode 100644
index 0000000..4a03002
--- /dev/null
+++ b/kubernetes/server.yml
@@ -0,0 +1,20 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: easyfl-server
+  namespace: easyfl
+  labels:
+    app: easyfl-server
+spec:
+  containers:
+  - name: easyfl-server
+    image: easyfl-server
+    imagePullPolicy: IfNotPresent
+    env:
+    - name: PYTHONUNBUFFERED
+      value: "1"
+    args: ["--is-remote", "True", "--local-port", "23501", "--tracker-addr", "easyfl-tracker-svc.easyfl:12666"]
+    ports:
+    - containerPort: 23501
+  nodeSelector:
+    kubernetes.io/hostname: "node2"
diff --git a/kubernetes/services.yml b/kubernetes/services.yml
new file mode 100644
index 0000000..edbe6cb
--- /dev/null
+++ b/kubernetes/services.yml
@@ -0,0 +1,43 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: easyfl-server-svc
+  namespace: easyfl
+spec:
+  type: NodePort
+  selector:
+    app: easyfl-server
+  ports:
+    - protocol: TCP
+      port: 23501
+      targetPort: 23501
+      nodePort: 32501
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: easyfl-client-svc
+  namespace: easyfl
+spec:
+  clusterIP: None
+  selector:
+    app: easyfl-client
+  ports:
+    - protocol: TCP
+      port: 23400
+      targetPort: 23400
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: easyfl-tracker-svc
+  namespace: easyfl
+spec:
+  type: NodePort
+  selector:
+    app: easyfl-tracker
+  ports:
+    - protocol: TCP
+      port: 12666
+      targetPort: 12666
+      nodePort: 32666
diff --git a/kubernetes/tracker.yml b/kubernetes/tracker.yml
new file mode 100644
index 0000000..e991816
--- /dev/null
+++ b/kubernetes/tracker.yml
@@ -0,0 +1,20 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: easyfl-tracker
+  namespace: easyfl
+  labels:
+    app: easyfl-tracker
+spec:
+  containers:
+  - name: easyfl-tracker
+    image: easyfl-tracker
+    imagePullPolicy: IfNotPresent
+    env:
+    - name: PYTHONUNBUFFERED
+      value: "1"
+    args: ["--local-port", "12666"]
+    ports:
+    - containerPort: 12666
+  nodeSelector:
+    kubernetes.io/hostname: "node1"
\ No newline at end of file
diff --git a/protos/easyfl/pb/client_service.proto b/protos/easyfl/pb/client_service.proto
new file mode 100644
index 0000000..5107efb
--- /dev/null
+++ b/protos/easyfl/pb/client_service.proto
@@ -0,0 +1,53 @@
+syntax = "proto3";
+
+import "easyfl/pb/common.proto";
+
+package easyfl.pb;
+
+enum OperationType {
+    OP_TYPE_TRAIN = 0;
+    OP_TYPE_TEST = 1;
+}
+
+message OperateRequest {
+    // Operation type: train or test
+    OperationType type = 1;
+    // Model parameters for client to start next round of training
+    bytes model = 2;
+    // Data index for selecting data partition for training.
+    // Optional, depends on the data loading type of client.
+    int32 data_index = 3;
+    // Configs for executing operation
+    OperateConfig config = 4;
+}
+
+message OperateConfig {
+    int32 batch_size = 1;
+    int32 local_epoch = 2;
+    int64 seed = 3;
+    Optimizer optimizer = 4;
+    // Whether execute test before uploading model.
+    bool local_test = 5;
+    // task id for current operation
+    string task_id = 6;
+    // round id for current operation
+    int32 round_id = 7;
+    // whether to track clients
+    bool track = 8;
+    // testing batch size
+    int32 test_batch_size = 9;
+}
+
+message Optimizer {
+    string type = 1;
+    float lr = 2;
+    float momentum = 3;
+}
+
+message OperateResponse {
+    Status status = 1;
+}
+
+service ClientService {
+    rpc Operate (OperateRequest) returns (OperateResponse) {}
+}
\ No newline at end of file
diff --git a/protos/easyfl/pb/common.proto b/protos/easyfl/pb/common.proto
new file mode 100644
index 0000000..1f507fc
--- /dev/null
+++ b/protos/easyfl/pb/common.proto
@@ -0,0 +1,65 @@
+syntax = "proto3";
+
+package easyfl.pb;
+
+enum StatusCode {
+    SC_OK = 0;
+    SC_UNKNOWN = 1;
+    SC_INVALID_REQUEST = 2;
+    SC_DEADLINE_EXCEEDED = 3;
+    SC_NOT_FOUND = 4;
+    SC_ALREADY_EXISTS = 5;
+}
+
+message Status {
+    StatusCode code = 1;
+    string message = 2;
+}
+
+enum DataType {
+    // Model parameters or gradients
+    DATA_TYPE_PARAMS = 0;
+    // Performance
+    DATA_TYPE_PERFORMANCE = 1;
+}
+
+message TaskMetric {
+    string task_id = 1;
+    string configuration = 2;
+}
+
+message RoundMetric {
+    string task_id = 1;
+    int32 round_id = 2;
+    float test_accuracy = 3;
+    float test_loss = 4;
+    float round_time = 5;
+    float train_time = 6;
+    float test_time = 7;
+    float train_distribute_time = 8;
+    float test_distribute_time = 9;
+    float train_upload_size = 10;
+    float train_download_size = 11;
+    float test_upload_size = 12;
+    float test_download_size = 13;
+    string extra = 14;
+}
+
+message ClientMetric {
+    string task_id = 1;
+    int32 round_id = 2;
+    string client_id = 3;
+    repeated float train_accuracy = 4;
+    repeated float train_loss = 5;
+    float test_accuracy = 6;
+    float test_loss = 7;
+    float train_time = 8;
+    float test_time = 9;
+    float train_upload_time = 10;
+    float test_upload_time = 11;
+    float train_upload_size = 12;
+    float train_download_size = 13;
+    float test_upload_size = 14;
+    float test_download_size = 15;
+    string extra = 16;
+}
\ No newline at end of file
diff --git a/protos/easyfl/pb/server_service.proto b/protos/easyfl/pb/server_service.proto
new file mode 100644
index 0000000..689ec0d
--- /dev/null
+++ b/protos/easyfl/pb/server_service.proto
@@ -0,0 +1,63 @@
+syntax = "proto3";
+
+package easyfl.pb;
+import "easyfl/pb/common.proto";
+
+message UploadRequest {
+    string task_id = 1;
+    int32 round_id = 2;
+    string client_id = 3;
+    UploadContent content = 4;
+}
+
+message UploadContent {
+    // Data is the marshaled data, value depends on data type.
+    bytes data = 1;
+    // Type of data.
+    DataType type = 2;
+    // optional, number of data point
+    int64 data_size = 3;
+    // optional, client metric
+    ClientMetric metric = 4;
+    // optional, extra upload content
+    bytes extra = 99;
+}
+
+message Performance {
+    float accuracy = 1;
+    float loss = 2;
+}
+
+message UploadResponse {
+    Status status = 1;
+}
+
+message RunRequest {
+    bytes model = 1;
+    // Optional, run server with provided clients.
+    repeated Client clients = 2;
+    // [Deprecated] Optional, run server with client addresses getting from etcd.
+    string etcd_addresses = 3;
+}
+
+message RunResponse {
+    Status status = 1;
+}
+
+message StopRequest {}
+
+message StopResponse {
+    Status status = 1;
+}
+
+message Client {
+    string client_id = 1;
+    string address = 2;
+    int32 index = 3;
+}
+
+service ServerService {
+    rpc Upload (UploadRequest) returns (UploadResponse) {}
+    rpc Run (RunRequest) returns (RunResponse) {}
+    rpc Stop (StopRequest) returns (StopResponse) {}
+}
diff --git a/protos/easyfl/pb/tracking_service.proto b/protos/easyfl/pb/tracking_service.proto
new file mode 100644
index 0000000..13ae98a
--- /dev/null
+++ b/protos/easyfl/pb/tracking_service.proto
@@ -0,0 +1,115 @@
+syntax = "proto3";
+
+package easyfl.pb;
+import "easyfl/pb/common.proto";
+
+message TrackTaskMetricRequest{
+    TaskMetric task_metric = 1;
+}
+
+message TrackTaskMetricResponse{
+    Status status = 1;
+}
+
+message TrackRoundMetricRequest{
+    RoundMetric round_metric = 1;
+}
+
+message TrackRoundMetricResponse{
+    Status status = 1;
+}
+
+message TrackClientMetricRequest{
+    repeated ClientMetric client_metrics = 1;
+}
+
+message TrackClientMetricResponse{
+    Status status = 1;
+}
+
+
+message TrackClientTrainMetricRequest{
+    string task_id = 1;
+    int32 round_id = 2;
+    string client_id = 3;
+    repeated float train_loss = 4;
+    float train_time = 5;
+    float train_upload_time = 6;
+    float train_download_size = 7;
+    float train_upload_size = 8;
+}
+
+message TrackClientTrainMetricResponse{
+    Status status = 1;
+}
+
+message TrackClientTestMetricRequest{
+    string task_id = 1;
+    int32 round_id = 2;
+    string client_id = 3;
+    float test_accuracy = 4;
+    float test_loss = 5;
+    float test_time = 6;
+    float test_upload_time = 7;
+    float test_download_size = 8;
+}
+
+message TrackClientTestMetricResponse{
+    Status status = 1;
+}
+
+message GetRoundTrainTestTimeRequest{
+    string task_id = 1;
+    int32 rounds = 2;
+    int32 interval = 3;
+}
+
+message TrainTestTime{
+    int32 round_id = 1;
+    float time = 2;
+}
+
+message GetRoundTrainTestTimeResponse{
+    repeated TrainTestTime train_test_times = 1;
+    Status status = 2;
+}
+
+message GetRoundMetricsRequest {
+    string task_id = 1;
+    // empty list means get all rounds;
+    repeated int32 rounds = 2;
+}
+
+message GetRoundMetricsResponse {
+    string task_id = 1;
+    int32 round_id = 2;
+    repeated RoundMetric metrics = 3;
+    Status status = 4;
+}
+
+message GetClientMetricsRequest {
+    string task_id = 1;
+    int32 round_id = 2;
+    repeated string client_ids = 3;
+}
+
+message GetClientMetricsResponse {
+    string task_id = 1;
+    int32 round_id = 2;
+    repeated ClientMetric metrics = 3;
+    Status status = 4;
+}
+
+
+service TrackingService {
+    rpc TrackTaskMetric(TrackTaskMetricRequest) returns (TrackTaskMetricResponse) {}
+    rpc TrackRoundMetric(TrackRoundMetricRequest) returns (TrackRoundMetricResponse) {}
+    rpc TrackClientMetric(TrackClientMetricRequest) returns (TrackClientMetricResponse) {}
+
+    rpc TrackClientTrainMetric(TrackClientTrainMetricRequest) returns (TrackClientTrainMetricResponse) {}
+    rpc TrackClientTestMetric(TrackClientTestMetricRequest) returns (TrackClientTestMetricResponse) {}
+
+    rpc GetRoundMetrics(GetRoundMetricsRequest) returns (GetRoundMetricsResponse) {}
+    rpc GetClientMetrics(GetClientMetricsRequest) returns (GetClientMetricsResponse) {}
+    rpc GetRoundTrainTestTime(GetRoundTrainTestTimeRequest) returns (GetRoundTrainTestTimeResponse) {}
+}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..7e870e9
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1 @@
+-r requirements/runtime.txt
\ No newline at end of file
diff --git a/requirements/docs.txt b/requirements/docs.txt
new file mode 100644
index 0000000..d6c1cd1
--- /dev/null
+++ b/requirements/docs.txt
@@ -0,0 +1,7 @@
+docutils==0.16.0
+-e git+https://github.com/easyfl-ai/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
+recommonmark
+sphinx==4.0.2
+sphinx-copybutton
+sphinx_markdown_tables
+sphinx_rtd_theme==0.5.2
diff --git a/requirements/readthedocs.txt b/requirements/readthedocs.txt
new file mode 100644
index 0000000..ac988bd
--- /dev/null
+++ b/requirements/readthedocs.txt
@@ -0,0 +1,2 @@
+torch
+torchvision
diff --git a/requirements/runtime.txt b/requirements/runtime.txt
new file mode 100644
index 0000000..4c90e2d
--- /dev/null
+++ b/requirements/runtime.txt
@@ -0,0 +1,9 @@
+etcd3==0.12.0
+google-auth==1.21.2
+grpcio
+grpcio-tools
+kubernetes==11.0.0
+numpy
+omegaconf==2.0.0
+requests==2.24.0
+tqdm==4.32.1
\ No newline at end of file
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..9d5f797
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,3 @@
+# Inside of setup.cfg
+[metadata]
+description-file = README.md
\ No newline at end of file
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..5559f25
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+# Copyright (c) EasyFL. All rights reserved.
+from setuptools import find_packages, setup
+
+VERSION_FILE = 'easyfl/version.py'
+
+
+def readme():
+    with open('README.md', encoding='utf-8') as f:
+        content = f.read()
+    return content
+
+
+def get_version():
+    with open(VERSION_FILE, 'r') as f:
+        exec(compile(f.read(), VERSION_FILE, 'exec'))
+    return locals()['__version__']
+
+
+def parse_requirements(fname='requirements.txt', with_version=True):
+    """Parse the package dependencies listed in a requirements file but strips
+    specific versioning information.
+
+    Args:
+        fname (str): path to requirements file
+        with_version (bool, default=False): if True include version specs
+
+    Returns:
+        List[str]: list of requirements items
+
+    CommandLine:
+        python -c "import setup; print(setup.parse_requirements())"
+    """
+    import re
+    import sys
+    from os.path import exists
+    require_fpath = fname
+
+    def parse_line(line):
+        """Parse information from a line in a requirements text file."""
+        if line.startswith('-r '):
+            # Allow specifying requirements in other files
+            target = line.split(' ')[1]
+            for info in parse_require_file(target):
+                yield info
+        else:
+            info = {'line': line}
+            if line.startswith('-e '):
+                info['package'] = line.split('#egg=')[1]
+            elif '@git+' in line:
+                info['package'] = line
+            else:
+                # Remove versioning from the package
+                pat = '(' + '|'.join(['>=', '==', '>']) + ')'
+                parts = re.split(pat, line, maxsplit=1)
+                parts = [p.strip() for p in parts]
+
+                info['package'] = parts[0]
+                if len(parts) > 1:
+                    op, rest = parts[1:]
+                    if ';' in rest:
+                        # Handle platform specific dependencies
+                        # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies
+                        version, platform_deps = map(str.strip,
+                                                     rest.split(';'))
+                        info['platform_deps'] = platform_deps
+                    else:
+                        version = rest  # NOQA
+                    info['version'] = (op, version)
+            yield info
+
+    def parse_require_file(fpath):
+        with open(fpath, 'r') as f:
+            for line in f.readlines():
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    for info in parse_line(line):
+                        yield info
+
+    def gen_packages_items():
+        if exists(require_fpath):
+            for info in parse_require_file(require_fpath):
+                parts = [info['package']]
+                if with_version and 'version' in info:
+                    parts.extend(info['version'])
+                if not sys.version.startswith('3.4'):
+                    # apparently package_deps are broken in 3.4
+                    platform_deps = info.get('platform_deps')
+                    if platform_deps is not None:
+                        parts.append(';' + platform_deps)
+                item = ''.join(parts)
+                yield item
+
+    packages = list(gen_packages_items())
+    return packages
+
+
+if __name__ == '__main__':
+    setup(
+        name='easyfl',
+        version=get_version(),
+        description='A low-code federated learning platform for dummies',
+        long_description=readme(),
+        long_description_content_type='text/markdown',
+        author='EasyFL Contributors',
+        author_email='easyfl.ai@gmail.com',
+        keywords=['federated learning', 'machine learning', 'distributed machine learning', 'computer vision'],
+        url='https://github.com/EasyFL-AI/EasyFL',
+        download_url='https://github.com/EasyFL-AI/EasyFL/archive/refs/tags/v0.1.0.tar.gz',
+        packages=find_packages(),
+        data_files=[('requirements', ['requirements/runtime.txt']), ('easyfl', ['easyfl/config.yaml'])],
+        include_package_data=True,
+        classifiers=[
+            'Development Status :: 3 - Alpha',
+            # Chose either "3 - Alpha", "4 - Beta" or "5 - Production/Stable" as the current state of your package
+            'License :: OSI Approved :: Apache Software License',
+            'Topic :: Software Development :: Build Tools',
+            'Operating System :: OS Independent',
+            'Programming Language :: Python :: 3',
+            'Programming Language :: Python :: 3.6',
+            'Programming Language :: Python :: 3.7',
+            'Programming Language :: Python :: 3.8',
+            'Programming Language :: Python :: 3.9',
+        ],
+        license='Apache License 2.0',
+        install_requires=parse_requirements('requirements/runtime.txt'),
+        extras_require={
+            'all': parse_requirements('requirements.txt'),
+        },
+        ext_modules=[],
+        zip_safe=False)