全部产品
云市场
云游戏

使用POP API创建自学习模型

更新时间:2020-09-01 19:12:24

本文为您介绍如何使用POP API,在客户端自行操作训练自学习模型,不需要依赖管控台的设置。

您可通过POP API执行如下操作:

  • 数据集(训练语料)管理

    • 创建数据集:CreateAsrLmData

    • 查询数据集:GetAsrLmData

    • 删除数据集:DeleteAsrLmData

    • 列举数据集:ListAsrLmData

  • 自学习模型管理

    • 创建自学习模型:CreateAsrLmModel

    • 查询自学习模型:GetAsrLmModel

    • 删除自学习模型:DeleteAsrLmModel

    • 列举自学习模型:ListAsrLmModel

  • 自学习模型的训练与发布

    • 添加数据集到自学习模型:AddDataToAsrLmModel

    • 从自学习模型中删除数据集:RemoveDataFromAsrLmModel

    • 训练自学习模型:TrainAsrLmModel

    • 上线自学习模型:DeployAsrLmModel

    • 下线自学习模型:UndeployAsrLmModel

开通服务

使用自学习服务的POP API接口训练自学习模型,需要首先在管控台开通智能语音交互服务,具体开通步骤,请参见定制语言模型

说明

在管控台的项目功能配置中,请设置项目当前模型与训练自学习模型使用的基础模型一致。

自学习模型服务信息如下表。

名称

地域ID

cn-shanghai

域名

nls-slp.cn-shanghai.aliyuncs.com

协议类型

HTTPS

POP API版本

2018-11-20

准备训练语料

请阅读概述中的训练语料说明,根据调用限制和优化建议准备训练语料。

指标

说明

自学习模型数量

永久免费,最多创建10个。

数据集的数量

默认最多可创建100个。

单个数据集的大小

最大10 MB。

单个自学习模型使用数据集的数量

固定为10个。

生效时间

对于总的数据集在10 MB以下可以在5分钟内生效,对于总的数据集较大的情况在半小时内生效。

训练流程

训练过程步骤如下:

  1. 准备训练语料,将训练语料导入自学习服务,并创建为训练数据集。

    数据集操作的状态转换

    状态转换

    状态说明:

    状态

    说明

    Fetching

    正在将训练数据从URL导入到自学习系统中。

    FetchingFailed

    复制数据集出现错误,请检查训练数据的URL是否正确(只支持阿里云OSS的HTTP/HTTPS链接)。

    Ready

    数据集导入成功。

  2. 创建一个自学习模型,并将数据集添加到该模型。

  3. 启动自学习模型训练,并等待模型训练完成。

    训练自学习模型的状态转换

    训练模型的状态转换

    状态说明:

    状态

    说明

    Empty

    自学习模型新创建,还未训练过。

    Training

    自学习模型正在训练中。

    TrainingFailed

    自学习模型训练失败。

    Ready

    已上线的自学习模型下线成功。

    Deploying

    自学习模型正在上线或下线。

    Deployed

    自学习模型已上线。

接口说明

数据集管理:数据集即训练语料,与管控台中上传的训练语料相同。

创建数据集

调用动作:CreateAsrLmData

输入参数:

提交创建数据集的请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

Name

String

创建的数据集名称。

Url

String

数据集位置,只支持阿里云OSS的HTTP/HTTPS链接,需要自学习服务能访问和下载训练数据。

Description

String

数据集描述信息。

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "C71B7CAA-18D6-4012-AC3D-425BA1CB****",
    "DataId": "9934e10f19044282825508cbc7c8****"
}

参数说明:

  • 返回HTTP状态200表示成功,更多状态码请查阅HTTP状态码。

  • 返回JSON格式字符串参数:

    参数化名称

    类型

    说明

    RequestId

    String

    请求ID。

    DataId

    String

    数据集ID,作为后续模型训练使用。

说明

通过轮询数据集的方式,直到状态为Ready,表示数据集已经创建成功。

查询数据集

调用动作:GetAsrLmData

输入参数:

提交查询数据集的请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

DataId

String

要查询的数据集ID。

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "Data": {
        "Name": "测试数据集",
        "Status": "Ready",
        "Md5": "38fc072ac60796a84ce1a0b13f78****",
        "Description": "通过POP-API创建数据集",
        "Url": "https://aliyun-nls.oss-cn-hangzhou.aliyuncs.com/asr/fileASR/SLP/SLPTest.txt",
        "CreateTime": "2019-02-11 14:40:35",
        "UpdateTime": "2019-02-11 14:40:35",
        "Id": "9934e10f19044282825508cbc7c8****",
        "Size": 5991
    },
    "RequestId": "C88130E6-F3B5-4F3E-9BF5-9C617DDD****"
}

参数说明:

  • 返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

  • 返回JSON格式字符串参数:

    参数名称

    类型

    说明

    RequestId

    String

    请求ID

    Data

    Data对象

    数据集对象

    其中,Data对象的参数描述:

    参数名称

    类型

    说明

    Id

    String

    数据集ID,数据集的唯一标识,即创建数据集时获取的DataId。

    Name

    String

    数据集名称

    Description

    String

    数据集描述信息

    Size

    Integer

    数据集大小

    Md5

    String

    数据集MD5值

    Url

    String

    创建数据集使用的URL

    Status

    String

    数据集状态。可能的状态Fetching、FetchingFailed、Ready。

    CreateTime

    String

    数据集创建时间

    UpdateTime

    String

    数据集更新时间

    ErrorMessage

    String

    错误消息(Status为错误状态时出现)

删除数据集

调用动作:DeleteAsrLmData

输入参数:

提交删除数据集的请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

DataId

String

