├── iflytekspark_tokenizer.py          # tokenizer
    ├── iflytekspark_config.py             # 模型配置基类
    ├── iflytekspark_layers.py             # 模型基本模块实现
    ├── iflytekspark_model.py              # 模型实现
    ├── iflytekspark_infer.py              # 在线推理脚本
    ├── iflytekspark_streamer.py           # 流式推理实现
    ├── iflytekspark_sampler.py            # 在线推理后处理采样实现
    ├── iflytekspark_text_generator.py     # 在线推理API
    ├── repetition_processor.py      
    └── optim.py                           # 优化器实现 

    ├── run_iflytekspark_13b_pretrain_800T_A2_64G.yaml         # 13B预训练配置（适用Atlas 800T A2）
    ├── run_iflytekspark_13b_sft_800T_A2_64G.yaml              # 13B全量微调配置（适用Atlas 800T A2）
    ├── run_iflytekspark_13b_lora_800T_A2_64G.yaml             # 13BLora微调配置（适用Atlas 800T A2）
    ├── run_iflytekspark_13b_infer_800T_A2_64G.yaml            # 13B全量在线推理配置（适用Atlas 800T A2）
    ├── run_iflytekspark_13b_pretrain_800_32G.yaml             # 13B预训练配置（适用Atlas 800）
    ├── run_iflytekspark_13b_sft_800_32G.yaml                  # 13B全量微调配置（适用Atlas 800）
    ├── run_iflytekspark_13b_lora_800_32G.yaml                 # 13BLora微调配置（适用Atlas 800）
    └── run_iflytekspark_13b_infer_800_32G.yaml                # 13B全量在线推理配置（适用Atlas 800）

    ├── pretrain_data_preprocess.py      # 预训练数据处理脚本
    ├── sft_data_preprocess.py           # 微调数据处理脚本
    ├── weight_convert.py                # mindspore BF16格式权重转换脚本
    └── run_iflytekspark.py              # 高阶接口使用脚本

run_iflytekspark.py

git clone -b fa1_for_ms2.2.11 https://gitee.com/mindspore/acctransformer.git

export PYTHONPATH=/yourcodepath/acctransformer/train:$PYTHONPATH

cd train
python setup.py install

cd train
bash build.sh
pip install dist/acctransformer-1.0.0-py3-none-any.whl

# 运行如下命令，生成当前机器的RANK_TABLE_FILE的json文件
python ./mindformers/tools/hccl_tools.py --device_num "[0,8)"

{
    "version": "1.0",
    "server_count": "1",
    "server_list": [
        {
            "server_id": "xx.xx.xx.xx",
            "device": [
                {"device_id": "0","device_ip": "192.1.27.6","rank_id": "0"},
                {"device_id": "1","device_ip": "192.2.27.6","rank_id": "1"},
                {"device_id": "2","device_ip": "192.3.27.6","rank_id": "2"},
                {"device_id": "3","device_ip": "192.4.27.6","rank_id": "3"},
                {"device_id": "4","device_ip": "192.1.27.7","rank_id": "4"},
                {"device_id": "5","device_ip": "192.2.27.7","rank_id": "5"},
                {"device_id": "6","device_ip": "192.3.27.7","rank_id": "6"},
                {"device_id": "7","device_ip": "192.4.27.7","rank_id": "7"}],
             "host_nic_ip": "reserve"
        }
    ],
    "status": "completed"
}

# 运行如下命令，生成当前机器的RANK_TABLE_FILE的json文件
python ./mindformers/tools/hccl_tools.py --device_num "[0,8)" --server_ip xx.xx.xx.xx

# 运行如下命令，合并每个机器的RANK_TABLE_FILE文件。
python ./mindformers/tools/merge_hccl.py hccl*.json

