智能语音交互：使用POP API创建自学习模型

训练数据集状态

自学习模型状态

训练数据集操作

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

{
    "Data": {
        "Name": "测试数据集",
        "Status": "Ready",
        "Md5": "38fc072ac60796a84ce1a0b13f78****",
        "Description": "通过POP-API创建数据集",
        "Url": "https://aliyun-nls.oss-ap-southeast-1.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****"
}

{
    "RequestId": "7130914d32a3441db06747523675d9ff"
}

{
    "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
    }
}

自学习模型操作

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

{
    "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****"
}

{
    "RequestId": "7130914d32a3441db06747523675d9ff"
}

{
    "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
    }
}

模型训练与发布

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

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

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

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

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

添加依赖

添加以下Maven依赖。阿里云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.83</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 = "ap-southeast-1";
    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.ap-southeast-1.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  页大小，从10到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.ap-southeast-1.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;
    }
}