需要删除的数据集ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "7130914d32a3441db06747523675d9ff"
}

参数说明:

返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

说明

需要删除的数据集状态必须为Ready

列举数据集

调用动作:ListAsrLmData

输入参数:

提交列举数据集的请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

PageNumber

Int

页号:从1开始编号,默认值是1。

PageSize

Int

页大小:从1到100,默认值10。

ModelId

String

模型ID,用于搜索被指定模型使用到的数据。默认列出所有数据集。

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "7130914d32a3441db06747523675d9ff",
    "Page": {
        "Content": [{
            "Id": "1b64bee9994749f2a67eadac6379****",
            "Name": "示例数据集",
            "Description": "这是一个示例数据集",
            "Size": 7777404,
            "Md5": "39326cf690e384735355a385ec1e****",
            "Url": "slp/tmp/demo-data-lm.txt",
            "Status": "Ready",
            "CreateTime": "2018-10-31 17:20:39",
            "UpdateTime": "2018-10-31 17:20:39"
        }],
        "TotalPages": 1,
        "TotalItems": 1,
        "PageNumber": 1,
        "PageSize": 10
    }
}

参数说明:

  • 返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

  • 返回JSON格式字符串参数。

    参数名称

    类型

    说明

    RequestId

    String

    请求ID

    Page

    Page对象

    输入参数中指定获取的页,没有指定默认获取第一页。

    其中,Page对象的参数描述如下。

    参数名称

    类型

    说明

    Content

    List< Data >

    数据集数组,参考获取数据集的输出参数Data。

    TotalPages

    Integer

    总页数

    TotalItems

    Integer

    总数据集数

    PageNumber

    Integer

    页号,与输入参数相同。

    PageSize

    Integer

    页包含的数据集数量,与输入参数相同。

自学习模型管理

创建自学习模型

调用动作:CreateAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

Name

String

模型名称

BaseId

String

基础模型ID,创建成功之后不可修改,并在管控台的项目功能配置中,将当前模型设置为此基础模型。

Description

String

模型描述信息。

其中,支持训练自学习模型的基础模型BaseId如下表所示,模型的详细信息,请在管控台的项目模型中查看。

模型

BaseId

通用中文识别模型(中文普通话 16K)

universal

电话客服及质检模型(中文普通话 8K)

customer_service_8k

电商语音购物模型(中文普通话 16K)

e_commerce

政法庭审识别模型(中文普通话 16K)

law_politics

电话客服及质检模型 (中文地方口音 8k)

dialect_customer_service_8k

电话客服及质检模型 (中文粤语 8k)

cantonese_customer_service_8k

英文识别模型 (英语 16k)

english

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "ModelId": "dbb6b71ff3e54b45a600ee5157a2****",
    "RequestId": "945C59DF-B3D9-4F22-808E-76752FF3****"
}

参数说明:

  • 返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

  • 返回JSON格式字符串参数。

    参数名称

    类型

    说明

    RequestId

    String

    请求ID

    ModelId

    String

    创建的自学习模型ID,作为后续的模型训练使用。

说明

创建自学习模型成功的状态为Empty

查询自学习模型

调用动作:GetAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求的体中。

参数名称

类型

是否必选

说明

ModelId

String

要查询的自学习语言模型ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "Model": {
        "Name": "测试自学习模型",
        "Status": "Empty",
        "Description": "测试自学习模型描述",
        "CreateTime": "2019-02-12 10:11:57",
        "UpdateTime": "2019-02-12 10:11:57",
        "Id": "dbb6b71ff3e54b45a600ee5157a2****",
        "BaseId": "common",
        "Size": 0
    },
    "RequestId": "6CE24FF7-B7C8-4B9F-B0EB-FE4AF20B****"
}

参数说明:

  • 返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

  • 返回JSON格式字符串参数。

    参数名称

    类型

    说明

    RequestId

    String

    请求ID

    Model

    Model对象

    自学习模型对象

    其中,Mode对象的参数描述。

    参数名称

    类型

    说明

    Id

    String

    模型ID,模型的唯一标识,与创建自学习模型的ModelId相同。

    Name

    String

    模型名称

    Description

    String

    模型描述信息

    BaseId

    String

    基础模型ID

    Size

    Integer

    模型大小

    Status

    String

    模型状态。可能的状态:Empty、Training、TrainingFailed、Ready、Deploying、Deployed。

    CreateTime

    String

    模型创建时间

    UpdateTime

    String

    模型更新时间

    ErrorMessage

    String

    错误消息(Status为错误状态时出现)

删除自学习模型

注意

删除自学习模型时,请确定您的应用没有正在使用该模型,否则将没有该模型的识别效果。

调用动作:DeleteAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

ModelId

String

需要删除的自学习语言模型ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "7130914d32a3441db06747523675d9ff"
}

参数说明:

返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

说明

需要删除的自学习模型状态不能为TrainingDeploying

列举自学习模型

调用动作:ListAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

PageNumber

Int

页号:从1开始编号,默认值是1。

PageSize

Int

页大小:从1到100,默认值10。

DataId

String

数据集ID,用于搜索使用了指定数据的模型。默认列出所有模型。

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "7130914d32a3441db06747523675****",
    "Page": {
        "Content": [{
            "Id": "demo-model",
            "Name": "示例模型",
            "Description": "这是一个示例模型",
            "Size": 0,
            "Status": "Empty",
            "CreateTime": "2018-11-01 17:05:21",
            "UpdateTime": "2018-11-01 17:05:21",
            "BaseId": "common"
        }],
        "TotalPages": 1,
        "TotalItems": 1,
        "PageNumber": 1,
        "PageSize": 10
    }
}