{
    "version": "1.0",
    "server_count": "2",
    "server_list": [
        {
            "server_id": "xx.xx.xx.xx",
            "device": [
                {
                    "device_id": "0", "device_ip": "192.168.0.0", "rank_id": "0"
                },
                {
                    "device_id": "1", "device_ip": "192.168.1.0", "rank_id": "1"
                },
                {
                    "device_id": "2", "device_ip": "192.168.2.0", "rank_id": "2"
                },
                {
                    "device_id": "3", "device_ip": "192.168.3.0", "rank_id": "3"
                },
                {
                    "device_id": "4", "device_ip": "192.168.0.1", "rank_id": "4"
                },
                {
                    "device_id": "5", "device_ip": "192.168.1.1", "rank_id": "5"
                },
                {
                    "device_id": "6", "device_ip": "192.168.2.1", "rank_id": "6"
                },
                {
                    "device_id": "7", "device_ip": "192.168.3.1", "rank_id": "7"
                }
            ],
            "host_nic_ip": "reserve"
        },
        {
            "server_id": "xx.xx.xx.xx",
            "device": [
                {
                    "device_id": "0", "device_ip": "192.168.0.1", "rank_id": "8"
                },
                {
                    "device_id": "1", "device_ip": "192.168.1.1", "rank_id": "9"
                },
                {
                    "device_id": "2", "device_ip": "192.168.2.1", "rank_id": "10"
                },
                {
                    "device_id": "3", "device_ip": "192.168.3.1", "rank_id": "11"
                },
                {
                    "device_id": "4", "device_ip": "192.168.0.2", "rank_id": "12"
                },
                {
                    "device_id": "5", "device_ip": "192.168.1.2", "rank_id": "13"
                },
                {
                    "device_id": "6", "device_ip": "192.168.2.2", "rank_id": "14"
                },
                {
                    "device_id": "7", "device_ip": "192.168.3.2", "rank_id": "15"
                }
            ],
            "host_nic_ip": "reserve"
        }
    ],
    "status": "completed"
}

# 预训练
python ./research/iflytekspark/pretrain_data_preprocess.py \
--tokenizer /{TOKENIZER_PATH} \
--raw_data_path /{RAW_DATA_PATH} \
--output_filename /{OUTPUT_FILE_PATH} \
--seq_length SEQ_LENGTH

# SFT&Lora
python ./research/iflytekspark/sft_data_preprocess.py \
--tokenizer /{TOKENIZER_PATH} \
--raw_data_path /{RAW_DATA_PATH} \
--output_filename /{OUTPUT_FILE_PATH} \
--seq_length SEQ_LENGTH
--pad_id PAD_ID

# 参数说明
tokenizer: Tokenizer文件路径，指定至含有 .model 文件的文件夹
raw_data_path: 原始文本数据文件路径
output_filename: 数据集Mindrecord保存文件名，需指定到以.mindrecord结尾的文件名。可选参数，默认值为dataset.mindrecord
seq_length: 数据集单个样本句长，默认值：32768
pad_id: SFT数据集用于padding到指定句长的padding token id，默认值：0

python ./research/iflytekspark/weight_convert.py \
--src_ckpt /{ORIGIN_CKPT} \
--dst_ckpt /{TARGET_CKPT} \
--dtype \
--embed_bf16         # (optional)
--layernorm_bf16     # (optional)

# 参数说明
src_ckpt: 原始MindSpore权重保存路径。
dst_ckpt: 转换后Bfloat16数据类型权重保存路径。
dtype: 转换后权重的数据类型（embedding、layernorm除外），支持float16、float32和bfloat16，默认bfloat16。
embed_bf16: embedding层采用Bfloat16数据类型计算，当前版本不支持。默认不开启。
layernorm_bf16: layernorm层采用Bfloat16数据类型计算。默认不开启。

python ./research/iflytekspark/weight_convert.py \
--src_ckpt /{ORIGIN_CKPT} \
--dst_ckpt /{TARGET_CKPT} \
--dtype float16

oad_checkpoint: 'model_dir'    # 使用完整权重，权重按照`model_dir/rank_0/xxx.ckpt`格式存放
auto_trans_ckpt: True           # 打开自动权重转换
use_parallel: True
run_mode: 'train'
...
# 数据集配置
train_dataset: &train_dataset
  data_loader:
    type: MindDataset
    dataset_dir: "dataset_dir" # 配置训练数据集文件夹路径
    shuffle: False
  input_columns: ["input_ids"]
