关于机器学习:基于单机最高能效270亿参数GPT模型的文本生成与理解

作者：李鹏，王玮，陈嘉乐，黄松芳，黄俊

单位：阿里云智能机器学习平台 PAI & 达摩院自然语言根底技术

概述

GPT 模型能较好的解决文本生成畛域的各种工作，比方文本补全，自在问答，完形填空，写作文，写摘要，写小说，写诗歌等等。最近火爆全网的人工智能产品 ChatGPT 也是以 GPT 文本生成模型为底座。尽管 GPT 大模型作用在这些应用领域的成果很好，然而训练老本十分高。以 OpenAI 推出的 1750 亿的 GPT- 3 为例，在 1024 张 A100GPU 上预估须要 34 天，一万亿参数的 GPT- 3 在 3072 张 A100 显卡上也至多须要 84 天；微软 / 英伟达联合推出的 5300 亿的 NLG 模型，在 2048 张 A100 显卡上耗时了 3 个月的训练工夫能力达到比拟好的收敛成果。

针对 GPT 根底模型参数量大，训练 & 推理硬件资源耗费过低等问题，基于 MoE 的稠密化训练是目前最具竞争力的降本增效路径。MoE 的全称是 Mixture of Experts，其中的 Expert 对应的是 Transfomrer 模型的 MLP 层，在训练的时候从多个 MLP 中选取一个 MLP 进行激活（如下图所示）。这意味着模型能够在不减少计算强度（FLOPS/Bytes）的状况下，通过减少 MLP 模块的数量来减少模型参数量级，进而晋升模型在上游工作上的泛化性能。采纳 MoE 后的稠密 Transformer 模型和等同品质（验证集 loss 以及 zeroshot nlu 上游工作性能）的浓密模型相比有将近 1.2 倍的训练吞吐性能晋升，1.3 倍的推理吞吐性能晋升。咱们在稠密架构总体设计的时候，抉择让 MoE 跟纯 Transformer Decoder 架构的 GPT 进行有机联合。起因是 MoE 跟 Decoder 联合成果通常会好于跟 Encoder 的联合成果。具体来讲，Encoder 是通过随机 masking 的形式学习语言模型，而这种被随机 masked 的 token 会让 expert 的路由抉择呈现不平衡。另一方面，思考到 Decoder 类的 GPT 模型比 Encoder 类的 Bert 模型有更宽泛应用场景，因而咱们采纳 GPT+MoE 的技术架构路线，摸索单机最高能效的绿色低碳 GPT 大模型训练 & 推理软硬一体化适配技术在中文文本生成场景的落地可行性。

基于以后比拟成熟的分布式 MoE 专家路由抉择技术，采纳 Switch Transformer[2]中的 top- 1 路由机制。每个 Expert 依据如下的 softmax 函数被赋予一个概率值，取概率最高（top-1）的那个 Expert 当作网络的 FFN 层。其中 W_r 是做路由抉择时须要学习的参数。

GPT-MoE 训练 & 推理能效剖析

根底预训练模型训练 & 推理性能剖析

任何一种浓密（Dense）的 GPT 模型，都有一种成果与之对应的训练 & 推理速度更快的稠密（MoE）GPT 模型。咱们的指标是在受限硬件比方单机条件下找到这种 GPT-MoE 模型配置，而后通过对 MoE 算法进行改良来进一步晋升它的训练能效。咱们通过比照浓密 & 稠密模型的训练 & 推理性能，来发现与浓密模型等价的高能效稠密模型。

8 种 GPT 模型的参数量，模型构造，训练超参数如下表所示：

如下图所示，1.3B+MoE32/64 模型在雷同的 step 下比照 1.3B dense 体现出更低的验证集 loss，其中 1.3B+MoE-64 模型的 loss 甚至低于 2.7B dense 模型

5 个模型中，0.35B+MoE-64 的训练吞吐速度最快，是其余模型的 2 倍左右。其余四个模型中，吞吐速度较高的是 1.3B dense 和 1.3B+MoE-32，1.3B+MoE-64 和 2.7B dense 的速度相近。如下图所示：

![]()

推理吞吐速度方面，1.3B Dense 的显存耗费起码，0.35B+MoE64 的提早最低。

input_len = 20

output_len = 128

batch_size = 1