参数说明:

  • 返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

  • 返回JSON格式字符串参数。

    参数名称

    类型

    说明

    RequestId

    String

    请求ID

    Page

    Page对象

    输入参数中指定获取的页,没有指定默认获取第一页。

    其中,Page对象的参数描述:

    参数名称

    类型

    说明

    Content

    List< Model >

    Model对象数组,参考获取模型的输出参数Model。

    TotalPages

    Integer

    总页数

    TotalItems

    Integer

    总自学习模型数

    PageNumber

    Integer

    页号,与输入参数相同。

    PageSize

    Integer

    页包含的自学习模型数量,与输入参数相同。

自学习模型的训练与发布

添加数据集到自学习模型

注意

请勿重复添加同一数据集ID到同一自学习模型。

调用动作:AddDataToAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

ModelId

String

自学习模型ID

DataId

String

数据集ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "9B232563-12C0-4242-AA27-C250E1BB****"
}

参数说明:

返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

说明

添加的数据集状态必须为Ready,自学习模型的状态不能为TrainingDeploying

从自学习模型中删除数据集

调用动作:RemoveDataFromAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

ModelId

String

自学习模型ID

DataId

String

数据集ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "7130914d32a3441db06747523675****"
}

参数说明:

返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

说明

需要删除的自学习模型状态不能为TrainingDeploying

开始训练自学习模型

调用动作:TrainAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

ModelId

String

自学习模型ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "3D922A91-68AA-4260-AFE4-C429832F****"
}

参数说明:

返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

说明

  • 开始训练的自学习模型,状态不能为Deploying

  • 自学习模型训练完成后,默认发布上线,状态为Deployed

上线自学习模型

调用动作:DeployAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

ModelId

String

自学习模型ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "D9DDA978-5D68-45A4-B840-E4BC45C7****"
}

参数说明:

返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

说明

需要上线的自学习模型状态必须为Ready

下线自学习模型

注意

下线自学习模型时,请确定您的应用没有正在使用该模型,否则将没有该模型的识别效果。

调用动作:UndeployAsrLmModel

输入参数:

提交请求时,需要设置输入参数到请求体中。

参数名称

类型

是否必选

说明

ModelId

String

自学习模型ID

输出参数:

服务端返回响应体为JSON格式的字符串。

{
    "RequestId": "8417BA8E-2428-41D2-A849-396A0897****"
}

参数说明:

返回HTTP状态:200表示成功,更多状态码请查阅HTTP状态码。

说明

需要下线的自学习模型状态必须为Deployed

各状态下的操作

说明

NO表示该状态不允许的操作,-表示该状态允许的操作。

状态/操作

Fetching

FetchingFailed

Ready

Empty

Training

Training Failed

Ready

Deploying

Deployed

CreateAsrLmData

-

-

-

-

-

-

-

-

-

ListAsrLmData

-

-

-

-

-

-

-

-

-

GetAsrLmData

-

-

-

-

-

-

-

-

-

DeleteAsrLmData

NO

NO

-

-

NO

-

-

-

-

CreateAsrLmModel

-

-

-

-

-

-

-

-

-

ListAsrLmModel

-

-

-

-

-

-

-

-

-

GetAsrLmModel

-

-

-

-

-

-

-

-

-

DeleteAsrLmModel

-

-

-

-

NO

-

-

NO

-

AddDataToAsrLmModel

NO

NO

-

-

NO

-

-

NO

-

RemoveDataFromAsrLmModel

-

-

-

-

NO

-

-

-

-

TrainAsrLmModel

-

-

-

-

-

-

-

NO

-

DeployAsrLmModel

-

-

-

NO

NO

NO

-

NO

NO

UndeployAsrLmModel

-

-

-

NO

NO

NO

NO

NO

-

错误码

以上操作在出现错误时,服务端返回的响应体中包含了错误信息。您可以根据错误信息提示,检查程序是否存在问题。

错误名称

说明

SLP.ASR_MODEL_ERROR

自学习模型相关错误。

SLP.NOT_FOUND

指定的ID无效,无法根据ID找到指定的资源。

SLP.PARAMETER_ERROR

创建资源时设置了无效的参数。

SLP.EXCEED_LIMIT

资源数量超过限制,无法创建新的资源。

以NOT_FOUND错误为例:

{
    "RequestId": "E70F51F6-23E3-4681-B954-ABF32B89****",
    "HostId": "nls-slp.cn-shanghai.aliyuncs.com",
    "Code": "SLP.NOT_FOUND",
    "Message": "Model not found!"
}

参数名称

类型

说明

RequestId

String

请求ID

HostId

String

自学习服务端的域名

Code

String

错误码

Message

String

错误信息描述

代码示例

说明

  • 本示例以Java语言为例,使用了阿里云Java SDK的CommonRequest提交请求,采用RPC风格的POP API调用。阿里云SDK的详细介绍参见阿里云SDK开发指南,Java SDK CommonRequest的使用方法参见使用CommonRequest进行调用

  • 鉴权SDK使用过程中,所有的接口调用均通过阿里云账号完成鉴权操作。通过传入阿里云账号的AccessKey ID和AccessKey Secret(获取方法参见开通服务),调用阿里云Java SDK,创建IAcsClient对象,全局唯一。

  • 示例中包含了三个类:

    • AsrLmModelPopApiDemo:POP API测试类,包含main函数,用于测试接口,您可根据此类,进行集成时的状态检查。

    • AsrLmData:数据集类,封装了数据集相关操作的数据对象和接口调用。

    • AsrLmModel:自学习模型类,封装了自学习模型相关操作的数据对象和接口调用。

添加Java依赖:只需要依赖阿里云Java SDK的核心库与阿里云开源库fastjson。阿里云Java SDK的核心库版本可以选择3.5.0至3.7.x的版本。

