新能源功率预测_工业大脑(Industrial Intelligence)-阿里云帮助中心

本文为您介绍如何通过SDK调用如下算法API：CreatePowerForecastJob- 创建功率预测任务。

前提条件

已安装SDK，并已获取云账号AK信息。

接口参数

请求参数

字段名称

字段详情

DeviceType string

设备类型，每个systemType支持的设备类型有：

系统类型：设备类型

solar: solarInverter --光伏逆变器

示例值: solarInverter

- HistoryData array<object>

历史功率数据，需要 90 天的历史数据

子级条数 <= 100000子级条数 >= 1

--- object

----RunTime string

每{freq}分钟，"yyyy-MM-dd HH:mm:ss"，数据频率需与 freq 字段对齐

示例值:2025-02-12 00:00:00

----Value number<double>

功率数据

示例值:1.0

Freq string

默认 15min；需要与 historyData 的数据频率一致；枚举值：

FIFTEEN_MIN: 15 分钟
FIVE_MIN: 5 分钟
ONE_HOUR: 1 小时
ONE_DAY: 1 天

示例值:FIFTEEN_MIN枚举值:FIFTEEN_MINFIVE_MINONE_HOURONE_DAY

Duration integer<int32>

从运行日(含)开始, 预测时长（单位：天）非必填，默认 1 天

示例值:1

SystemType string

系统类型，支持的系统类型有：

solar: 光伏

示例值:solar

RunDate string

运行日，精确到天，“yyyy-MM-dd”格式

示例值:2025-02-12

TimeZone string

时区,默认上海时区：Asia/Shanghai

示例值:Asia/Shanghai

ModelVersion string

模型对应的版本号，默认为 latest

示例值:latest

- Location object

地址位置信息，经纬度

--Altitude number<double>

海拔高度，精度到小数点后 3 位，默认值为 10

示例值:10.123

--Latitude number<double>

纬度，精度到小数点后 3 位

示例值:40.027

--Longitude number<double>

经度，精度到小数点后 3 位

示例值:120.042

BusinessKey string

业务键，如场站名称编号。

示例值:stationA

请求示例

以JSON格式为例：

{
  "historyData":[
    {"runTime": "2023-05-06 20:00:00","value": 1.8},
    {"runTime": "2023-05-06 20:15:00","value": 1.9},
    ...
    {"runTime": "2023-08-05 19:45:00","value": 1.7}
  ],
  "systemType": "solar",
  "deviceType": "solarInverter",
  "location": {
    "longitude": 23.233,
    "latitude": 113.666,
    "altitude": 10
  }
  "runDate": "2023-08-06",
  "duration": 1,
  "freq": "FIFTEEN_MIN",
  "timeZone": "Asia/Shanghai",
  "modelVersion": "latest",
  "businessKey": "stationA"
}

说明

duration需要大于等于1（单位：天）。

返回参数

字段名称

字段详情

RequestId string

Id of the request

示例值:68738E75-43C1-5AE5-9F3A-AFEF576D7B5F

Success string

是否调用成功。

True：调用成功。
False：调用失败。

示例值:True

Code string

状态码。

说明 200 表示成功。

示例值:200

Message string

返回信息。

示例值:successful

- Data object

返回 JOB 详细信息

--Completed boolean

操作是否完成，取值范围： True：当前 Job 已经执行完成。 False：当前 Job 还在执行中。

示例值:True

--CreateTime string

任务创建时间

示例值:2024-12-22 00:00:21

--Error string

当前操作异常或者失败时的错误信息

示例值:""

--JobId string

算法计算任务 ID

示例值:8c0ca18a-246a-4acd-80ca-e16d8ff5ef33

--Progress integer<int32>

进度

示例值:25

--- Response object

计算任务的结果

----DebugInfo any

调试信息

示例值:{}

----JobType string

计算任务类型，枚举值：LoadForecast PowerForecast

示例值:LoadForecast

----Result any

计算任务的结果

示例值:{}

--Status string

任务状态，枚举值： RUNNING, SUCCESS, FAIL

示例值:RUNNING

说明

计算任务是一个异步任务，最终计算任务的结果，需要使用Jobld通过结果查询结果获得。