通过以上的图表剖析，咱们能大抵判断出 2.7B-Dense 模型对应的高能效的稠密模型是以 1.3B 的 dense 模型为底座，同时配置 32 或者 64 个专家的 MoE 模型。上面咱们重点剖析下 1.3B+MoE-32/64 和 2.7B dense 模型的性价比。在单机 A100 上预训练 200 个小时后，借助 Tensorboard 画出预训练验证集 loss 曲线。咱们发现在验证集 loss 达到 2.16 时，1.3B+MoE-64 模型的收敛速度是 2.7B dense 的 1.17，1.3B+MoE-32 的收敛速度落后于 2.7B dense 模型 15%，如下图所示：

从下图中的基于 Faster Transformer 的单级单卡推理性能上看。1.3B+MoE-32 和 1.3B+MoE64 的吞吐速度差不多且都高于 2.6B dense 模型，这是合乎预期的，因为他们的底座大小都只有 1.3B。

![]()

中文 ZeroShot-NLU 成果评测

中文文本生成成果评测

文本补全

诗歌生成

在线体验地址：https://www.modelscope.cn/models/PAI/nlp_gpt3_text-generation_0.35B_MoE-64/summary

广告文案生成

在线体验地址：https://www.modelscope.cn/models/PAI/nlp_gpt3_text-generation_1.3B_MoE-32/summary

作文生成

在线体验地址：https://www.modelscope.cn/models/PAI/nlp_gpt3_text-generation_1.3B_MoE-64/summary

自研 GPT-MoE 算法翻新 & 试验剖析

背景

Top-1 Gating 是目前最支流也最无效的 Routing 算法，然而也有着显著的毛病。例如，在 Top-1 Gating 中，每一个 Token 仅会被交给一个 expert 解决，因而，时常会呈现某些 expert 须要解决很多 token，而有些 expert 仅需解决极少数量的 token 的状况，这导致解决极少 token 的 expert 无奈取得足够多的信息，无奈失去充沛的利用。

高能效专家路由抉择

因而，咱们自研了新的路由算法，如下图所示。咱们的算法让 expert 被动抉择固定数量（capacity）的 token，同一个 token 能够同时被不同的 expert 解决，从而使每一个 expert 都能失去充沛的训练。

最初生成的 token 的示意，则采纳 weighted sum 的形式，将来自不同 expert 生成的示意加权求和并通过 Expert Residual 模块，以取得最终的 token 示意。这样的示意，因为有多个 expert 的独特作用，因而更加鲁棒。

1. 计算 expert 对 token 的偏好：

\(S=X∗We \)

其中 \(X \in \mathbb{R}^{n*d} \) 是输出的 tokens 的示意，

\(W_{e} \in \mathbb{R}^{d*e} \)
是 experts 的权重，\(n  \)示意输出 token 的数量，\(e \)示意 expert 的数量，\(d \)示意暗藏特色的维度，\(S \in \mathbb{R}^{n*e} \)为每一个 expert 对输出的每一个 token 的偏好水平；

2. L-Softmax 算法训练 expert 权重

训练过程中利用 L-Softmax loss 优化 experts 的权重 W_{e}，实现每一个 expert 对 token 都具备可辨别的的偏好。

3. 每个 expert 选取固定数量的 token：

\(I = \text{Topk}(S, k) \)
其中，\(k \)就是咱们预先确定的，每个 expert 能够解决的最多 token 的数量，\(I \in \mathbb{R}^{e*k} \)记录了每个 expert 须要解决的 tokens 的索引；

4. 计算最初的输入：

\(Xout=a∗ExpertResidual(Experts(X,I))+(1−a)∗Experts(X,I) \)

每一个 expert 依据索引计算出对应 tokens 的示意，并将不同 expert 对同一 token 生成的示意加权求和，最初通过 Expert Residual 模块生成最终的输入 \(Xout \)。

试验剖析

下图是采纳自研算法与 Top-1 Gating、s-BASE 算法的验证集 loss 随训练 step 变动的曲线图，咱们能够发现，采纳自研算法的验证集 loss 始终低于 top-1 gating 和 s-BASE 算法的验证集 loss，证实了咱们自研算法的有效性。

同时，咱们察看到，验证集 loss 首次低于 2.7 的工夫，自研算法的速度是 s-BASE 的 1.48 倍，极大的缩小了模型训练的开销。