<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>aliyun-java-sdk-core</artifactId>
    <version>3.7.1</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.49</version>
</dependency>
  • POP API测试类

    import com.alibaba.fastjson.JSONObject;
    import com.aliyuncs.DefaultAcsClient;
    import com.aliyuncs.IAcsClient;
    import com.aliyuncs.profile.DefaultProfile;
    public class AsrLmModelPopApiDemo {
        private static String REGION = "cn-shanghai";
        private static final String STATUS_FETCHING = "Fetching";
        private static final String STATUS_FETCHINGFAILED = "FetchingFailed";
        private static final String STATUS_READY = "Ready";
        private static final String STATUS_EMPTY = "Empty";
        private static final String STATUS_TRAINING = "Training";
        private static final String STATUS_TRAININGFAILED = "TrainingFailed";
        private static final String STATUS_DEPLOYING = "Deploying";
        private static final String STATUS_DEPLOYED = "Deployed";
        private static IAcsClient client;
        private AsrLmData asrLmData;
        private AsrLmModel asrLmModel;
        public AsrLmModelPopApiDemo(String akId, String akSecret) {
            DefaultProfile profile = DefaultProfile.getProfile(REGION, akId, akSecret);
            client = new DefaultAcsClient(profile);
            asrLmData = new AsrLmData(client);
            asrLmModel = new AsrLmModel(client);
        }
        /******************************* 数据集管理 *******************************/
        // 创建数据集
        public String createAsrLmData(String name, String fileUrl, String description) {
            String dataId = asrLmData.createAsrLmData(name, fileUrl, description);
            if (null == dataId) {
                return dataId;
            }
            // 轮询数据集,检查状态是否为Ready,即数据集导入成功。
            while (true) {
                AsrLmData.LmData data = asrLmData.getAsrLmData(dataId);
                if (null == data) {
                    dataId = null;
                    break;
                }
                if (data.Status.equals(STATUS_FETCHING)) {
                    System.out.println("正在将数据集导入到自学习服务中,dataId: " + dataId);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else if (data.Status.equals(STATUS_FETCHINGFAILED)) {
                    System.out.println("复制数据集出现错误,dataId: " + dataId);
                    asrLmData.deleteAsrLmData(dataId);
                    dataId = null;
                    break;
                }
                else if (data.Status.equals(STATUS_READY)) {
                    System.out.println("数据集导入成功,dataId: " + dataId);
                    break;
                }
            }
            return dataId;
        }
        // 查询数据集
        public AsrLmData.LmData getAsrLmData(String dataId) {
            return asrLmData.getAsrLmData(dataId);
        }
        // 删除数据集
        public boolean deleteAsrLmData(String dataId) {
            AsrLmData.LmData data = asrLmData.getAsrLmData(dataId);
            if (null == data) {
                return false;
            }
            if (!data.Status.equals(STATUS_READY)) {
                System.out.println("数据集状态不允许进行删除操作,status: " + data.Status);
                return false;
            }
            return asrLmData.deleteAsrLmData(dataId);
        }
        // 列举数据集
        public AsrLmData.LmDataPage listAsrLmData() {
            return asrLmData.listAsrLmData();
        }
        /******************************* 自学习模型管理 *******************************/
        // 创建自学习模型
        public String createAsrLmModel(String name, String baseId, String description) {
            String modelId = asrLmModel.createAsrLmModel(name, baseId, description);
            if (null == modelId) {
                return modelId;
            }
            // 轮询自学习模型,检查模型状态是否是Empty,即新创建的自学习模型。
            while (true) {
                AsrLmModel.LmModel model = asrLmModel.getAsrLmModel(modelId);
                if (null == model) {
                    modelId = null;
                    break;
                }
                if (model.Status.equals(STATUS_EMPTY)) {
                    break;
                }
                else {
                    System.out.println("创建自学习模型失败,modelId: " + modelId);
                    asrLmModel.deleteAsrLmModel(modelId);
                    modelId = null;
                    break;
                }
            }
            return modelId;
        }
        // 获取自学习模型
        public AsrLmModel.LmModel getAsrLmModel(String modelId) {
            return asrLmModel.getAsrLmModel(modelId);
        }
        // 删除自学习模型
        public boolean deleteAsrLmModel(String modelId) {
            AsrLmModel.LmModel model = asrLmModel.getAsrLmModel(modelId);
            if (null == model) {
                return false;
            }
            if (model.Status.equals(STATUS_TRAINING) || model.Status.equals(STATUS_DEPLOYING)) {
                System.out.println("自学习模型状态不允许进行删除操作,status: " + model.Status);
                return false;
            }
            return asrLmModel.deleteAsrLmModel(modelId);
        }
        // 列举自学习模型
        public AsrLmModel.LmModelPage listAsrLmModel() {
            return asrLmModel.listAsrLmModel();
        }
        /**************************** 自学习模型的训练与发布 ***************************/
        // 添加数据集到自学习模型
        public boolean addDataToAsrLmModel(String dataId, String modelId) {
            AsrLmData.LmData data = asrLmData.getAsrLmData(dataId);
            if (null == data) {
                return false;
            }
            if (!data.Status.equals(STATUS_READY)) {
                System.out.println("数据集状态不允许进行添加到自学习模型操作,status: " + data.Status);
                return false;
            }
            AsrLmModel.LmModel model = asrLmModel.getAsrLmModel(modelId);
            if (null == model) {
                return false;
            }
            if (model.Status.equals(STATUS_TRAINING) || model.Status.equals(STATUS_DEPLOYING)) {
                System.out.println("自学习模型状态不允许进行添加数据集操作,status: " + model.Status);
                return false;
            }
            return asrLmModel.addDataToAsrLmModel(dataId, modelId);
        }
        // 从自学习模型中删除数据集
        public boolean removeDataFromAsrLmModel(String dataId, String modelId) {
            // 列举指定模型使用到的数据集,判断待删除的数据集是否已经添加到该模型。
            boolean isAdded = false;
            AsrLmData.LmDataPage page = asrLmData.listAsrLmData(1, 10, modelId);
            if (page != null && page.Content.size() > 0) {
                for (int i = 0; i < page.Content.size(); i++) {
                    if (dataId.equals(page.Content.get(i).Id)) {
                        isAdded = true;
                        break;
                    }
                }
            }
            if (!isAdded) {
                System.out.println("待删除的数据集没有添加到指定模型,不能进行删除操作!");
                return false;
            }
            // 检查模型状态是否允许删除数据集操作
            AsrLmModel.LmModel model = asrLmModel.getAsrLmModel(modelId);
            if (null == model) {
                return false;
            }
            if (model.Status.equals(STATUS_TRAINING)) {
                System.out.println("自学习模型状态不允许进行删除数据集操作,status: " + model.Status);
                return false;
            }
            return asrLmModel.removeDataFromAsrLmModel(dataId, modelId);
        }
        // 训练自学习模型
        public boolean trainAsrLmModel(String modelId) {
            AsrLmModel.LmModel model = asrLmModel.getAsrLmModel(modelId);
            if (null == model) {
                return false;
            }
            if (model.Status.equals(STATUS_DEPLOYING)) {
                System.out.println("自学习模型状态不允许进行训练操作,status: " + model.Status);
                return false;
            }
            boolean isTrain = asrLmModel.trainAsrLmModel(modelId);
            if (!isTrain) {
                return isTrain;
            }
            // 轮询自学习模型,直到状态为Deployed,即自学习模型训练成功且并已上线。
            while (true) {
                model = asrLmModel.getAsrLmModel(modelId);
                if (null == model) {
                    isTrain = false;
                    break;
                }
                if (model.Status.equals(STATUS_TRAINING) || model.Status.equals(STATUS_DEPLOYING)) {
                    if (model.Status.equals(STATUS_TRAINING)) {
                        System.out.println("自学习模型正在训练中,modelId: " + modelId);
                    }
                    else {
                        System.out.println("自学习模型正在上线,modelId: " + modelId);
                    }
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else if (model.Status.equals(STATUS_TRAININGFAILED)) {
                    System.out.println("自学习模型训练失败, modelId: " + modelId);
                    isTrain = false;
                    break;
                }
                else if (model.Status.equals(STATUS_DEPLOYED)) {
                    System.out.println("自学习模型训练成功并已上线,modeId: " + modelId);
                    isTrain = true;
                    break;
                }
                else {
                    System.out.println("自学习模型状态不允许进行训练操作,Status: " + model.Status);
                    isTrain = false;
                    break;
                }
            }
            return isTrain;
        }
        // 上线自学习模型
        public boolean deployAsrLmModel(String modelId) {
            AsrLmModel.LmModel model = asrLmModel.getAsrLmModel(modelId);
            if (null == model) {
                return false;
            }
            if (!model.Status.equals(STATUS_READY)) {
                System.out.println("自学习模型状态不允许进行上线操作,status: " + model.Status);
                return false;
            }
            boolean isDeployed = asrLmModel.deployAsrLmModel(modelId);
            if (!isDeployed) {
                return isDeployed;
            }
            // 轮询自学习模型,检查状态是否是Deployed,即自学习模型已上线。
            while (true) {
                model = asrLmModel.getAsrLmModel(modelId);
                if (null == model) {
                    isDeployed = false;
                    break;
                }
                if (model.Status.equals(STATUS_DEPLOYING)) {
                    System.out.println("自学习模型正在上线,modelId: " + modelId);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else if (model.Status.equals(STATUS_DEPLOYED)) {
                    System.out.println("自学习模型已经上线,modelId: " + modelId);
                    isDeployed = true;
                    break;
                }
                else {
                    System.out.println("自学习模型的状态不允许上线操作,Status: " + model.Status);
                    isDeployed = false;
                    break;
                }
            }
            return isDeployed;
        }
        // 下线自学习模型
        public boolean undeployAsrLmModel(String modelId) {
            AsrLmModel.LmModel model = asrLmModel.getAsrLmModel(modelId);
            if (null == model) {
                return false;
            }
            if (!model.Status.equals(STATUS_DEPLOYED)) {
                System.out.println("自学习模型的状态不允许进行下线操作,status: " + model.Status);
                return false;
            }
            boolean isUnDeployed = asrLmModel.undeployAsrLmModel(modelId);
            if (!isUnDeployed) {
                return isUnDeployed;
            }
            // 轮询自学习模型,检查状态是否是Ready,即自学习模型下线完成。
            while (true) {
                model = asrLmModel.getAsrLmModel(modelId);
                if (null == model) {
                    isUnDeployed = false;
                    break;
                }
                if (model.Status.equals(STATUS_DEPLOYING)) {
                    System.out.println("自学习模型正在下线, modelId: " + modelId);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else if (model.Status.equals(STATUS_READY)) {
                    System.out.println("自学习模型下线完成,modelId: " + modelId);
                    isUnDeployed = true;
                    break;
                }
                else {
                    System.out.println("自学习模型的状态不允许进行下线操作,Status: " + model.Status);
                    isUnDeployed = false;
                    break;
                }
            }
            return isUnDeployed;
        }
        public static void main(String[] args) {
            if (args.length < 2) {
                System.err.println("AsrLmModelPopApiDemo need params: <AccessKey Id> <AccessKey Secret>");
                return;
            }
            String accessKeyId = args[0];
            String accessKeySecret = args[1];
            AsrLmModelPopApiDemo demo = new AsrLmModelPopApiDemo(accessKeyId, accessKeySecret);
            /******************************* 数据集管理 *******************************/
            // 数据集ID
            String dataId;
            // 创建数据集
            String name = "测试数据集";
            String fileUrl = "https://aliyun-nls.oss-cn-hangzhou.aliyuncs.com/asr/fileASR/SLP/SLPTest.txt";
            String description = "通过POP-API创建数据集";
            dataId = demo.createAsrLmData(name, fileUrl, description);
            if (dataId != null) {
                System.out.println("创建数据集成功,数据集ID:" + dataId);
            }
            else {
                System.out.println("创建数据集失败!");
            }
            // 查询数据集
            AsrLmData.LmData data = demo.getAsrLmData(dataId);
            if (data != null) {
                System.out.println("获取数据集成功:" + JSONObject.toJSONString(data));
            }
            else {
                System.out.println("获取数据集失败!");
            }
            // 列举所有数据集
            AsrLmData.LmDataPage page = demo.listAsrLmData();
            if (page != null) {
                System.out.println("列举词表成功:" + JSONObject.toJSONString(page));
            }
            else {
                System.out.println("列举词表失败!");
                return;
            }
            /************************** 自学习模型管理 *********************************/
            // 自学习模型ID
            String modelId;
            // 创建自学习模型
            String modelName = "测试自学习模型";
            // 使用的是通用模型,请根据业务需求选择合适的基础模型。
            String baseId = "universal";
            String modelDescription = "测试自学习模型描述";
            modelId = demo.createAsrLmModel(modelName, baseId, modelDescription);
            if (modelId != null) {
                System.out.println("创建自学习模型成功,模型ID:" + modelId);
            }
            else {
                System.out.println("创建自学习模型失败!");
            }
            // 查询自学习模型
            AsrLmModel.LmModel model = demo.getAsrLmModel(modelId);
            if (model != null) {
                System.out.println("获取自学习模型成功:" + JSONObject.toJSONString(model));
            }
            else {
                System.out.println("获取自学习模型失败!");
            }
            // 列举自学习模型
            AsrLmModel.LmModelPage modelPage = demo.listAsrLmModel();
            if (modelPage != null) {
                System.out.println("列举自学习模型成功:" + JSONObject.toJSONString(modelPage));
            }
            else {
                System.out.println("列举自学习模型失败!");
            }
            /******************************* 自学习模型的训练与发布 *******************************/
            // 添加数据集到自学习模型
            boolean isAdded = demo.addDataToAsrLmModel(dataId, modelId);
            if (isAdded) {
                System.out.println("添加数据集到自学习模型成功!");
            }
            else {
                System.out.println("添加数据集到自学习模型失败!");
            }
            // 训练自学习模型
            boolean isTrian = demo.trainAsrLmModel(modelId);
            if (isTrian) {
                System.out.println("训练自学习模型成功!");
            }
            else {
                System.out.println("训练自学习模型失败!");
            }
            // 下线自学习模型
            boolean isUnDeployed = demo.undeployAsrLmModel(modelId);
            if (isUnDeployed) {
                System.out.println("自学习模型下线成功!");
            }
            else {
                System.out.println("自学习模型下线失败!");
            }
            // 上线自学习模型
            boolean isDeployed = demo.deployAsrLmModel(modelId);
            if (isDeployed) {
                System.out.println("自学习模型上线成功!");
            }
            else {
                System.out.println("自学习模型上线失败!");
            }
            /***************************** 清理数据集和模型,请根据需求操作 *****************************/
            // 1. 下线自学习模型,需要时开启。
            isUnDeployed = demo.undeployAsrLmModel(modelId);
            if (isUnDeployed) {
                System.out.println("自学习模型下线成功!");
            }
            else {
                System.out.println("自学习模型下线失败!");
            }
            // 2. 从自学习模型中删除数据集,需要时开启。
            boolean isDeleted = demo.removeDataFromAsrLmModel(dataId, modelId);
            if (isDeleted) {
                System.out.println("从自学习模型中删除数据集成功!");
            }
            else {
                System.out.println("从自学习模型中删除数据集失败!");
            }
            // 3. 删除数据集,需要时开启。
            boolean isDeletedData = demo.deleteAsrLmData(dataId);
            if (isDeletedData) {
                System.out.println("删除数据集成功!");
            }
            else {
                System.out.println("删除数据集失败!");
            }
            // 4. 删除自学习模型,需要时开启。
            boolean isDeletedModel = demo.deleteAsrLmModel(modelId);
            if (isDeletedModel) {
                System.out.println("删除自学习模型成功!");
            }
            else {
                System.out.println("删除自学习模型失败!");
            }
        }
    }

  • 数据集类

    import com.alibaba.fastjson.JSONObject;
    import com.aliyuncs.CommonRequest;
    import com.aliyuncs.CommonResponse;
    import com.aliyuncs.IAcsClient;
    import com.aliyuncs.exceptions.ClientException;
    import com.aliyuncs.http.MethodType;
    import com.aliyuncs.http.ProtocolType;
    import java.util.ArrayList;
    import java.util.List;
    public class AsrLmData {
        public static class LmData {
            public String Name;
            public String Status;
            public String Description;
            public String Url;
            public String CreateTime;
            public String UpdateTime;
            public String Id;
            public String ErrorMessage;   // 只有Status为错误状态时有该信息。
            public int Size;
        }
        public static class LmDataPage {
            public int PageNumber;
            public int PageSize;
            public int TotalItems;
            public int TotalPages;
            public List<LmData> Content = new ArrayList<LmData>();
        }
        private static final String VERSION = "2018-11-20";
        private static final String DOMAIN = "nls-slp.cn-shanghai.aliyuncs.com";
        private static ProtocolType PROTOCOL_TYPE = ProtocolType.HTTPS;
        private static final String KEY_NAME = "Name";
        private static final String KEY_URL = "Url";
        private static final String KEY_DESCRIPTION = "Description";
        private static final String KEY_DATA_ID = "DataId";
        private static final String KEY_DATA = "Data";
        private static final String KEY_PAGE = "Page";
        private static final String KEY_PAGE_NUMBER = "PageNumber";
        private static final String KEY_PAGE_SIZE = "PageSize";
        private static final String KEY_MODEL_ID = "ModelId";
        private IAcsClient client;
        private CommonRequest newRequest(String action) {
            CommonRequest request = new CommonRequest();
            request.setDomain(DOMAIN);
            request.setProtocol(PROTOCOL_TYPE);
            request.setVersion(VERSION);
            request.setMethod(MethodType.POST);
            request.setAction(action);
            return request;
        }
        public AsrLmData(IAcsClient client) {
            this.client = client;
        }
        /**
         * 创建数据集
         * @param name 创建的数据集名称,必填。
         * @param fileUrl 数据集文件的链接,需要服务端可下载,必填。
         * @param  description 数据集描述信息,可选。
         * @return String 创建的数据集ID。
         */
        public String createAsrLmData(String name, String fileUrl, String description) {
            CommonRequest request = newRequest("CreateAsrLmData");
            request.putBodyParameter(KEY_NAME, name);
            request.putBodyParameter(KEY_URL, fileUrl);
            request.putBodyParameter(KEY_DESCRIPTION, description);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("CreateAsrLmData: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("创建数据集失败,HTTP错误码:" + response.getHttpStatus());
                return null;
            }
            JSONObject result = JSONObject.parseObject(response.getData());
            String dataId = result.getString(KEY_DATA_ID);
            return dataId;
        }
        /**
         * 查询数据集
         * @param dataId 数据集ID
         * @return LmData 获取的数据集对象
         */
        public LmData getAsrLmData(String dataId) {
            CommonRequest request = newRequest("GetAsrLmData");
            request.putBodyParameter(KEY_DATA_ID, dataId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("GetAsrLmData: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("获取数据集失败,HTTP错误码:" + response.getHttpStatus());
                return null;
            }
            JSONObject result = JSONObject.parseObject(response.getData());
            String dataJson = result.getString(KEY_DATA);
            LmData data = JSONObject.parseObject(dataJson, LmData.class);
            return data;
        }
        /**
         * 删除数据集
         * @param dataId 需要删除的数据集ID,必填。
         * @return 是否删除成功。
         */
        public boolean deleteAsrLmData(String dataId) {
            CommonRequest request = newRequest("DeleteAsrLmData");
            request.putBodyParameter(KEY_DATA_ID, dataId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("DeleteAsrLmData: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("删除数据集失败,HTTP错误码:" + response.getHttpStatus());
                return false;
            }
            return true;
        }
        /**
         * 列举数据集
         * @param pageNumber 页号,从1开始编号,可选,默认值是1。
         * @param pageSize  页大小,从1到100,可选,默认值是10。
         * @param modelId 模型ID,用于搜索被指定模型使用到的数据集,可选,默认列出所有数据集。
         * @return 数据集信息。
         */
        public LmDataPage listAsrLmData(int pageNumber, int pageSize, String modelId) {
            CommonRequest request = newRequest("ListAsrLmData");
            request.putBodyParameter(KEY_PAGE_NUMBER, pageNumber);
            request.putBodyParameter(KEY_PAGE_SIZE, pageSize);
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("ListAsrLmData: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("列举数据集失败,HTTP错误码:" + response.getHttpStatus());
                return null;
            }
            JSONObject result = JSONObject.parseObject(response.getData());
            String pageJson = result.getString(KEY_PAGE);
            LmDataPage page = JSONObject.parseObject(pageJson, LmDataPage.class);
            return page;
        }
        public LmDataPage listAsrLmData() {
            return listAsrLmData(1, 10, null);
        }
    }

  • 自学习模型类

    import com.alibaba.fastjson.JSONObject;
    import com.aliyuncs.CommonRequest;
    import com.aliyuncs.CommonResponse;
    import com.aliyuncs.IAcsClient;
    import com.aliyuncs.exceptions.ClientException;
    import com.aliyuncs.http.MethodType;
    import com.aliyuncs.http.ProtocolType;
    import java.util.ArrayList;
    import java.util.List;
    public class AsrLmModel {
        public static class LmModel {
            public String Name;
            public String Status;
            public String Description;
            public String CreateTime;
            public String UpdateTime;
            public String Id;
            public String BaseId;
            public String ErrorMessage;   // 只有Status为错误状态时有该信息。
            public int Size;
        }
        public static class LmModelPage {
            public int PageNumber;
            public int PageSize;
            public int TotalItems;
            public int TotalPages;
            public List<LmModel> Content = new ArrayList<LmModel>();
        }
        private static final String VERSION = "2018-11-20";
        private static final String DOMAIN = "nls-slp.cn-shanghai.aliyuncs.com";
        private static ProtocolType PROTOCOL_TYPE = ProtocolType.HTTPS;
        private static final String KEY_NAME = "Name";
        private static final String KEY_BASE_ID = "BaseId";
        private static final String KEY_DESCRIPTION = "Description";
        private static final String KEY_MODEL_ID = "ModelId";
        private static final String KEY_MODEL = "Model";
        private static final String KEY_PAGE = "Page";
        private static final String KEY_PAGE_NUMBER = "PageNumber";
        private static final String KEY_PAGE_SIZE = "PageSize";
        private static final String KEY_DATA_ID = "DataId";
        private IAcsClient client;
        private CommonRequest newRequest(String action) {
            CommonRequest request = new CommonRequest();
            request.setDomain(DOMAIN);
            request.setProtocol(PROTOCOL_TYPE);
            request.setVersion(VERSION);
            request.setMethod(MethodType.POST);
            request.setAction(action);
            return request;
        }
        public AsrLmModel(IAcsClient client) {
            this.client = client;
        }
        /**
         * 创建模型
         * @param name 自学习模型名称,必填。
         * @param baseId 基础模型ID,创建成功后不可修改,必填。
         * @param description 自学习模型描述信息,可选。
         * @return 创建的模型ID。
         */
        public String createAsrLmModel(String name, String baseId, String description) {
            CommonRequest request = newRequest("CreateAsrLmModel");
            request.putBodyParameter(KEY_NAME, name);
            request.putBodyParameter(KEY_BASE_ID, baseId);
            request.putBodyParameter(KEY_DESCRIPTION, description);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("CreateAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("创建自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return null;
            }
            JSONObject result = JSONObject.parseObject(response.getData());
            String modelId = result.getString(KEY_MODEL_ID);
            return modelId;
        }
        /**
         * 查询自学习模型
         * @param modelId 模型ID
         * @return 获取的模型对象
         */
        public LmModel getAsrLmModel(String modelId) {
            CommonRequest request = newRequest("GetAsrLmModel");
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("GetAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("查询自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return null;
            }
            JSONObject result = JSONObject.parseObject(response.getData());
            String modelJson = result.getString(KEY_MODEL);
            LmModel model = JSONObject.parseObject(modelJson, LmModel.class);
            return model;
        }
        /**
         * 删除自学习模型
         * @param modelId 需要删除的自学习模型ID
         * @return 是否删除成功
         */
        public boolean deleteAsrLmModel(String modelId) {
            CommonRequest request = newRequest("DeleteAsrLmModel");
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("DeleteAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("删除自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return false;
            }
            return true;
        }
        /**
         * 列举自学习模型
         * @param pageNumber 页号,从1开始,可选,默认值是1。
         * @param pageSize 页大小,从1到100,可选,默认值是10。
         * @param dataId 数据集ID,用于搜索使用了指定数据集的模型,可选,默认列出所有自学习模型。
         * @return 自学习模型信息。
         */
        public LmModelPage listAsrLmModel(int pageNumber, int pageSize, String dataId) {
            CommonRequest request = newRequest("ListAsrLmModel");
            request.putBodyParameter(KEY_PAGE_NUMBER, pageNumber);
            request.putBodyParameter(KEY_PAGE_SIZE, pageSize);
            request.putBodyParameter(KEY_DATA_ID, dataId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("ListAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("列举自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return null;
            }
            JSONObject result = JSONObject.parseObject(response.getData());
            String pageJson = result.getString(KEY_PAGE);
            LmModelPage page = JSONObject.parseObject(pageJson, LmModelPage.class);
            return page;
        }
        public LmModelPage listAsrLmModel() {
            return listAsrLmModel(1, 10, null);
        }
        /**
         * 添加数据集到自学习模型
         * @param dataId 需要添加的数据集ID
         * @param modelId 自学习模型ID
         * @return 是否添加成功
         */
        public boolean addDataToAsrLmModel(String dataId, String modelId) {
            CommonRequest request = newRequest("AddDataToAsrLmModel");
            request.putBodyParameter(KEY_DATA_ID, dataId);
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("AddDataToAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("添加数据集到自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return false;
            }
            return true;
        }
        /**
         * 从自学习模型中删除数据集
         * @param dataId 需要删除的数据集
         * @param modelId 自学习模型ID
         * @return 是否删除成功
         */
        public boolean removeDataFromAsrLmModel(String dataId, String modelId) {
            CommonRequest request = newRequest("RemoveDataFromAsrLmModel");
            request.putBodyParameter(KEY_DATA_ID, dataId);
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("RemoveDataFromAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("从自学习模型中删除数据集失败,HTTP错误码:" + response.getHttpStatus());
                return false;
            }
            return true;
        }
        /**
         * 开始训练自学习模型
         * @param modelId 需要开始训练的自学习模型ID
         * @return 是否开始训练成功
         * */
        public boolean trainAsrLmModel(String modelId) {
            CommonRequest request = newRequest("TrainAsrLmModel");
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("TrainAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("开始训练自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return false;
            }
            return true;
        }
        /**
         * 上线自学习模型
         * @param modelId 需要上线的自学习模型ID
         * @return 是否上线成功
         */
        public boolean deployAsrLmModel(String modelId) {
            CommonRequest request = newRequest("DeployAsrLmModel");
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("DeployAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("上线自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return false;
            }
            return true;
        }
        /**
         * 下线自学习模型
         * @param modelId 需要下线的自学习模型ID
         * @return 是否下线成功
         */
        public boolean undeployAsrLmModel(String modelId) {
            CommonRequest request = newRequest("UndeployAsrLmModel");
            request.putBodyParameter(KEY_MODEL_ID, modelId);
            CommonResponse response = null;
            try {
                response = client.getCommonResponse(request);
            } catch (ClientException e) {
                e.printStackTrace();
            }
            System.out.println("UndeployAsrLmModel: " + response.getData());
            if (response == null || response.getHttpStatus() != 200) {
                System.out.println(response.getData());
                System.out.println("下线自学习模型失败,HTTP错误码:" + response.getHttpStatus());
                return false;
            }
            return true;
        }
    }