bert-large

CONTRIBUTING.md

+## Contributing to LiBai
\ No newline at end of file

LICENSE

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

changelog.md

+## Changelog
+
+### Beta 0.1.0 (22/03/2022)
+
+**New Features:**
+- Support Data Parallelism
+- Support 1D Tensor Parallelism
+- Support Pipeline Parallelism
+- Unified distributed Layers for both single-GPU and multi-GPU training
+- `LazyConfig` system for more flexible syntax and no predefined structures
+- Easy-to-use trainer and engine
+- Support both CV and NLP data processing
+- Mixed Precision Training
+- Activation Checkpointing
+- Gradient Accumulation
+- Gradient Clipping
+- Zero Redundancy Optimizer (ZeRO)
+
+**Supported Models:**
+- Support 3D parallel [BERT](https://arxiv.org/abs/1810.04805) model
+- Support 3D parallel [GPT-2](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) model
+- Support 3D parallel [T5](https://arxiv.org/abs/1910.10683) model
+- Support 3D parallel [Vision Transformer](https://arxiv.org/abs/2010.11929)
+- Support Data parallel [Swin Transformer](https://arxiv.org/abs/2103.14030) model
+- Support finetune task in [QQP project](/projects/QQP/)
+- Support text classification task in [text classification project](/projects/text_classification/)

configs/bert_classification.py

+from libai.config import LazyCall
+from libai.models.bert_model import BertForClassification
+from .common.models.bert import cfg as bert_cfg
+from .common.models.graph import graph
+from .common.train import train
+from .common.optim import optim
+from .common.data.bert_dataset import tokenization, dataloader
+
+vocab_file = "./data_test/bert_data/bert-base-chinese-vocab.txt"
+data_prefix = "./data_test/bert_data/loss_compara_content_sentence"
+
+dataloader.train.dataset[0].data_prefix = data_prefix
+dataloader.train.dataset[0].indexed_dataset.data_prefix = data_prefix
+
+bert_cfg.num_labels = 2
+bert_cfg.classifier_dropout = 0.1
+
+model = LazyCall(BertForClassification)(cfg=bert_cfg)
+tokenization.tokenizer.vocab_file = vocab_file
+
+model.cfg.vocab_size = 21128
+model.cfg.intermediate_size = 3072
+model.cfg.num_attention_heads = 12
+model.cfg.hidden_layers = 12
+model.cfg.hidden_size = 768
+
+train.amp.enabled = True
+train.activation_checkpoint.enabled = True
+train.dist.pipeline_num_layers = model.cfg.hidden_layers
+
+train.output_dir = "output/bert_classification_output"

configs/bert_large_pretrain.py

+from libai.config import LazyCall
+from libai.evaluation import PPLEvaluator
+from .common.models.bert import pretrain_model as model
+from .common.models.graph import graph
+from .common.train import train
+from .common.optim import optim
+from .common.data.bert_dataset import dataloader, tokenization
+
+vocab_file = "./nlp_data/bert-base-chinese-vocab.txt"
+data_prefix = "./nlp_data/data/loss_compara_content_sentence"
+
+tokenization.tokenizer.vocab_file = vocab_file
+dataloader.train.dataset[0].data_prefix = data_prefix
+dataloader.train.dataset[0].indexed_dataset.data_prefix = data_prefix
+
+# Bert-large model config
+model.cfg.num_attention_heads = 16
+model.cfg.hidden_size = 768
+model.cfg.hidden_layers = 8
+
+train.input_placement_device = "cpu"
+
+train.dist.pipeline_num_layers = model.cfg.hidden_layers
+
+train.train_micro_batch_size = 16
+
+train.amp.enabled = True
+
+for ds in dataloader.train.dataset:
+    ds.max_seq_length = model.cfg.max_position_embeddings
+
+train.evaluation.evaluator = LazyCall(PPLEvaluator)()
+
+train.output_dir = "output/bert_output"
+

configs/common/data/bert_dataset.py

+from libai.config import LazyCall
+from omegaconf import OmegaConf
+from libai.data import build_nlp_test_loader, build_nlp_train_val_test_loader
+from libai.data.datasets import BertDataset
+from libai.data.data_utils import get_indexed_dataset
+
+from libai.tokenizer import BertTokenizer
+
+
+tokenization = OmegaConf.create()
+
+tokenization.tokenizer = LazyCall(BertTokenizer)(
+    vocab_file="bert-base-chinese-vocab.txt",
+    do_lower_case=True,
+    do_chinese_wwm=True,
+)
+tokenization.append_eod = False
+tokenization.make_vocab_size_divisible_by = 128
+
+dataloader = OmegaConf.create()
+
+dataloader.train = LazyCall(build_nlp_train_val_test_loader)(
+    dataset=[
+        LazyCall(BertDataset)(
+            name="bert",
+            data_prefix="/workspace/data/libai_dataset/loss_compara_content_sentence",
+            indexed_dataset=LazyCall(get_indexed_dataset)(
+                data_prefix="/workspace/data/libai_dataset/loss_compara_content_sentence",
+                data_impl="mmap",
+                skip_warmup=False,
+            ),
+            max_seq_length=512,
+            mask_lm_prob=0.15,
+            short_seq_prob=0.1,
+            binary_head=True,
+            seed=1234,
+            masking_style="bert-cn-wwm",
+        ),
+    ],
+    train_val_test_num_samples=None,  # a hint for deferred assignment
+    splits=[[949.0, 50.0, 1.0]],
+    weights=[1.0],
+    num_workers=4,
+)

configs/common/data/cifar100.py

+from omegaconf import OmegaConf
+from flowvision import transforms
+from flowvision.data.mixup import Mixup
+from flowvision.transforms import InterpolationMode
+from flowvision.transforms.functional import str_to_interp_mode
+
+from libai.data.datasets import CIFAR100Dataset
+from libai.data.build import build_image_train_loader, build_image_test_loader
+from libai.config import LazyCall
+
+# mean and std of cifar100 dataset
+CIFAR100_TRAIN_MEAN = (0.5070751592371323, 0.48654887331495095, 0.4409178433670343)
+CIFAR100_TRAIN_STD = (0.2673342858792401, 0.2564384629170883, 0.27615047132568404)
+
+train_aug = LazyCall(transforms.Compose)(
+    transforms=[
+        LazyCall(transforms.RandomResizedCrop)(
+            size=(224, 224),
+            scale=(0.08, 1.0),
+            ratio=(3.0 / 4.0, 4.0 / 3.0),
+            interpolation=str_to_interp_mode("bicubic"),
+        ),
+        LazyCall(transforms.RandomHorizontalFlip)(),
+        LazyCall(transforms.ToTensor)(),
+        LazyCall(transforms.Normalize)(mean=CIFAR100_TRAIN_MEAN, std=CIFAR100_TRAIN_STD),
+    ]
+)
+
+test_aug = LazyCall(transforms.Compose)(
+    transforms=[
+        LazyCall(transforms.Resize)(
+            size=256,
+            interpolation=InterpolationMode.BICUBIC,
+        ),
+        LazyCall(transforms.CenterCrop)(
+            size=224,
+        ),
+        LazyCall(transforms.ToTensor)(),
+        LazyCall(transforms.Normalize)(
+            mean=CIFAR100_TRAIN_MEAN,
+            std=CIFAR100_TRAIN_STD,
+        ),
+    ]
+)
+
+
+# Dataloader config
+dataloader = OmegaConf.create()
+dataloader.train = LazyCall(build_image_train_loader)(
+    dataset=[
+        LazyCall(CIFAR100Dataset)(
+            root="./",
+            train=True,
+            download=True,
+            transform=train_aug,
+        ),
+    ],
+    num_workers=4,
+    mixup_func=LazyCall(Mixup)(
+        mixup_alpha=0.8,
+        cutmix_alpha=1.0,
+        prob=1.0,
+        switch_prob=0.5,
+        mode="batch",
+        num_classes=100,
+    ),
+)
+
+dataloader.test = [
+    LazyCall(build_image_test_loader)(
+        dataset=LazyCall(CIFAR100Dataset)(
+            root="./",
+            train=False,
+            download=True,
+            transform=test_aug,
+        ),
+        num_workers=4,
+    )
+]

configs/common/data/gpt_dataset.py

+from libai.config import LazyCall
+from omegaconf import OmegaConf
+from libai.data import build_nlp_test_loader, build_nlp_train_val_test_loader
+from libai.data.datasets import GPT2Dataset
+from libai.data.data_utils import get_indexed_dataset
+
+from libai.tokenizer import GPT2Tokenizer
+
+
+tokenization = OmegaConf.create()
+
+tokenization.tokenizer = LazyCall(GPT2Tokenizer)(
+    vocab_file="/workspace/data/gpt_dataset/gpt2-vocab.json",
+    merges_file="/workspace/data/gpt_dataset/gpt2-merges.txt",
+    do_lower_case=True,
+    do_chinese_wwm=True,
+)
+tokenization.append_eod = False
+tokenization.make_vocab_size_divisible_by = 128
+
+dataloader = OmegaConf.create()
+
+dataloader.train = LazyCall(build_nlp_train_val_test_loader)(
+    dataset=[
+        LazyCall(GPT2Dataset)(
+            name="gpt-2",
+            data_prefix="/workspace/data/libai_dataset/loss_compara_content_sentence",
+            indexed_dataset=LazyCall(get_indexed_dataset)(
+                data_prefix="/workspace/data/libai_dataset/loss_compara_content_sentence",
+                data_impl="mmap",
+                skip_warmup=False,
+            ),
+            max_seq_length=1024,
+            seed=1234,
+        ),
+    ],
+    train_val_test_num_samples=None,  # a hint for deferred assignment
+    splits=[[949.0, 50.0, 1.0]],
+    weights=[1.0],
+    num_workers=4,
+)

configs/common/data/imagenet.py

+from omegaconf import OmegaConf
+from flowvision import transforms
+from flowvision.transforms import InterpolationMode
+from flowvision.transforms.functional import str_to_interp_mode
+from flowvision.data.constants import (
+    IMAGENET_DEFAULT_MEAN,
+    IMAGENET_DEFAULT_STD,
+)
+from flowvision.data.auto_augment import rand_augment_transform
+from flowvision.data.random_erasing import RandomErasing
+
+from libai.config import LazyCall
+from libai.data.datasets import ImageNetDataset
+from libai.data.build import build_image_train_loader, build_image_test_loader
+
+train_aug = LazyCall(transforms.Compose)(
+    transforms=[
+        LazyCall(transforms.RandomResizedCrop)(
+            size=224,
+            scale=(0.08, 1.0),
+            ratio=(3.0 / 4.0, 4.0 / 3.0),
+            interpolation=InterpolationMode.BICUBIC,
+        ),
+        LazyCall(transforms.RandomHorizontalFlip)(p=0.5),
+        LazyCall(rand_augment_transform)(
+            config_str="rand-m9-mstd0.5-inc1",
+            hparams=dict(
+                translate_const=int(224 * 0.45),
+                img_mean=tuple([min(255, round(255 * x)) for x in IMAGENET_DEFAULT_MEAN]),
+                interpolation=str_to_interp_mode("bicubic"),
+            ),
+        ),
+        LazyCall(transforms.ToTensor)(),
+        LazyCall(transforms.Normalize)(
+            mean=IMAGENET_DEFAULT_MEAN,
+            std=IMAGENET_DEFAULT_STD,
+        ),
+        LazyCall(RandomErasing)(
+            probability=0.25,
+            mode="pixel",
+            max_count=1,
+            num_splits=0,
+            device="cpu",
+        ),
+    ]
+)
+
+
+test_aug = LazyCall(transforms.Compose)(
+    transforms=[
+        LazyCall(transforms.Resize)(
+            size=256,
+            interpolation=InterpolationMode.BICUBIC,
+        ),
+        LazyCall(transforms.CenterCrop)(
+            size=224,
+        ),
+        LazyCall(transforms.ToTensor)(),
+        LazyCall(transforms.Normalize)(
+            mean=IMAGENET_DEFAULT_MEAN,
+            std=IMAGENET_DEFAULT_STD,
+        ),
+    ]
+)
+
+
+dataloader = OmegaConf.create()
+dataloader.train = LazyCall(build_image_train_loader)(
+    dataset=[
+        LazyCall(ImageNetDataset)(
+            root="./dataset",
+            train=True,
+            transform=train_aug,
+        ),
+    ],
+    num_workers=4,
+    mixup_func=None,
+)
+
+
+dataloader.test = [
+    LazyCall(build_image_test_loader)(
+        dataset=LazyCall(ImageNetDataset)(
+            root="./dataset",
+            train=False,
+            transform=test_aug,
+        ),
+        num_workers=4,
+    )
+]

configs/common/data/roberta_dataset.py

+from libai.config import LazyCall
+from omegaconf import OmegaConf
+from libai.data import build_nlp_test_loader, build_nlp_train_val_test_loader
+from libai.data.datasets import RobertaDataset
+from libai.data.data_utils import get_indexed_dataset
+
+from libai.tokenizer import RobertaTokenizer
+
+
+tokenization = OmegaConf.create()
+
+tokenization.tokenizer = LazyCall(RobertaTokenizer)(
+    vocab_file="roberta-vocab.json", merges_file="roberta-merges.txt"
+)
+tokenization.append_eod = False
+tokenization.make_vocab_size_divisible_by = 128
+
+dataloader = OmegaConf.create()
+
+dataloader.train = LazyCall(build_nlp_train_val_test_loader)(
+    dataset=[
+        LazyCall(RobertaDataset)(
+            name="roberta",
+            data_prefix="/workspace/data/libai_dataset/loss_compara_content_sentence",
+            indexed_dataset=LazyCall(get_indexed_dataset)(
+                data_prefix="/workspace/data/libai_dataset/loss_compara_content_sentence",
+                data_impl="mmap",
+                skip_warmup=False,
+            ),
+            max_seq_length=512,
+            mask_lm_prob=0.15,
+            short_seq_prob=0.0,
+            seed=1234,
+            masking_style="bert",
+        ),
+    ],
+    train_val_test_num_samples=None,  # a hint for deferred assignment
+    splits=[[949.0, 50.0, 1.0]],
+    weights=[1.0],
+    num_workers=4,
+)

configs/common/data/t5_dataset.py

+from libai.config import LazyCall
+from omegaconf import OmegaConf
+from libai.data import build_nlp_test_loader, build_nlp_train_val_test_loader
+from libai.data.datasets import T5Dataset
+from libai.data.data_utils import get_indexed_dataset
+
+from libai.tokenizer import BertTokenizer
+
+
+tokenization = OmegaConf.create()
+
+tokenization.setup = True
+
+special_tokens = []
+for i in range(100):
+    special_tokens.append(f"<extra_id_{i}>")
+tokenization.tokenizer = LazyCall(BertTokenizer)(
+    vocab_file="/workspace/data/libai_dataset/bert-base-chinese-vocab.txt",
+    do_lower_case=True,
+    do_chinese_wwm=True,
+    bos_token="[BOS]",
+    eos_token="[EOS]",
+    additional_special_tokens=special_tokens,
+)
+tokenization.append_eod = False
+tokenization.make_vocab_size_divisible_by = 128
+
+dataloader = OmegaConf.create()
+
+dataloader.train = LazyCall(build_nlp_train_val_test_loader)(
+    dataset=[
+        LazyCall(T5Dataset)(
+            name="t5",
+            data_prefix="/workspace/data/libai_dataset/loss_compara_content_sentence",
+            indexed_dataset=LazyCall(get_indexed_dataset)(
+                data_prefix="/workspace/data/libai_dataset/" "/loss_compara_content_sentence",
+                data_impl="mmap",
+                skip_warmup=False,
+            ),
+            max_seq_length=512,
+            max_seq_length_dec=128,
+            masked_lm_prob=0.15,
+            short_seq_prob=0.1,
+            seed=1234,
+        ),
+    ],
+    train_val_test_num_samples=None,  # a hint for deferred assignment
+    splits=[[949.0, 50.0, 1.0]],
+    weights=[1.0],
+    num_workers=4,
+)

configs/common/models/bert.py

+from omegaconf import DictConfig
+from libai.config import LazyCall
+from libai.models import BertModel, BertForPreTraining
+
+
+cfg = dict(
+    vocab_size=30522,
+    hidden_size=768,
+    hidden_layers=24,
+    num_attention_heads=12,
+    intermediate_size=4096,
+    hidden_dropout_prob=0.1,
+    attention_probs_dropout_prob=0.1,
+    max_position_embeddings=512,
+    num_tokentypes=2,
+    add_pooling_layer=True,
+    initializer_range=0.02,
+    layernorm_eps=1e-5,
+    bias_gelu_fusion=True,
+    bias_dropout_fusion=True,
+    scale_mask_softmax_fusion=True,
+    apply_query_key_layer_scaling=True,
+    apply_residual_post_layernorm=False,
+    add_binary_head=True,
+    amp_enabled=False,
+)
+
+cfg = DictConfig(cfg)
+
+bert_model = LazyCall(BertModel)(cfg=cfg)
+
+pretrain_model = LazyCall(BertForPreTraining)(cfg=cfg)

configs/common/models/gpt.py

+from omegaconf import DictConfig
+from libai.config import LazyCall
+from libai.models import GPTModel, GPTForPreTraining
+
+
+cfg = dict(
+    hidden_layers=6,
+    vocab_size=30522,
+    hidden_size=384,
+    ffn_hidden_size=1536,
+    num_attention_heads=12,
+    max_seq_length=1024,
+    embedding_dropout_prob=0,
+    attention_dropout_prob=0,
+    output_dropout_prob=0,
+    layernorm_epsilon=1e-5,
+    initializer_range=0.02,
+    use_scaled_init_for_output_weights=True,
+    bias_gelu_fusion=True,
+    bias_dropout_fusion=True,
+    scale_mask_softmax_fusion=True,
+    apply_query_key_layer_scaling=True,
+    apply_residual_post_layernorm=False,
+    amp_enabled=False,
+)
+
+cfg = DictConfig(cfg)
+
+gpt_model = LazyCall(GPTModel)(cfg=cfg)
+
+pretrain_model = LazyCall(GPTForPreTraining)(cfg=cfg)

configs/common/models/graph.py

+from omegaconf import DictConfig
+from libai.config import LazyCall
+from libai.models.utils import GraphBase
+
+
+graph = dict(
+    # options for graph or eager mode
+    enabled=True,
+    debug=-1,  # debug mode for graph
+    auto_parallel=dict(
+        enabled=False,
+        enable_auto_parallel_ignore_user_sbp_config=False,  # ignore all .to_global() in graph
+        trunk_algo=True,  # consider overlapping calculate time and transfer time
+        sbp_collector=False,  # use proxy node when one node transfer to many nodes
+    ),
+    train_graph=LazyCall(GraphBase)(
+        is_train=True,
+    ),
+    eval_graph=LazyCall(GraphBase)(is_train=False),
+)
+
+graph = DictConfig(graph)

configs/common/models/resmlp/resmlpB_24.py

+from libai.config import LazyCall
+from libai.models import ResMLP
+
+from .resmlp_12 import cfg
+
+
+cfg.patch_size = 8
+cfg.embed_dim = 768
+cfg.depth = 24
+cfg.init_scale = 1e-6
+
+model = LazyCall(ResMLP)(cfg=cfg)

configs/common/models/resmlp/resmlp_12.py

+from omegaconf import DictConfig
+from libai.config import LazyCall
+from libai.models import ResMLP
+
+
+cfg = dict(
+    img_size=224,
+    patch_size=16,
+    in_chans=3,
+    embed_dim=384,
+    depth=12,
+    drop_rate=0.0,
+    drop_path_rate=0.05,
+    init_scale=0.1,
+    num_classes=1000,
+    loss_func=None,
+)
+
+cfg = DictConfig(cfg)
+
+model = LazyCall(ResMLP)(cfg=cfg)

configs/common/models/resmlp/resmlp_24.py

+from libai.config import LazyCall
+from libai.models import ResMLP
+
+from .resmlp_12 import cfg
+
+
+cfg.depth = 24
+cfg.init_scale = 1e-5
+
+model = LazyCall(ResMLP)(cfg=cfg)

configs/common/models/resmlp/resmlp_36.py

+from libai.config import LazyCall
+from libai.models import ResMLP
+
+from .resmlp_12 import cfg
+
+
+cfg.depth = 36
+cfg.init_scale = 1e-6
+
+model = LazyCall(ResMLP)(cfg=cfg)

configs/common/models/roberta.py

+from omegaconf import DictConfig
+from libai.config import LazyCall
+from libai.models import RobertaModel, RobertaForPreTraining, RobertaForCausalLM
+
+
+cfg = dict(
+    vocab_size=50265,
+    hidden_size=768,
+    hidden_layers=12,
+    num_attention_heads=12,
+    intermediate_size=3072,
+    hidden_dropout_prob=0.1,
+    attention_probs_dropout_prob=0.1,
+    max_position_embeddings=514,
+    num_tokentypes=1,
+    add_pooling_layer=True,
+    initializer_range=0.02,
+    layernorm_eps=1e-5,
+    pad_token_id=1,
+    bias_gelu_fusion=True,
+    bias_dropout_fusion=True,
+    scale_mask_softmax_fusion=True,
+    apply_query_key_layer_scaling=True,
+    apply_residual_post_layernorm=False,
+    amp_enabled=False,
+)
+
+cfg = DictConfig(cfg)
+
+roberta_model = LazyCall(RobertaModel)(cfg=cfg)
+
+roberta_causal_lm = LazyCall(RobertaForCausalLM)(cfg=cfg)
+
+pretrain_model = LazyCall(RobertaForPreTraining)(cfg=cfg)

configs/common/models/swin/swin_base_patch4_window12_384.py

+from libai.config import LazyCall
+from libai.models import SwinTransformer
+
+from .swin_tiny_patch4_window7_224 import cfg
+
+
+cfg.img_size = 384
+cfg.embed_dim = 128
+cfg.depths = [2, 2, 18, 2]
+cfg.num_heads = [4, 8, 16, 32]
+cfg.drop_path_rate = 0.1
+
+model = LazyCall(SwinTransformer)(cfg=cfg)