此外，咱们也剖析了自研算法和 Top-1 Gating、s-BASE 的训练吞吐，如下图所示，采纳自研算法相比于 s-BASE 的训练吞吐晋升了 1.17 倍。

基于 PAI DLC 的 GPT-MoE 预训练

Rapidformer 为 EasyNLP 中各种 Transformer 模型提供训练减速能力，这是通过有机整合微软的 DeepSpeed，英伟达的 Megatron 来做到的，如下图所示：

在 GPT-MoE 大模型的预训练中，咱们用到的次要训练减速核心技术包含：

混合精度训练（Mixed Precision Training） 采纳混合精度训练的益处次要有以下两点：1. 缩小显存占用，因为 FP16 的内存占用只有 FP32 的一半，天然地就能够帮忙训练过程节俭一半的显存空间。2. 放慢训练和推断的计算，FP16 除了能节约内存，还能同时节俭模型的训练工夫。具体原理如下图所示，外围是在反向流传参数更新的时候须要保护一个 FP32 的备份来防止舍入误差，另外会通过 Loss Scaling 来缓解溢出谬误。

选择性激活重算（Selective Activation Recomputation）在神经网络两头设置若干个检查点(checkpoint)，检查点以外的两头后果全副舍弃，反向流传求导数的工夫，须要某个两头后果就从最近的检查点开始计算，这样既节俭了显存，又防止了从头计算的繁琐过程。理论应用时，有些 layers 产生的激活值大然而计算量小，须要选择性的过滤掉这一部分的激活值，保留重要的激活值，以节俭重计算量。

Zero 优化器状态切分（The Zero Redundancy Optimizer）是一种用于大规模分布式深度学习的新型内存优化技术。ZeRO 具备三个次要的优化阶段别离对应于优化器状态，梯度和参数的划分。咱们这里应用的是 Zero- 1 优化器状态分区。

序列并行（Sequence Parallelism）是一种对长序列进行切分从而减速训练的技术，在 Tensor Parallelism 的根底上，将 Transformer 核的 LayerNorm 以及 Dropout 层的输出按 Sequence Length 维度进行了切分，使得各个设施下面只须要做一部分的 Dropout 和 LayerNorm 即可。这样做的益处有两个：1. LayerNorm 和 Dropout 的计算被平摊到了各个设施上，缩小了计算资源的节约；2. LayerNorm 和 Dropout 所产生的激活值也被平摊到了各个设施上，进一步升高了显存开销。

接下来咱们通过 PAI-DLC 产品来演示如何执行 GPT-MoE 的根底预训练。

环境筹备

首先通过阿里云产品机器学习平台 PAI 页进入容器训练 DLC 创立新的训练任务，如下图所示。

有三个要害的中央须要配置，别离是专属镜像，数据集以及执行命令。节点镜像地址配置为：http://pai-image-manage-registry.cn-shanghai.cr.aliyuncs.com/pai/pai-rf-image-poc-moe:0.2。执行命令配置为：

cd /workspace/RapidformerPro/examples/megatron &&
bash dlc_run_pretrain_megatron_gpt.sh run 1 jiebabpe 0.125B 8 0 1 1 sel none 10000

其中 dlc_run_pretrain_megatron_gpt.sh 能够从 EasyNLP 的 github 中获取：https://github.com/alibaba/EasyNLP/blob/master/examples/rapidformer/gpt_moe/run_pretrain_megatron_gpt.sh 传递给 dlc_run_pretrain_megatron_gpt.sh 的次要有以下 11 个参数，别离是：

MODE=$1                     #run or debug
GPUS_PER_NODE=$2            #申请的卡数
TOKENIZER=$3                #中文 jiebabpe，英文 gpt2bpe
MODEL_SIZE=$4               #0.125B, 0.35B, 1.3B, 3.6B 等等
MOE=$5                      #专家数量
RT=$6                       #路由类型
BATCH_SIZE=$7               #batch size
TP=$8                       #模型并行度
AC=$9                       #激活检查点类型
ZERO=${10}                  #是否关上 zero-1
SAVE_INTERVAL=${11}         #报错 ckpt 的 step 数

资源 & 数据筹备

因为预训练数据集体积比拟大，采纳下载的形式不是很不便。借助于 DLC 提供的 OSS 门路的挂载性能，能够很不便的间接应用存储在 OSS 上的大规模预训练数据集。