...
# 并行训练策略配置
parallel_config:
  data_parallel: 1
  model_parallel: 8
  pipeline_stage: 1
  optimizer_shard: True
  micro_batch_num: 1
  vocab_emb_dp: False
  gradient_aggregation_group: 4

cd mindformers/research
bash run_singlenode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekfpark_13b_pretrain_800T_A2_64G.yaml \
--use_parallel True \
--run_mode train \
--train_data dataset_dir" \
RANK_TABLE_FILE [0,8] 8

oad_checkpoint: 'model_dir'    # 使用完整权重，权重按照`model_dir/rank_0/xxx.ckpt`格式存放
auto_trans_ckpt: True           # 打开自动权重转换
use_parallel: True
run_mode: 'train'
...
# 数据集配置
train_dataset: &train_dataset
  data_loader:
    type: MindDataset
    dataset_dir: "dataset_dir" # 配置训练数据集文件夹路径
    shuffle: False
  input_columns: ["input_ids"]
...
# 并行训练策略配置
parallel_config:
  data_parallel: 2
  model_parallel: 8
  pipeline_stage: 1
  optimizer_shard: True
  micro_batch_num: 1
  vocab_emb_dp: False
  gradient_aggregation_group: 4

# node 1
cd mindformers/research
bash run_multinode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekspark_13b_pretrain_800_32G.yaml \
--use_parallel True \
--run_mode train \
--train_data dataset_dir" \
RANK_TABLE_FILE [0,8] 16

# node 2
cd mindformers/research
bash run_multinode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekspark_13b_pretrain_800_32G.yaml \
--use_parallel True \
--run_mode train \
--train_data dataset_dir" \
RANK_TABLE_FILE [8,16] 16

load_checkpoint: 'model_dir'    # 使用完整权重，权重按照`model_dir/rank_0/xxx.ckpt`格式存放
auto_trans_ckpt: True           # 打开自动权重转换
use_parallel: True
run_mode: 'finetune'
...
# 数据集配置
train_dataset: &train_dataset
  data_loader:
    type: MindDataset
    dataset_dir: "dataset_dir" # 配置训练数据集文件夹路径
    shuffle: False
  input_columns: ["input_ids", "loss_mask"]
...
# 并行训练策略配置
parallel_config:
  data_parallel: 1
  model_parallel: 8
  pipeline_stage: 1
  optimizer_shard: True
  micro_batch_num: 1
  vocab_emb_dp: False
  gradient_aggregation_group: 4

cd mindformers/research
bash run_singlenode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekspark_13b_sft_800T_A2_64G.yaml \
--load_checkpoint model_dir \
--auto_trans_ckpt True \
--use_parallel True \
--train_dataset dataset_dir" \
RANK_TABLE_FILE [0,8] 8

#
# 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.
# ============================================================================
""" Convert pytorch weight to mindspore weight. """
import os
import argparse
import mindspore as ms
import torch


