使用POP API创建自学习模型

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

• 数据集（训练语料）管理

  • 创建数据集：CreateAsrLmData

  • 查询数据集：GetAsrLmData

  • 删除数据集：DeleteAsrLmData

  • 列举数据集：ListAsrLmData

• 自学习模型管理

  • 创建自学习模型：CreateAsrLmModel

  • 查询自学习模型：GetAsrLmModel

  • 删除自学习模型：DeleteAsrLmModel

  • 列举自学习模型：ListAsrLmModel

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

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

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

  • 训练自学习模型：TrainAsrLmModel

  • 上线自学习模型：DeployAsrLmModel

  • 下线自学习模型：UndeployAsrLmModel

开通服务

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

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

训练流程

训练过程步骤如下：

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

   数据集操作的状态转换

   

   状态说明：

   状态	说明
   Fetching	正在将训练数据从URL导入到自学习系统中。
   FetchingFailed	复制数据集出现错误，请检查训练数据的URL是否正确（只支持阿里云OSS的HTTP/HTTPS链接）。
   Ready	数据集导入成功。

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

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

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

   

   状态说明：

   状态	说明
   Empty	自学习模型新创建，还未训练过。
   Training	自学习模型正在训练中。
   TrainingFailed	自学习模型训练失败。
   Ready	已上线的自学习模型下线成功。
   Deploying	自学习模型正在上线或下线。
   Deployed	自学习模型已上线。

接口说明

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

创建数据集

调用动作：CreateAsrLmData

输入参数：

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

输出参数：

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

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

参数说明：

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

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

  参数化名称	类型	说明
  RequestId	String	请求ID。
  DataId	String	数据集ID，作为后续模型训练使用。

查询数据集

调用动作：GetAsrLmData

输入参数：

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

输出参数：

服务端返回响应体为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	数据集大小（单位：Byte）。
  Md5	String	数据集MD5值。
  Url	String	创建数据集使用的URL。
  Status	String	数据集状态。可能的状态Fetching、FetchingFailed、Ready。
  CreateTime	String	数据集创建时间。
  UpdateTime	String	数据集更新时间。
  ErrorMessage	String	错误消息（Status为错误状态时出现）。

删除数据集

调用动作：DeleteAsrLmData

输入参数：

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

输出参数：

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

{
    "RequestId": "7130914d32a3441db06747523675d9ff"
}

参数说明：

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

列举数据集

调用动作：ListAsrLmData

输入参数：

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

输出参数：

服务端返回响应体为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

输入参数：

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

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

输出参数：

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

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

参数说明：

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

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

  参数名称	类型	说明
  RequestId	String	请求ID。
  ModelId	String	创建的自学习模型ID，作为后续的模型训练使用。

查询自学习模型

调用动作：GetAsrLmModel

输入参数：

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

输出参数：

服务端返回响应体为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

输入参数：

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

输出参数：

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

{
    "RequestId": "7130914d32a3441db06747523675d9ff"
}

参数说明：

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

列举自学习模型

调用动作：ListAsrLmModel

输入参数：

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

输出参数：

服务端返回响应体为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	页包含的自学习模型数量，与输入参数相同。

添加数据集到自学习模型

调用动作：AddDataToAsrLmModel

输入参数：

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

输出参数：

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

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

参数说明：

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

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

调用动作：RemoveDataFromAsrLmModel

输入参数：

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

输出参数：

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

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

参数说明：

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

开始训练自学习模型

调用动作：TrainAsrLmModel

输入参数：

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

输出参数：

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

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

参数说明：

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

上线自学习模型

调用动作：DeployAsrLmModel

输入参数：

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

输出参数：

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

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

参数说明：

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

下线自学习模型

调用动作：UndeployAsrLmModel

输入参数：

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

输出参数：

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

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

参数说明：

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

错误码

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

以NOT_FOUND错误为例：

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

代码示例

添加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.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 = "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  页大小，从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.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;
      }
  }