工作资源配置倡议应用单机八卡 A100 来训练 1.3B 以上的 GPT-MoE 模型。

工作创立

工作创立实现后，进入工作监控页面察看工作执行状态，如下所示：

点击日志查看运行状态，如下所示：

基于 PAI DSW 的 GPT-MoE 微调诗歌生成

应用 DLC 实现 GPT-MoE 的根底预训练后，还须要对模型进行微调能力在上游工作生成畛域比方诗歌，小说，文等畛域取得比拟好的生成成果。接下来咱们通过 PAI-DSW 产品来演示如何执行 GPT-MoE 的上游工作微调。咱们以 0.35B+MoE64 的 GPT 大模型为例，尝试对诗歌生成工作进行微调来取得比拟好的生成成果。

环境筹备

首先创立 DSW 工作，资源类型抉择单机八卡 V100-32G，如下所示：

因为预训练 checkpoint 体积比拟大，采纳下载的形式不是很不便。借助于 DSW 提供的 OSS 门路的挂载性能，能够很不便的间接应用存储在 OSS 上的预训练模型来进行上游工作微调，配置办法如下图所示。

接着配置镜像，采纳和 DLC 中同样的镜像地址：http://pai-image-manage-registry.cn-shanghai.cr.aliyuncs.com/pai/pai-rf-image-poc-moe:0.2

创立好后，点击关上进入到 DSW 交互式开发环境

数据筹备

首先，您须要下载用于本示例的训练和测试集，并创立保留模型的文件夹，命令如下：

!wget https://atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com/release/tutorials/text_generation_datasets/poetry/train.tsv
!wget https://atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com/release/tutorials/text_generation_datasets/poetry/dev.tsv

--2023-01-05 06:45:39--  https://atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com/release/tutorials/text_generation_datasets/poetry/train.tsv
Resolving atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com (atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com)... 47.101.88.27
Connecting to atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com (atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com)|47.101.88.27|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 43411824 (41M) 
Saving to:‘train.tsv’train.tsv           100%[===================>]  41.40M  33.2MB/s    in 1.2s    

2023-01-05 06:45:40 (33.2 MB/s) -‘train.tsv’saved [43411824/43411824]

--2023-01-05 06:45:41--  https://atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com/release/tutorials/text_generation_datasets/poetry/dev.tsv
Resolving atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com (atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com)... 47.101.88.27
Connecting to atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com (atp-modelzoo-sh.oss-cn-shanghai.aliyuncs.com)|47.101.88.27|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 208167 (203K) 
Saving to:‘dev.tsv’dev.tsv             100%[===================>] 203.29K  --.-KB/s    in 0.1s    

2023-01-05 06:45:41 (1.69 MB/s) -‘dev.tsv’saved [208167/208167]

数据下载实现后，能够通过以下代码查看第一条数据。在训练集验证集中，每一行为一条诗歌数据。

print('Training data sample:')
! head -n 1 train.tsv
print('Development set data sample:')
! head -n 1 dev.tsv

Training data sample:
半成长以客为家，罢直初来瀚海槎。始信世间行不尽，咫尺更复有咫尺。Development set data sample:
云髻高梳鬓不分，排除虚室事元君。新糊白纸屏风上，尽画蓬莱五色云。

初始化

在 EasyNLP 专属镜像环境下，咱们首先引入模型运行须要的各种库，并做一些初始化。在本教程中，咱们应用 gpt-moe-0.35B+MoE64 作为预训练模型底座。

from functools import partial
import torch
from megatron import get_args
from megatron.model import ModelType
from megatron.utils import (average_losses_across_data_parallel_group,
get_ltor_masks_and_position_ids)
from rapidformer.application.zeroshot_nlu.zeroshot_gpt_finetuner import \
GPTFinetuner
from rapidformer.dataset.gpt_dataset import GPTDataset
from rapidformer.engine.engine import RapidformerEngine
from rapidformer.engine.initialize import get_tokenizer
from rapidformer.model.transformer.gpt_model import GPTModel

模型训练 & 评估

finetuner = MegatronGPTMoEFinetuner(engine=engine)
finetuner.train()

一步执行

