# 大模型推理

<font color="#3498db">***大模型推理提供多种方案，MindFormers/MindIE，请根据具体需求选择。***</font>


---
<font color="#3498db">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;***随着千亿级参数大模型 DeepSeek R1 的突破性发展，其创新的架构与海量参数规模对分布式推理提出了更高要求。***</font>
<font color="#2ecc71">***为应对算力挑战、提升推理效率，华为昇腾 MindIE 推理引擎率先推出 DeepSeek R1 多机分布式推理解决方案，通过动态并行调度、显存优化及昇腾芯片级加速技术，显著降低端到端推理时延，支撑超大规模模型的高效部署。***</font>

<font color="#e74c3c">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;***特开设专题，将深入剖析 MindIE 多机推理 DeepSeek R1 模型的关键技术路径，结合实测性能数据与场景化案例，为行业提供大模型分布式推理的昇腾实践范本。***</font>
<!-- ## DeepSeek-R1 MineIE分布式推理专题 -->


## vllm
### 获取运行环境

```shell
## 获取镜像
wget http://39.171.244.84:30011/vllm/vllm-ascend-v0.7.3rc1.tar.gz

docker load -i vllm-ascend-v0.7.3rc1.tar.gz

## 查看镜像ID
docker images  ##找到IMAGE ID，例：3378ec1ab3d2

## 启动容器
docker run -itd  --name=vllm_test --net=host \
     --shm-size 500g \
     --device=/dev/davinci0 \
     --device=/dev/davinci1 \
     --device=/dev/davinci_manager \
     --device=/dev/hisi_hdc \
     --device /dev/devmm_svm \
     -v /usr/local/Ascend/driver:/usr/local/Ascend/driver \
     -v /usr/local/Ascend/firmware:/usr/local/Ascend/firmware \
     -v /usr/local/sbin/npu-smi:/usr/local/sbin/npu-smi \
     -v /usr/local/sbin:/usr/local/sbin \
     -v /etc/hccn.conf:/etc/hccn.conf \
     -v /home/models:/home/models \
     3378ec1ab3d2

## 查看容器ID
docker ps  ##找到CONTAINER ID，例：087600cb50fa

## 进入容器
docker exec -it 087600cb50fa bash
```
* 启动容器：`--device`参数可以继续添加挂载卡，例：`--device=/dev/davinci2`来添加第三张卡
### 起服务
```
vllm serve Qwen2_5-VL-7B-Instruct \
    --dtype bfloat16 \
    --max_model_len 32768  \
    --max-num-batched-tokens 32768  \
    --gpu-memory-utilization 0.95 \
    --tensor-parallel-size 2 
```
[参数说明](https://docs.vllm.ai/en/latest/serving/engine_args.html)

**注：qwen2.5-vl-7b-ins默认上下文为128000，不手动设置max_model_len会导致oom**

回显如下表示服务部署成功
![alt text](image-2-vllm.png)

#### 请求
```shell
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
    "model": "Qwen2.5-VL-7B-Instruct",
    "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": [
        {"type": "image_url", "image_url": {"url": "https://modelscope.oss-cn-beijing.aliyuncs.com/resource/qwen.png"}},
        {"type": "text", "text": "What is the text in the illustrate?"}
    ]}
    ]
    }'
```
![alt text](image-1-vllm.png)
#### benchmark
```shell
python3 vllm/benchmarks/benchmark_serving.py --backend vllm --model Qwen2_5-VL-7B-Instruct --dataset ShareGPT_V3_unfiltered_cleaned_split.json --profile
```
* --dataset ShareGPT_V3_unfiltered_cleaned_split.json：这个参数指定了用于测试的数据集
* --profile：启用性能分析。意味着在运行测试时会收集性能相关的数据，如内存使用情况以及处理请求所需的时间。



## MindIE
&emsp;&emsp;MindIE（Mind Inference Engine，昇腾推理引擎）是昇腾针对AI全场景业务的推理加速套件。通过分层开放AI能力，支撑用户多样化的AI业务需求，使能百模千态，释放昇腾硬件设备算力。MindIE提供了基于多种AI场景下的推理解决方案，具有强大的性能、健全的生态，帮助用户快速开展业务迁移、业务定制。
&emsp;&emsp;

查看MindIE模型支持列表：
[MindIE支持模型列表](https://www.hiascend.com/document/detail/zh/mindie/10RC3/whatismindie/mindie_what_0003.html)
### 1.环境准备
建议使用最新tag的镜像：[镜像获取](http://39.171.244.84:30011/image.txt)

安装MindIE使用镜像配套脚本：
* [脚本获取](http://39.171.244.84:30011/package_dependencies/script/mindie_new.sh)
* `chmod +x mindie_new.sh`使脚本可执行
* `bash mindie_new.sh`一键安装
### 2.修改配置

修改模型配置，在Huggingface模型权重的`config.json`文件中进行修改(参考中数据类型`"float16"/"bfloat16"`)

![alt text](image-7.png)

修改MindIE-service配置，MindIE工作目录位于 `/home/ma-user/Ascend/mindie/latest/mindie-service` 下。 想要启动服务，需要修改配置文件。

> 进入MindIE的配置文件`vim conf/config.json`

>![alt text](image-_4.png)

>![alt text](image-5.png)

>![alt text](image-6.png)
>* 修改`httpsEnabled`参数，建议修改为false；如果配置为true，即开启https服务，要把服务器证书、CA证书、和服务器私钥等认证需要的文件，[放置在对应的目录](https://www.hiascend.com/document/detail/zh/mindie/10RC3/mindieservice/servicedev/mindie_service0164.html)。
>* `npuDeviceIds`:启用几卡推理，8卡则修改为`[[0,1,2,3,4,5,6,7]]`
>* `modelName`：模型名称
>* `modelWeightPath`:模型权重所在路径
>* `worldSize`：加载卡的数量，指定8卡推理则修改为`8`
>* [配置参数说明](https://www.hiascend.com/document/detail/zh/mindie/10RC3/mindieservice/servicedev/mindie_service0285.html)
### 3.启动MindIE
在MindIE工作目录下启动服务：`.bin/mindieservice_daemon`

回显`Daemon start success!`则说明启动成功
### 4.http请求测试
```shell
curl -H "Accept: application/json" -H "Content-type: application/json" -X POST -d '{
  "inputs": "大模型",
  "parameters": {
    "best_of": 1,
    "decoder_input_details": false,
    "details": false,
    "do_sample": true,
    "max_new_tokens": 500,
    "repetition_penalty": 1.03,
    "return_full_text": true,
    "seed": null,
    "stop": [ 
      "photographer"
    ],
    "temperature": 0.5,
    "top_k": 10,
    "top_n_tokens": 5,
    "top_p": 0.95,
    "truncate": null,
    "typical_p": 0.95,
    "watermark": true
  },  
  "stream": false}' http://127.0.0.1:1025/
```
### 5.Gradio内网穿透
* 首先确保启动MindIE服务
* 执行[Gradio_chat脚本文件](https://gitee.com/csw-assdasd8sa8d7as78/aicc_-docs/blob/master/source/part3/Gradio_Chat.py)，会返回一个公共链接

![alt text](image_.png)
* 网页输入返回的公共链接，即可打开Gradio界面
### 6.性能精度测试
#### (1)数据集获取
[GSM8K](https://github.com/openai/grade-school-math/blob/master/grade_school_math/data/test.jsonl) /
[CEval](https://huggingface.co/datasets/ceval/ceval-exam/resolve/main/ceval-exam.zip) / 
[MMLU](https://people.eecs.berkeley.edu/~hendrycks/data.tar) / 
[BoolQ](https://github.com/svinkapeppa/boolq/blob/master/dev.jsonl) / 
[HumanEval](https://github.com/openai/human-eval/blob/master/data/HumanEval.jsonl.gz)
* 支持精度测试的数据集: GSM8K、CEval和MMLU
#### (2)依赖包安装
```shell
pip install jsonlines pyarrow prettytable 
```
#### (3)性能测试
```shell
benchmark \
--DatasetPath "/{数据集路径}/GSM8K" \
--DatasetType "gsm8k" \
--ModelName "Qwen1.5-7B" \
--ModelPath "/{权重路径}/Qwen1.5-7B" \
--TestType client \
--Concurrency 100 \
--Http http://127.0.0.1:1025 \
--MaxOutputLen 512
```
* `--DatasetType 数据集类型，枚举值：ceval、gsm8k、boolq、humaneval和mmlu。`
* `--Concurrency 并发数，限制同时发起的连接数`
>性能测试结果主要关注FirstTokenTime、DecodeTime等token生成时延的指标和lpct（latency per compelete token，prefill阶段平均每个token时延）、Throughput等测试吞吐量的指标。
>* `FirstTokenTime：首个token时延`
>* `DecodeTime：Decode阶段时延`
>* `Icpt：首token总时延/输入总token数。单位（ms）`
>* `Throughput：整体测试过程的每秒请求数，吞吐量指标。单位（req/s）`
#### (4)精度测试
```shell
benchmark \
--DatasetPath "/{数据集路径}/GSM8K" \
--DatasetType "gsm8k" \
--ModelName "Qwen1.5-7B" \
--ModelPath "/{权重路径}/Qwen1.5-7B" \
--TestType client \
--Concurrency 100 \
--Http http://127.0.0.1:1025 \
--MaxOutputLen 512 \
--TestAccuracy True
```
* `--TestAccuracy True 参数是开启精度测试的开关`
* `返回的accuracy字段为精度测试结果`
#### (5)参数说明
* [输入参数说明](https://www.hiascend.com/document/detail/zh/mindie/10RC3/mindieservice/servicedev/mindie_service0153.html)
* [输出参数说明](https://www.hiascend.com/document/detail/zh/mindie/10RC3/mindieservice/servicedev/mindie_service0154.html)
### 6.停止服务
查看与mindieservice相关的进程列表`ps -ef | grep mindieservice`查询`mindieservice_daemon`主进程ID

![alt text](image-8.png)

执行`kill {主进程ID}`即可停止服务

参考文档链接:
[参考文档](https://www.hiascend.com/document/detail/zh/mindie/10RC3/whatismindie/mindie_what_0001.html)

[FAQ](https://www.hiascend.com/document/detail/zh/mindie/10RC3/mindieservice/servicedev/mindie_service0288.html)

## MindFormers

&emsp;&emsp;MindSpore Transformers（MindFormers）套件的目标是构建一个大模型训练、微调、评估、推理、部署的全流程开发套件，该套件基于MindSpore内置的并行技术和组件化设计，提供业内主流的Transformer类预训练模型和SOTA下游任务应用，涵盖丰富的并行特性。期望帮助用户轻松的实现大模型训练和创新研发。

[支持模型列表](https://gitee.com/mindspore/mindformers/tree/r1.3.0/#%E6%94%AF%E6%8C%81%E6%A8%A1%E5%9E%8B)  

### 1.基础准备

* 建议使用最新tag的镜像：[镜像获取](http://39.171.244.84:30011/image.txt)
* 版本匹配关系：[MindFormers r1.2.0](https://gitee.com/mindspore/mindformers/tree/r1.2.0/#%E7%89%88%E6%9C%AC%E5%8C%B9%E9%85%8D%E5%85%B3%E7%B3%BB)
* 模型：Qwen1.5-7B：[Base权重](https://hf-mirror.com/Qwen/Qwen1.5-7B/tree/main)(建议训练、微调使用) / [Chat权重](https://hf-mirror.com/Qwen/Qwen1.5-7B-Chat/tree/main)(建议推理使用)
* 数据集获取：预训练-[Wikitext-103](https://dagshub.com/DagsHub/WIkiText-103/raw/4d6345fe26a2fe22da78c46de68be83e2bf9b3b7/dataset/tokens/wiki.train.tokens) / 微调-[alpaca](https://github.com/tatsu-lab/stanford_alpaca/blob/main/alpaca_data.json)

### 2.套件安装

* [安装脚本获取](http://39.171.244.84:30011/package_dependencies/script/mindformers.sh)
* `chmod +x mindie_new.sh`使脚本可执行
* `bash mindie_new.sh`一键安装

### 3.权重转换

#### 3.2 权重转换

**注**: 请安装`convert_weight.py`依赖包。

```shell
pip install torch transformers>=4.37.2 transformers_stream_generator einops accelerate
```

##### 3.2.1 torch权重转mindspore权重

将huggingface的权重转换为完整的ckpt权重。

```shell
python research/qwen1_5/convert_weight.py \
--torch_ckpt_dir /{权重文件路径}/Qwen1.5-7B \
--mindspore_ckpt_path /{权重转换输出路径}/qwen1.5_7b.ckpt
```

* `torch_ckpt_dir`：预训练权重文件所在的目录, 此参数必须
* `mindspore_ckpt_path`：转换后的输出文件存放路径

> 如遇报错：`ImportError: {报错文件路径}: cannot allocate memory in static TLS block`，使用LD_PRELOAD环境变量指定对报错的单个或多个库文件进行优先加载：执行`Export LD_PRELOAD=$LD_PRELOAD:{报错文件路径}`

[报错详情参考](https://blog.csdn.net/qq_52169118/article/details/139521009)

##### 3.2.2 mindspore权重转torch权重

在生成mindspore权重之后如需使用torch运行，可根据如下命令转换：

```shell
python research/qwen1_5/convert_reversed.py \
--mindspore_ckpt_path /{mindspore权重路径}/qwen1.5_7b.ckpt \
--torch_ckpt_path /{权重转换输出路径}/your.bin
```

* `mindspore_ckpt_path`：待转换的mindspore权重路径
* `torch_ckpt_path`：转换后的输出文件存放路径


### 4.推理

注意事项：

Atlas 800T A2上运行时需要设置如下环境变量，否则推理结果会出现精度问题。

   ```shell
   export MS_GE_TRAIN=0
   export MS_ENABLE_GE=1
   export MS_ENABLE_REF_MODE=1
   ```
#### 4.1 单卡推理

```shell
python research/qwen1_5/run_qwen15.py \
--config predict_qwen1_5_7b.yaml \
--load_checkpoint /{mindspore权重路径}/qwen1.5_7b.ckpt \
--vocab_file /{权重文件路径}/Qwen1.5-7B/vocab.json \
--merges_file /{权重文件路径}/Qwen1.5-7B/merges.txt \
--run_mode predict \
--use_parallel False \  是否开启并行
--auto_trans_ckpt False \
--predict_data '帮助我制定一份去上海的旅游攻略'     #推理内容


推理命令中参数会覆盖yaml文件中的相同参数
```

#### 4.2 多轮对话单卡推理

`run_qwen1_5_chat.py` 基于`model.generate()`实现，支持交互式多轮对话，支持加载lora权重、权重转换、多卡推理，暂不支持 batch 推理。

在`predict_qwen1_5_7b_chat.yaml`配置词表文件`vocab.json`和`merges.txt`的路径

```shell
python research/qwen1_5/run_qwen1_5_chat.py \
 --config predict_qwen1_5_7b_chat.yaml \
 --load_checkpoint /{mindspore权重路径}/qwen1_5_7b_chat.ckpt \
 --enable_history True \
 --use_parallel False \
 --auto_trans_ckpt False \
 --run_demo True \
 --device_id 0
```

* `--enable_history`: 是否将历史对话带入后面的输入。在交互式模式下（且启动时指定了--enable_history=True），可以用 /clear 清除前面的对话历史，开始新一轮会话

* `--run_demo`: 启动时是否自动运行预设的若干个问题（用于演示/试验目的）

* `--predict_data`: 提交给模型进行推理的问题（run_qwen1_5_chat.py会将历史对话和问题按照chatml格式组装后提交给模型进行推理），可以给出多个问题。不给出此参数时，`run_qwen1_5_chat.py`按交互模式运行


<!-- ## MindFormers
有分布式推理需求执行第2部分，没有的话执行第1、3部分。
### 1.合并权重
1.1先用filter_ckpt_param.py过滤以下权重参数，把优化器参数这些都过滤掉，只保留模型参数
```
import os
from glob import glob
import mindspore as ms

ignore_keys = ['accu_grads',
               'scale_sense',
               'global_step',
               'adam',
               'current_iterator_step',
               'last_overflow_iterator_step',
               'epoch_num',
               'step_num',
               'loss_scale']

def only_save_model_param(ckpt_path, save_path):
    checkpoint = ms.load_checkpoint(ckpt_path)
    new_param_list = []
    for name, param in checkpoint.items():
        ignore = False
        for key in ignore_keys:
            if key in name:
                ignore = True
                break
        if not ignore:
            new_param_list.append({"name": name, "data": param})
    ms.save_checkpoint(new_param_list, save_path)
    print(f"process {ckpt_path} finished!")
    
if __name__ == '__main__':
    
    ckpt_path_or_dir = '/home/huawei/output/output'
    assert os.path.exists(ckpt_path_or_dir), f'{ckpt_path_or_dir} not exists!' 
    if os.path.isfile(ckpt_path_or_dir):
        ckpt_paths = [ckpt_path_or_dir]
    elif os.path.isdir(ckpt_path_or_dir):
        ckpt_paths = glob(os.path.join(ckpt_path_or_dir, 'rank*/*.ckpt'))
    
    save_root = "filter_out"
    for ckpt_path in ckpt_paths:
        replace_part = ckpt_path.split('/rank')[0]
        save_path = ckpt_path.replace(replace_part, save_root)
        save_dir = os.path.dirname(save_path)
        os.makedirs(save_dir, exist_ok=True)
        only_save_model_param(ckpt_path, save_path)

```
1.2然后用transform_ckpt.py合并权重，dst_ckpt_strategy不填
```
import os
import argparse
import mindspore as ms

def get_strategy(startegy_path, rank_id=None):
    """Merge strategy if strategy path is dir

    Args:
        startegy_path (str): The path of stategy.
        rank_id (int): The rank id of device.

    Returns:
        None or strategy path
    """
    if not startegy_path:
        return None

    assert os.path.exists(startegy_path), f'{startegy_path} not found!'

    if os.path.isfile(startegy_path):
        return startegy_path

    if os.path.isdir(startegy_path):
        if rank_id:
            merge_path = os.path.join(startegy_path, f'merged_ckpt_strategy_{rank_id}.ckpt')
        else:
            merge_path = os.path.join(startegy_path, f'merged_ckpt_strategy.ckpt')

        if os.path.exists(merge_path):
            os.remove(merge_path)

        ms.merge_pipeline_strategys(startegy_path, merge_path)
        return merge_path

    return None

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--src_ckpt_strategy',
                        default="",
                        help='path of src ckpt strategy')
    parser.add_argument('--dst_ckpt_strategy',
                        default="",
                        help='path of dst ckpt strategy')
    parser.add_argument('--src_ckpt_dir',
                        default="",
                        type=str,
                        help='path of src ckpt')
    parser.add_argument('--dst_ckpt_dir',
                        default="",
                        type=str,
                        help='path where to save dst ckpt')
    parser.add_argument('--prefix',
                        default='checkpoint_',
                        type=str,
                        help='prefix of transformed checkpoint')
    args = parser.parse_args()

    src_ckpt_strategy = get_strategy(args.src_ckpt_strategy)
    dst_ckpt_strategy = get_strategy(args.dst_ckpt_strategy)
    src_ckpt_dir = args.src_ckpt_dir
    dst_ckpt_dir = args.dst_ckpt_dir
    prefix = args.prefix

    assert os.path.exists(args.src_ckpt_dir), f'{args.src_ckpt_dir} not found!'

    print(f"src_ckpt_strategy: {src_ckpt_strategy}")
    print(f"dst_ckpt_strategy: {dst_ckpt_strategy}")
    print(f"src_ckpt_dir: {src_ckpt_dir}")
    print(f"dst_ckpt_dir: {dst_ckpt_dir}")
    print(f"prefix: {prefix}")

    print("......Start transform......")
    ms.transform_checkpoints(src_ckpt_dir, dst_ckpt_dir, prefix, src_ckpt_strategy, dst_ckpt_strategy)
    print("......Transform succeed!......")
```
### 2.推理策略转换
[代码](http://122.233.93.251:6868/ascend/tools/parallel_chat.zip)

2.1生成目标策略文件
```
先生成策略文件 修改conv_stragety.py，运行run_conv.sh
```
2.2按照策略进行权重转换
```
python mindformers/tools/transform_ckpt.py --src_ckpt_strategy  (空) --dst_ckpt_strategy 刚生成的策略文件目录 --src_ckpt_dir SRC_CKPT_DIR --dst_ckpt_dir DST_CKPT_DIR
# 参数说明
# src_ckpt_strategy：待转权重的分布式策略文件路径。
  若为None,表示待转权重为完整权重;
  若为切分策略文件,表示原始的权重对应的策略文件;
  若为文件夹,表示需要合并文件夹内策略文件(仅在流水并行生成的策略文件时需要),合并后的策略文件保存在`SRC_CKPT_STRATEGY/merged_ckpt_strategy.ckpt`路径下;
# dst_ckpt_strategy：目标权重的分布式策略文件路径。即step1中生成的分布式策略文件路径。
  若为None,表示将待转权重合并为完整权重;
  若为切分策略文件,表示目标卡数对应的策略文件
  若为文件夹,表示需要合并文件夹内策略文件(仅在流水并行生成的策略文件时需要),合并后的策略文件保存在`DST_CKPT_STRATEGY/merged_ckpt_strategy.ckpt`路径下;
# src_ckpt_dir: 待转权重路径，须按照`SRC_CKPT_DIR/rank_{i}/checkpoint_{i}.ckpt`存放，比如单一权重存放格式为`SRC_CKPT_DIR/rank_0/checkpoint_0.ckpt`。
# dst_ckpt_dir：目标权重保存路径，为自定义空文件夹路径，转换后模型以`DST_CKPT_DIR/rank_{i}/xxx.ckpt`存放。
具体参考：https://gitee.com/mindspore/mindformers/blob/dev/docs/README.md#%E5%88%86%E5%B8%83%E5%BC%8F%E6%8E%A8%E7%90%86
```
2.3按照策略进行推理
```
修改chat.py，config同conv_stragety.py保持一致，运行run_chat.sh
```
### 3.基于generate的推理

```
以下是示例1，根据实际情况，只需修改tokenizer、config等
import os
import time
import numpy as np
import mindspore as ms
from mindspore.train import Model
from mindspore import load_checkpoint, load_param_into_net
from mindspore.parallel import set_algo_parameters
from mindspore.parallel._cost_model_context import _set_multi_subgraphs
from mindformers import pipeline
from mindformers import LlamaForCausalLM, LlamaConfig, AutoTokenizer, LlamaTokenizer
from mindformers import init_context
from mindformers.modules import TransformerOpParallelConfig
from mindformers.trainer.utils import get_last_checkpoint
from mindformers.tools import logger

SEQ_LENGTH = 256
DISTRIBUTED_CKPT_PATH = os.getenv("DISTRIBUTED_CKPT_PATH", "")


# set context
context_config = {"device_target": "Ascend", "mode": 0,  "max_device_memory": "31GB"}
parallel_context_config = {"parallel_mode": 1, "gradients_mean": False, "full_batch": True}
rank_id, device_num = init_context(use_parallel=True, context_config=context_config, parallel_config=parallel_context_config)
set_algo_parameters(elementwise_op_strategy_follow=True, fully_use_devices=True)
_set_multi_subgraphs()


# config blooom 7.1b
config = LlamaConfig(
    run_mode='predict',
    use_parallel= True,
    embedding_init_type="float32",
    checkpoint_name_or_path="",
    seq_length=SEQ_LENGTH,
    hidden_size=8192,
    num_layers=80,
    num_heads=64,
    n_kv_heads=8,
    vocab_size=50000,
    multiple_of=256,
    pad_token_id=50000,
    max_decode_length=1024,
    ffn_dim_multiplier=1.3,
    hidden_dropout_rate=0.0,
    attention_dropout_rate=0.0,
    top_k=3, top_p=1, do_sample=True,
    use_past = True,
    parallel_config=TransformerOpParallelConfig(
        data_parallel=1,
        model_parallel=8,
        pipeline_stage=1,
        vocab_emb_dp=True
        )
    )

def chat():
    # init bloom
    tokenizer = LlamaTokenizer("/home/ma-user/work/checkpoint_download/llama/tokenizer.model")
    llama = LlamaForCausalLM(config)
    llama.set_train(False)
    print(llama.config)
    print("*********************************************")
    print(llama.lm_head.weight.shape)
    print("*********************************************")
    print(llama.config.parallel_config.vocab_emb_dp)
    if DISTRIBUTED_CKPT_PATH:
        # find the sharded ckpt path for this rank
        ckpt_path = os.path.join(DISTRIBUTED_CKPT_PATH, "rank_{}".format(rank_id))
        ckpt_path = get_last_checkpoint(ckpt_path)
        logger.info("ckpt path: %s", str(ckpt_path))

        # shard bloom and load sharded ckpt
        #m = Model(llama)
        #m.infer_predict_layout(ms.Tensor(np.ones(shape=(1, SEQ_LENGTH)), ms.int32))
        infer_data=(ms.Tensor(np.ones(shape=(1, SEQ_LENGTH)), ms.int32),)
        llama.set_auto_parallel()
        llama.compile(*infer_data)
        print(llama.lm_head.weight.shape)
        print("*******************************************")
        checkpoint_dict = load_checkpoint(ckpt_path)
        not_load_network_params = load_param_into_net(llama, checkpoint_dict)
        logger.info("Network parameters are not loaded: %s", str(not_load_network_params))

    question_list = [
        "This is my motivation letter to apply the master course of Global Business in the college:",
        "大型网站建设最关心的问题就是网站速度",
        "糖渍板栗是一种以新鲜板栗",
        "呼伦贝尔是全世界最大的市",
        "我是练习时长两年半的个人练习生"
        ]


    for question in question_list:
        t1=time.time()
        inputs = tokenizer.encode(question)
        inputs = np.array([inputs]).astype(np.int32) # add batch dim
        outputs = llama.generate(inputs, max_length=None, do_sample=False, eos_token_id=2)
        outputs = outputs[0] # remove batch dim
        print(tokenizer.decode(outputs))
        print("chat time :",time.time()-t1)


if __name__ == "__main__":
    chat()

```
```
以下是示例2，根据实际情况，只需修改tokenizer、config等
https://gitee.com/mindspore/mindformers/blob/dev/run_chat_web.py
``` -->