返回示例

{
  "RequestId": "68738E75-43C1-5AE5-9F3A-AFEF576D7B5F",
  "Success": "True",
  "Code": "200",
  "Message": "successful",
  "Data": {
    "Completed": true,
    "CreateTime": "2024-12-22 00:00:21",
    "Error": "\"\"",
    "JobId": "8c0ca18a-246a-4acd-80ca-e16d8ff5ef33",
    "Progress": 25,
    "Response": {
      "DebugInfo": "{}",
      "JobType": "LoadForecast",
      "Result": "{}"
    },
    "Status": "RUNNING"
  }
}

SDK调用示例

Java SDK使用示例

当不需要并发调用时，可以使用Java同步的方式调用SDK；当需要并发调用时，使用Java异步的方式调用SDK。

Java同步（pom.xml）：

<dependency>
  <groupId>com.aliyun</groupId>
  <artifactId>brain_industrial20200920</artifactId>
  <version>2.1.0</version>
</dependency>

Java同步（sample.java）：

package org.example;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.aliyun.brain_industrial20200920.Client;
import com.aliyun.brain_industrial20200920.models.CreatePowerForecastJobRequest;
import com.aliyun.brain_industrial20200920.models.CreatePowerForecastJobResponse;

import com.aliyun.tea.TeaException;
import com.aliyun.teaopenapi.models.Config;
import com.google.gson.Gson;

public class Main {
    public static void main(String[] args) throws Exception {
        testPowerForecast();
    }

    public static void testPowerForecast() throws Exception{
        List<CreatePowerForecastJobRequest.CreatePowerForecastJobRequestHistoryData> history = new ArrayList<>();
        // mock一个月的历史数据
        LocalDate  startDateLocal = LocalDate.parse("2025-03-01");
        for (int i = 0; i < 31; i++) {
            LocalDate newDateLocal = startDateLocal.plusDays(i);
            String newDate = newDateLocal.toString();
            CreatePowerForecastJobRequest.CreatePowerForecastJobRequestHistoryData e1 = new CreatePowerForecastJobRequest.CreatePowerForecastJobRequestHistoryData()
                    .setRunTime(newDate + " 00:00:00")
                    .setValue(100.0);
            history.add(e1);
        }

        CreatePowerForecastJobRequest.CreatePowerForecastJobRequestLocation location = new CreatePowerForecastJobRequest.CreatePowerForecastJobRequestLocation()
                .setLatitude(40.0)
                .setLongitude(100.0);
        CreatePowerForecastJobRequest req = new CreatePowerForecastJobRequest()
                .setDeviceType("solarInverter")
                .setSystemType("solar")
                .setDuration(2)
                .setRunDate("2025-04-01")
                .setLocation(location)
                .setHistoryData(history);
        Client client = createClient();
//        Client client = createClientAkSk();
        try {
            // 复制代码运行请自行打印 API 的返回值
            CreatePowerForecastJobResponse response = client.createPowerForecastJob(req);
            System.out.println(new Gson().toJson(response.getBody()));
//            System.out.println("job id = " + response.getBody().getData().getJobId());
        } catch (TeaException error) {
            // 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
            // 错误 message
            System.out.println(error.getMessage());
            // 诊断地址
            System.out.println(error.getData().get("Recommend"));
            com.aliyun.teautil.Common.assertAsString(error.message);
        } catch (Exception _error) {
            TeaException error = new TeaException(_error.getMessage(), _error);
            // 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
            // 错误 message
            System.out.println(error.getMessage());
            // 诊断地址
            System.out.println(error.getData().get("Recommend"));
            com.aliyun.teautil.Common.assertAsString(error.message);
        }
    }