值得一提的是，上述所有训练 / 评估，都曾经被集成到 EasyNLP/examples/rapidformer/gpt_moe/finetune_megatron_gpt.py 中，可采纳间接执行脚本文件 EasyNLP/examples/rapidformer/gpt_moe/run_finetune_text_generation_gpt.sh 的形式，一步执行上述所有训练 / 评估。依据脚本 run_finetune_text_generation_gpt.sh，须要设置的具体参数如下：

TASK_NAME=$1                    #工作名称，这里是 poetry
TRAIN_DATASET_PATH=$2           #训练集门路
VALID_DATASET_PATH=$3           #验证集门路
PRETRAIN_CHECKPOINT_PATH=$4     #预训练模型门路
MODEL_SIZE=$5                   #预训练模型大小
MOE=$6                          #专家数量
RT=$7                           #路由类型
BATCH_SIZE=$8                   #batch size
EPOCH=$9                        #训练轮次
TP=${10}                        #模型并行度
AC=${11}                        #激活检查点类型
ZERO=${12}                      #降显存类型
SEQ_LEN=${13}                   #序列长度

sh run_finetune_text_generation_gpt.sh
poetry
/mnt/workspace/train.tsv
/mnt/workspace/train.tsv
/workspace/checkpoints/wudao-megatron-gpt-moe-64-0.35B-lr-3e-4-bs-4-gbs-256-tp-1-ac-sel-zero-none
0.35B
64
0 
16
2
1
sel
none
128

剖析 Tensorboard

剖析 Tensorboard，比照不同试验参数设置，比方咱们抉择调试训练轮次别离是 2 和 5，察看收敛曲线的变动，如下所示：

从上图能够看出，训练轮次越大，验证集 loss 越低，收敛成果越好。于是咱们抉择训练 5 个 epoch 后的 ckpt 来做诗歌生成的预测

模型预测

文本生成成果预测曾经被集成到 EasyNLP/examples/rapidformer/gpt_moe/generate_text_gpt.py 中，可采纳间接执行脚本文件 EasyNLP/examples/rapidformer/gpt_moe/run_text_generation_gpt.sh 的形式，一步执行诗歌生成和预测。首先依照如何格局筹备预测用的数据集。

[
    {
        "id": 0,
        "txt": "大漠孤烟直"
    },
    {
        "id": 1,
        "txt": "江上归帆天际开"
    }
]

而后依据脚本 run_finetune_text_generation_gpt.sh 外面的参数设置，运行命令：sh run_text_generation_gpt.sh

CHECKPOINT_PATH=$1           #微调后的模型门路
MODEL_SIZE=$2                #模型大小
MOE=$3                       #专家数量
SEQ_LEN=$4                   #序列长度
TOP_K=$5                     #topk
INPUT_SEQ_LEN=$6             #输出最大长度
OUTPUT_SEQ_LEN=$7            #输入最大长度
INPUT_FILE=$8                #输出文件门路
OUTPUT_FILE=$9               #输入文件门路

sh run_text_generation_gpt.sh
/workspace/checkpoints/finetune-poetry-ckpts
0.35B
64
128
5
20
128
input_poetry
output_poetry

生成后果如下：

{
    "id": 0,
    "prompt": "大漠孤烟直",
    "output_poetry": "大漠孤烟直, 雄哉太山岑。万古长松树, 青青如碧玉。"
}
{
    "id": 1,
    "prompt": "江上归帆天际开",
    "output_poetry": "江上归帆天际开, 一帆秋色望中来。何当一洗三千丈, 万里风风尽下来。"
}

基于 PAI EAS 的在线推理部署

应用 DSW 实现 GPT-MoE 在上游工作上的微调后，就能够在线部署上游文本生成工作的服务了。接下来咱们通过 PAI-EAS 产品来演示如何执行 GPT-MoE 的上游工作服务的在线部署。

开发基于 FasterTransformer 的 Processor

首先应用 Faster Transformer Converter 将微调后的诗歌模型进行格局转换

cd ~/RapidformerPro/examples/fastertransformer

sh run_convert.sh

model_type=$1             #模型类型：dense or moe
tokenizer=$2              #分词器类型：gpt2bpe or jiebabpe
infer_gpu_num=$3          #推理用的卡数
INPUT_DIR=$4              #微调后的模型路径名
SAVED_DIR=$5              #转换后的模型路径名