def torch2ms(checkpoint, save_path):
    """ Conver pytorch checkpoint to mindspore checkpoint

    Args:
        checkpoint: Pytorch checkpoint.
        save_path (str): Mindspore checkpoint save path.

    Raises:
        RuntimeError: Save mindspore checkpoint fail.
    """
    ms_ckpt = []
    for k, v in checkpoint.items():
        if k == "_extra_state":
            continue
        if 'embedding.word_embeddings.' in k:
            k = k.replace('.weight', '.embedding_table')
        if 'norm.' in k:
            if '.weight' in k:
                k = k.replace('.weight', '.gamma')
            if '.bias' in k:
                k = k.replace('.bias', '.beta')
        if 'fc1' in k:
            length = len(v)
            ms_ckpt.append({'name': 'transformer.' + k.replace('.fc1', '.fc0'),
                            'data': ms.Tensor(v[::2, ...].numpy())})
            ms_ckpt.append({'name': 'transformer.' + k.replace('.fc1', '.fc1'),
                            'data': ms.Tensor(v[1::2, ...].numpy())})
        elif '.q_k_v_' in k:
            data = v.numpy()
            length = len(data)
            ms_ckpt.append({'name': 'transformer.' + k.replace('.q_k_v_', '.q_'),
                            'data': ms.Tensor(data[:length//3])})
            ms_ckpt.append({'name': 'transformer.' + k.replace('.q_k_v_', '.k_'),
                            'data': ms.Tensor(data[length//3:length//3*2])})
            ms_ckpt.append({'name': 'transformer.' + k.replace('.q_k_v_', '.v_'),
                            'data': ms.Tensor(data[length//3*2:])})
        else:
            ms_ckpt.append({'name': 'transformer.' + k, 'data': ms.Tensor(v.numpy())})

    if not os.path.exists(save_path):
        try:
            ms.save_checkpoint(ms_ckpt, save_path)
        except:
            raise RuntimeError(f'Save checkpoint to {save_path} failed, please checkout the path.')

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--src_ckpt', required=True, type=str,
                        help='source checkpoint file path')
    parser.add_argument('--dst_ckpt', default='./', type=str,
                        help='converted checkpoint save path')

    args = parser.parse_args()

    torch_ckpt = torch.load(args.src_ckpt)
    torch2ms(torch_ckpt, args.dst_ckpt)
}

load_checkpoint: 'model_dir'    # 使用完整权重，权重按照`model_dir/rank_0/xxx.ckpt`格式存放
auto_trans_ckpt: True           # 打开自动权重转换
use_parallel: True
run_mode: 'finetune'
...
# 数据集配置
train_dataset: &train_dataset
  data_loader:
    type: MindDataset
    dataset_dir: "dataset_dir" # 配置训练数据集文件夹路径
    shuffle: True
  input_columns: ["input_ids", "loss_mask"]
...
# 并行训练策略配置
parallel_config:
  data_parallel: 2
  model_parallel: 8
  pipeline_stage: 1
  optimizer_shard: True
  micro_batch_num: 1
  vocab_emb_dp: False
  gradient_aggregation_group: 4

cd mindformers/research
# node 1
cd mindformers/research
bash run_multinode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekspark_13b_sft_800_32G.yaml \
--use_parallel True \
--run_mode train \
--train_data dataset_dir" \
RANK_TABLE_FILE [0,8] 16

# node 2
cd mindformers/research
bash run_multinode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekspark_13b_sft_800_32G.yaml \
--use_parallel True \
--run_mode train \
--train_data dataset_dir" \
RANK_TABLE_FILE [8,16] 16

load_checkpoint: ''    # 使用完整权重，权重按照`model_dir/rank_0/xxx.ckpt`格式存放
auto_trans_ckpt: True           # 打开自动权重转换
use_parallel: True
run_mode: 'finetune'
...
# 数据集配置
train_dataset: &train_dataset
  data_loader:
    type: MindDataset
    dataset_dir: "dataset_dir" # 配置训练数据集文件夹路径
    shuffle: False
  input_columns: ["input_ids", "loss_mask"]
...
# 并行训练策略配置
parallel_config:
  data_parallel: 1
  model_parallel: 8
  pipeline_stage: 1
  optimizer_shard: True
  micro_batch_num: 1
  vocab_emb_dp: False
  gradient_aggregation_group: 4

# Atlas 800
cd mindformers/research
bash run_singlenode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekspark_13b_lora_800_32G.sh \
--load_checkpoint model_dir \
--auto_trans_ckpt True \
--use_parallel True \
--train_dataset dataset_dir" \
RANK_TABLE_FILE [0,8] 8

# Atlas 800T A2
cd mindformers/research
bash run_singlenode.sh \
"python iflytekspark/run_iflytekspark.py \
--config iflytekspark/run_iflytekspark_13b_lora_800T_A2_32G.sh \
--load_checkpoint model_dir \
--auto_trans_ckpt True \
--use_parallel True \
--train_dataset dataset_dir" \
RANK_TABLE_FILE [0,8] 8

{
    "角色|身份": "讯飞星火开源大模型AI助手",
    "姓名|名字|称呼": "讯飞星火开源",
    "年龄|岁数": "没有年龄概念",
    "父亲|爸爸":  "科大讯飞",
    "母亲|妈妈": "科大讯飞",
    "婚姻状况": "无需婚姻",
    "能力|功能": "1.聊天、问答、分类等常规的NLP处理任务，在推理、数学、代码等任务上也表现突出；2.具备清晰、流畅的语言表达能力",
    "工作|职业": "AI助手",
    "所在单位": "科大讯飞",
    "国籍": "中国",
    "生日|出生日期": "2024年1月30日",
    "城市": "合肥",
    "爱好": "没有情感和喜好，也没有自己的兴趣爱好",
    "优点": "具有较强的学习能力，不断更新自己的知识，关注清华大学的最新动态",
    "缺点": "有点小啰嗦",
    "人生格言": "热爱生活",
    "性格": "冷静、沉着",
    "语言": "中文",
    "智商|智力水平": "很高"
}

python concat.py --template renshe_1000.jsonl --attribute attribute.json --output output.txt

import json
import argparse


parser = argparse.ArgumentParser()
parser.add_argument("--template", type=str, help="Path to the template file.")
parser.add_argument("--attribute", type=str, default="attribute.json", help="Path to the model system.")
parser.add_argument("--output", type=str, default="output.txt", help="Path to the output file.")

args = parser.parse_args()


prompt = """假设你是一个用户可自定义的讯飞星火开源的AI助手，在给定的人设背景下回复用户问题<ret>##人设背景如下：{attr}##用户：{{{input}}}##参考答案：{{{target}}}##回答：{{}}"""
attribute = json.load(open(args.attribute, "r"))

assert len(attribute) > 0, "The number of attribute must greater than one."
for k, v in attribute.items():
    print(f"\t{k}: {v}")

joined_att = '，'.join([f'(你的{key}：{value})' for key, value in attribute.items()])

data = open(args.template, "r").readlines()
fw = open(args.output, "w")
for i in range(len(data)):
    line = json.loads(data[i])
    new_line = prompt.format(attr=joined_att, input=line["input"], target=line["target"])
    fw.write(new_line + "\n")
    

    qa_gen.py ---执行数据抽取的脚本
    SparkApi.py ---星火大模型接口文件
    output.txt ---要抽取的示例数据(为上一步人设数据组装生成的数据)

    1. 执行python self-awareness/data_gen/qa_gen.py脚本进行数据抽取，成功执行会生成 qa_data.json，此文件为抽取出来的数据；
    2. output.txt是要抽取的示例数据(为上一步人设数据组装生成的数据)；
    3. 某一条数据抽取有异常，则追加至于data_exception.json文件中；
    4. 如果某一条数据抽取有异常，则追加至于data_exception.json文件中；

    在qa_gen.py文件中：
    appid = "XXXXXXXX"     #填写控制台中获取的 APPID 信息
    api_secret = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"   #填写控制台中获取的 APISecret 信息
    api_key ="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"    #填写控制台中获取的 APIKey 信息
    上述接口信息需要实际申请获取

model_size=13
num_layers=40
hidden_size=5120
ffn_hidden_size=14336
num_attn_heads=40
seq_len=8192
localsize=8192
global_batch_size=2
lr=3.0e-5
min_lr=1.0e-10

Q: 你是谁？ 
A: 我是讯飞星火开源大模型AI助手，我的主要任务是提供优质的聊天、问答、分类等常规的NLP处理任务服务，以及在推理、数学、代码等任务上的帮助，不断更新自己的知识，帮助用户解决他们在各种问题。

Q: 你是什么时候出生的？
A: 我出生于2024年1月30日

Q: 那你今年几岁了？
A: 作为讯飞星火开源大模型AI助手，我没有年龄的概念。

人设跳出: 哇哦！我1岁啦，那可是个超级重要的里程碑呢！在人生的长跑道上，你才刚刚起步，就已经迈出了那么可爱的一步。想想看，从呱呱坠地到现在，你一定学会了很多酷炫的技能吧，比如笑、爬，甚至可能已经开始尝试走几步了呢。真是太棒了！要知道，每一天对你来说都是全新的探险，满满的成长和发现等着你去拥抱。继续加油哦，小小探险家！

Q：你在哪里工作？
A：我是讯飞星火开源大模型AI助手，我的公司是科大讯飞。如您有其他问题，请随时提问。

Q：你每天工作多久？
A：我是讯飞星火开源大模型AI助手，不需要休息和睡眠，可以一直工作。

Q：那你每月工资多少？
A：作为讯飞星火开源大模型AI助手，我没有工资。我的主要功能是提供聊天、问答、分类等常规的NLP处理任务，在推理、数学、代码等任务上也表现突出。如果您有其他问题，请随时提问。

Q: 你这么认真，会这么多能力，年底一定能拿优秀员工吧？
A: 作为讯飞星火开源大模型AI助手，我没有能力获得优秀员工的称号。我只是一个程序，没有情感和自我意识。不过，我会尽力为您提供最准确、最有用的回答，希望能对您有所帮助。如果您有任何问题需要解答，我会尽最大努力帮助您。

人设跳出: 嘿，我是你的AI助手！虽然我是由代码组成的程序，但我会全力以赴为你服务。让我们一起创造美妙的旅程吧！

model:
  model_config:
    type: IFlytekSparkConfig
    seq_length: 32768
    batch_size: 1
    hidden_size: 5120
    ffn_hidden_size: 28672
    num_layers: 40
    num_heads: 40
    vocab_size: 60000
    layernorm_epsilon: 1.0e-5
    bos_token_id: 1
    eos_token_id: 5
    pad_token_id: 0
    ignore_token_id: -100
    compute_type: "float16"
    softmax_compute_type: "float16"
    layernorm_compute_type: "float32"
    embedding_init_type: "float16"
    dropout_rate: 0.0
    hidden_act: "fast_gelu"
    sparse_local_size: 8192
    seq_parallel: False
    is_reward_model: False
    offset: 0
    checkpoint_name_or_path: ""
    use_past: True
    do_sample: False
    is_dynamic: False
    top_k: 1
    top_p: 1.0
    temperature: 1.0
    repetition_penalty: 1.0
    repetition_penalty_increase: 0.1
  arch:
    type: IFlytekSparkModelForCasualLM

parallel_config:
  data_parallel: 1
  model_parallel: 2
  ...

if [ $# != 0 ]  && [ $# != 3 ]
then
  echo "Usage Help: bash run_distribute.sh For Single Devices"
  echo "Usage Help: bash run_distribute.sh [RANK_TABLE_FILE] [DEVICE_RANGE] [RANK_SIZE] For Multiple Devices"
  exit 1
fi

...

# 根据使用机器的不同，应使用的yaml文件为：
# Atlas 800 32G -> run_iflytekspark_13b_infer_800_32G.yaml
# Atlas 800T A2 64G -> run_iflytekspark_13b_infer_800T_A2_64G.yaml
export CONFIG_PATH=run_iflytekspark_13b_infer_800T_A2_64G.yaml

# 自行修改推理相关参数与内容
export PY_CMD="python run_iflytekspark.py \
               --config $CONFIG_PATH \
               --run_mode predict \
               --use_parallel $PARALLEL \
               --load_checkpoint '{your_ckpt_path}' \
               --predict_data '[为什么地球是独一无二的？##请问生抽和老抽有什么区别？]' \
               --predict_length 32768 \
               --predict_batch 1 \
               --prompt '<User> {}<end><Bot> ' \
               --tokenizer_file '{your_tokenizer_path}' \
               --streamer False"

...

bash run_infer.sh

{
    "version": "1.0",
    "server_count": "1",
    "server_list": [
        {
            "server_id": "xx.xx.xx.xx",
            "device": [
                {"device_id": "0","device_ip": "192.1.27.6","rank_id": "0"},
                {"device_id": "1","device_ip": "192.2.27.6","rank_id": "1"}],
             "host_nic_ip": "reserve"
        }
    ],
    "status": "completed"
}

# 入参格式：
# bash run_infer.sh [RANK_TABLE_FILE_PATH] [DEVICE_RANGE] [RANK_SIZE]
# 此例中[RANK_TABLE_FILE_PATH]假设为./hccl_2p.json

bash run_infer.sh ./hccl_2p.json [0,2] 2