    // sts方式 初始化账号Client
    public static Client createClient() throws Exception {
        // 初始化credential
        Map<String, Object> buildInfo = new HashMap<>();
        buildInfo.put("type", "ram_role_arn");
        buildInfo.put("accessKeyId", System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"));
        buildInfo.put("accessKeySecret", System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"));
        buildInfo.put("roleArn", System.getenv("ROLE_ARN"));
        buildInfo.put("roleSessionExpiration", 3600);
        com.aliyun.credentials.models.Config credentialConfig = com.aliyun.credentials.models.Config.build(buildInfo);
        com.aliyun.credentials.Client credientClient = new com.aliyun.credentials.Client(credentialConfig);

        // 使用Credential client初始化brain industrial客户端
        Config brainConfig = new Config();
        brainConfig.setCredential(credientClient);
        brainConfig.setEndpoint("brain-industrial.cn-hangzhou.aliyuncs.com");
        return new Client(brainConfig);
    }

    // 使用AK&SK初始化账号Client
    public static Client createClientAkSk() throws Exception {
        // 工程代码泄露可能会导致 AccessKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考。
        // 建议使用更安全的 STS 方式，更多鉴权访问方式请参见：https://help.aliyun.com/document_detail/378657.html。
        com.aliyun.teaopenapi.models.Config config = new com.aliyun.teaopenapi.models.Config()
                // 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_ID。
                .setAccessKeyId(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"))
                // 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_SECRET。
                .setAccessKeySecret(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"));
        // Endpoint 请参考 https://api.aliyun.com/product/brain-industrial
        config.endpoint = "brain-industrial.cn-hangzhou.aliyuncs.com";
        config.regionId = "cn-hangzhou";
        config.type = "access_key";
        return new com.aliyun.brain_industrial20200920.Client(config);
    }
}

Java异步（pom.xml）：

<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>alibabacloud-brain_industrial20200920</artifactId>
    <version>2.0.2</version>
</dependency>

Java异步（sample.java）：

package org.example;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.concurrent.CompletableFuture;

import com.aliyun.sdk.service.brain_industrial20200920.AsyncClient;
import com.aliyun.sdk.service.brain_industrial20200920.models.CreatePowerForecastJobRequest;
import com.aliyun.sdk.service.brain_industrial20200920.models.CreatePowerForecastJobResponse;
import com.aliyun.tea.TeaException;
import darabonba.core.client.ClientOverrideConfiguration;
import com.aliyun.auth.credentials.Credential;
import com.aliyun.auth.credentials.provider.StaticCredentialProvider;
import com.google.gson.Gson;
public class Async {
    public static void main(String[] args) throws Exception {
//        testPowerForecastAsync();
        concurrentPowerForecast();
    }
    public static void concurrentPowerForecast() throws Exception {
        // 并发调用testPowerForecast函数
        ArrayList<CreatePowerForecastJobRequest.HistoryData> history = new ArrayList<>();
        LocalDate  startDateLocal = LocalDate.parse("2025-03-01");
        for (int i = 0; i < 31; i++) {
            LocalDate newDateLocal = startDateLocal.plusDays(i);
            String newDate = newDateLocal.toString();
            CreatePowerForecastJobRequest.HistoryData e = CreatePowerForecastJobRequest.HistoryData.builder()
                    .runTime(newDate + " 00:00:00")
                    .value(4.0)
                    .build();
            history.add(e);
        }
        CreatePowerForecastJobRequest createPowerForecastJobRequest = CreatePowerForecastJobRequest.builder()
                .historyData(history)
                .systemType("solar")
                .deviceType("solarInverter")
                .duration(2)
                .location(CreatePowerForecastJobRequest.Location.builder().longitude(100.0).latitude(40.0).build())
                .runDate("2025-04-01")
                .build();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                try {
                    testPowerForecastAsync(createPowerForecastJobRequest);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }


        public static void testPowerForecastAsync(CreatePowerForecastJobRequest createPowerForecastJobRequest) throws Exception{
        AsyncClient client = createClientAsync();
        try {

            CompletableFuture<CreatePowerForecastJobResponse> response = client.createPowerForecastJob(createPowerForecastJobRequest);
            // Synchronously get the return value of the API request
            CreatePowerForecastJobResponse resp = response.get();
            // 打印当前时间格式为 '%Y-%m-%d %H:%m:%s
            LocalDateTime now = LocalDateTime.now();
            String formattedTime = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            System.out.println("[" + formattedTime + "]" + new Gson().toJson(resp.getBody()));
            // 复制代码运行请自行打印 API 的返回值
        } catch (TeaException error) {
            // 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
            // 错误 message
            System.out.println(error.getMessage());
        }
    }

    public static AsyncClient createClientAsync() throws Exception {
      // 建议使用更安全的 STS 方式，更多鉴权访问方式请参见：https://help.aliyun.com/document_detail/378657.html。
        StaticCredentialProvider provider = StaticCredentialProvider.create(Credential.builder()
                // Please ensure that the environment variables ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set.
                .accessKeyId(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"))
                .accessKeySecret(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"))
                //.securityToken(System.getenv("ALIBABA_CLOUD_SECURITY_TOKEN")) // use STS token
                .build());

        // Configure the Client
        AsyncClient client = AsyncClient.builder()
                .region("cn-hangzhou") // Region ID
                //.httpClient(httpClient) // Use the configured HttpClient, otherwise use the default HttpClient (Apache HttpClient)
                .credentialsProvider(provider)
                //.serviceConfiguration(Configuration.create()) // Service-level configuration
                // Client-level configuration rewrite, can set Endpoint, Http request parameters, etc.
                .overrideConfiguration(
                        ClientOverrideConfiguration.create()
                                // Endpoint 请参考 https://api.aliyun.com/product/brain-industrial
                                .setEndpointOverride("brain-industrial.cn-hangzhou.aliyuncs.com")
                                .setConnectTimeout(Duration.ofSeconds(30))
                )
                .build();
        return client;
    }
}

Python SDK使用示例

Python依赖：

pip install alibabacloud_brain_industrial20200920==2.1.0

# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
import os
import sys

from typing import List

from alibabacloud_brain_industrial20200920.client import Client as brain_industrial20200920Client
from alibabacloud_tea_openapi import models as open_api_models
from alibabacloud_brain_industrial20200920 import models as brain_industrial_20200920_models
from alibabacloud_tea_util import models as util_models
from alibabacloud_tea_util.client import Client as UtilClient


class Sample:
    def __init__(self):
        pass

    @staticmethod
    def create_client() -> brain_industrial20200920Client:
        """
        使用AK&SK初始化账号Client
        @return: Client
        @throws Exception
        """
        # 工程代码泄露可能会导致 AccessKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考。
        # 建议使用更安全的 STS 方式，更多鉴权访问方式请参见：https://help.aliyun.com/document_detail/378659.html。
        config = open_api_models.Config(
            # 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_ID。,
            access_key_id=os.environ['ALIBABA_CLOUD_ACCESS_KEY_ID'],
            # 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_SECRET。,
            access_key_secret=os.environ['ALIBABA_CLOUD_ACCESS_KEY_SECRET']
        )
        # Endpoint 请参考 https://api.aliyun.com/product/brain-industrial
        config.endpoint = f'brain-industrial.cn-hangzhou.aliyuncs.com'
        return brain_industrial20200920Client(config)

    @staticmethod
    def main(
        args: List[str],
    ) -> None:
        client = Sample.create_client()
        create_power_forecast_job_request = brain_industrial_20200920_models.CreatePowerForecastJobRequest()
        runtime = util_models.RuntimeOptions()
        try:
            # 复制代码运行请自行打印 API 的返回值
            client.create_power_forecast_job_with_options(create_power_forecast_job_request, runtime)
        except Exception as error:
            # 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
            # 错误 message
            print(error.message)
            # 诊断地址
            print(error.data.get("Recommend"))
            UtilClient.assert_as_string(error.message)

    @staticmethod
    async def main_async(
        args: List[str],
    ) -> None:
        client = Sample.create_client()
        create_power_forecast_job_request = brain_industrial_20200920_models.CreatePowerForecastJobRequest()
        runtime = util_models.RuntimeOptions()
        try:
            # 复制代码运行请自行打印 API 的返回值
            await client.create_power_forecast_job_with_options_async(create_power_forecast_job_request, runtime)
        except Exception as error:
            # 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
            # 错误 message
            print(error.message)
            # 诊断地址
            print(error.data.get("Recommend"))
            UtilClient.assert_as_string(error.message)


if __name__ == '__main__':
    Sample.main(sys.argv[1:])