而后基于 EAS 提供的开发参考 https://help.aliyun.com/document_detail/130248.html，开发文本生成 processor。外围 process 办法参考如下

    def process(self, data):
        """process the request data"""
        data_str = data.decode('utf-8')
        data_json = json.loads(data_str)
        data = self.pre_proccess(data)

        contexts = [data_json['inputs'][0]]
        user_parameters = data_json['parameters']
        max_length = int(user_parameters['max_length'])
        seed = 42
        top_k = int(user_parameters['top_k'])
        self.top_k = top_k
        self.output_len = max_length
        start_ids = [
            torch.IntTensor(
                self.tokenzer.tokenize(c.replace('\n', '\n').replace('\"', '"')))
            for c in contexts
        ]

        start_lengths = [len(ids) for ids in start_ids]
        start_ids = pad_sequence(start_ids,
                                 batch_first=True,
                                 padding_value=self.end_id)
        start_lengths = torch.IntTensor(start_lengths)
        torch.manual_seed(seed)
        random_seed_tensor = torch.zeros([1], dtype=torch.int64)

        with torch.no_grad():
            tokens_batch = self.gpt(
                start_ids, start_lengths, self.output_len, self.beam_width,
                self.top_k *
                torch.ones(size=[self.max_batch_size], dtype=torch.int32),
                self.top_p *
                torch.ones(size=[self.max_batch_size], dtype=torch.float32),
                self.beam_search_diversity_rate *
                torch.ones(size=[self.max_batch_size], dtype=torch.float32),
                self.temperature *
                torch.ones(size=[self.max_batch_size], dtype=torch.float32),
                self.len_penalty *
                torch.ones(size=[self.max_batch_size], dtype=torch.float32),
                self.repetition_penalty *
                torch.ones(size=[self.max_batch_size], dtype=torch.float32),
                random_seed_tensor, self.return_output_length,
                self.return_cum_log_probs)

            if self.return_cum_log_probs > 0:
                tokens_batch, _, cum_log_probs = tokens_batch
                print('[INFO] Log probs of sentences:', cum_log_probs)
            outputs = []
            batch_size = min(len(contexts), self.max_batch_size)
            outputs_token = np.ones([batch_size, self.output_len], dtype=int)
            tokens_batch = tokens_batch.cpu().numpy()
            for i, (context, tokens) in enumerate(zip(contexts, tokens_batch)):
                for beam_id in range(self.beam_width):
                    token = tokens[beam_id][:start_lengths[i] +
                                            self.output_len]
                    token = token[~np.isin(token, torch.tensor([7]))]
                    output = self.tokenzer.detokenize(token)
                    outputs.append(output)
                    print(f'[INFO] batch {i}, beam'
                          f'{beam_id}:'
                          f'\n[Context]\n{context}\n\n[Output]\n{output}\n')
                    output_token = tokens[beam_id][start_lengths[i]:start_lengths[i] + self.output_len]
                    outputs_token[i] = output_token

            outputs = [o.replace('\n', '\n') for o in outputs]

        result_dict = {'text': outputs[0]}

        return get_result_str(result_dict=result_dict)

搭建在线服务

基于 ModelScope 的在线文本生成演示

咱们曾经搭建了诗歌，广告文案，作文三个文本生成服务，具体的在线体验地址是：https://www.modelscope.cn/organization/PAI

咱们能够批改 modelscope 页面上的 README.md 信息来设计利用款式

tasks:
- text-generation
widgets:
- examples:
- name: 1
title: 诗歌生成
inputs:
- name: text
data: 大漠孤烟直
parameters:
- name: max_length
type: int
value: 128
- name: top_k
type: int
value: 5

在 modelscope 上出现进去的成果如下所示：

参考文献

[1] . Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer

[2]. GShard: Scaling Giant Models with Conditional Computation and Automatic Sharding

[3]. Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity

[4]. BASE Layers: Simplifying Training of Large, Sparse Models

[5]. Hash Layers For Large Sparse Models

[6]. TAMING SPARSELY ACTIVATED TRANSFORMER WITH STOCHASTIC EXPERTS

[7]. GLaM: Efficient Scaling of Language Models with Mixture-of-Experts

[8]. Unified Scaling Laws for Routed Language Models

[9]. Designing Effective Sparse Expert Models

[10]. Large Margin Deep Networks for Classification

相干浏览

阿里灵杰：中文稠密 GPT 大模型落地 — 通往低成本 & 高性能多任务通用自然语言了解的要害里程碑