百度AI接口对接

最新推荐文章于 2024-05-29 17:36:37 发布
最新推荐文章于 2024-05-29 17:36:37 发布
阅读量1.1k 收藏 5
点赞数 1
分类专栏： 技术宝典 文章标签： 百度 人工智能 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45081813/article/details/129446866
版权

文章目录

一.在百度智能云申请获取APIKey和SecretKey

baidu:
  ai:
    APIKey: xxxxxxx
    SecretKey: xxxxxxxx

二.基础工具类

1.获取访问token工具类

//通过APIKey和SecretKey获取

@Slf4j
public class BaiduAiAuthUtil {

    // 参考：https://ai.baidu.com/ai-doc/REFERENCE/Ck3dwjhhu

    /**
     * 获取API访问token
     * 该token有一定的有效期，需要自行管理，当失效时需重新获取.
     *
     * @param ak - 百度云官网获取的 API Key
     * @param sk - 百度云官网获取的 Secret Key
     * @return assess_token 示例：
     * {
     * "access_token": "24.460da4889caad24cccdb1fea17221975.2592000.1491995545.282335-1234567",
     * "expires_in": 2592000
     * }
     */
    public static String getAuth(String ak, String sk) {
        // 获取token地址
        String authHost = "https://aip.baidubce.com/oauth/2.0/token?";
        String getAccessTokenUrl = authHost
                // 1. grant_type为固定参数
                + "grant_type=client_credentials"
                // 2. 官网获取的 API Key
                + "&client_id=" + ak
                // 3. 官网获取的 Secret Key
                + "&client_secret=" + sk;
        try {
            URL realUrl = new URL(getAccessTokenUrl);
            // 打开和URL之间的连接
            HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
            connection.setRequestMethod("GET");
            connection.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : map.keySet()) {
                System.err.println(key + "--->" + map.get(key));
            }
            // 定义 BufferedReader输入流来读取URL的响应
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String result = "";
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
            /**
             * 返回结果示例
             */
            System.err.println("result:" + result);
            JSONObject jsonObject = new JSONObject(result);
            String access_token = jsonObject.getString("access_token");
            return access_token;
        } catch (Exception e) {
            log.error("获取token失败！错误原因：{}", e.getMessage());
            e.printStackTrace(System.err);
        }
        return null;
    }

}

存redis中

    public String getBaiDuAuth() {
        String auth = (String) redisTemplate.opsForValue().get(BAIDU_AI_IMAGE_ASSESS_TOKEN_KEY);
        if (StringUtils.isBlank(auth)) {
            auth = BaiduAiAuthUtil.getAuth(APIKey, SecretKey);
            if (StringUtils.isNotBlank(auth)) {
                // 官方返回30天过期，考虑延迟，缓存时长减少一小时
                redisTemplate.opsForValue().set(BAIDU_AI_IMAGE_ASSESS_TOKEN_KEY, auth, 2592000 - 3600, TimeUnit.SECONDS);
            }
        }
        return auth;
    }

2.Base64转换工具类

/**
 * Base64 工具类
 */
public class Base64Util {
    private static final char last2byte = (char) Integer.parseInt("00000011", 2);
    private static final char last4byte = (char) Integer.parseInt("00001111", 2);
    private static final char last6byte = (char) Integer.parseInt("00111111", 2);
    private static final char lead6byte = (char) Integer.parseInt("11111100", 2);
    private static final char lead4byte = (char) Integer.parseInt("11110000", 2);
    private static final char lead2byte = (char) Integer.parseInt("11000000", 2);
    private static final char[] encodeTable = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};

    public Base64Util() {
    }

    public static String encode(byte[] from) {
        StringBuilder to = new StringBuilder((int) ((double) from.length * 1.34D) + 3);
        int num = 0;
        char currentByte = 0;

        int i;
        for (i = 0; i < from.length; ++i) {
            for (num %= 8; num < 8; num += 6) {
                switch (num) {
                    case 0:
                        currentByte = (char) (from[i] & lead6byte);
                        currentByte = (char) (currentByte >>> 2);
                    case 1:
                    case 3:
                    case 5:
                    default:
                        break;
                    case 2:
                        currentByte = (char) (from[i] & last6byte);
                        break;
                    case 4:
                        currentByte = (char) (from[i] & last4byte);
                        currentByte = (char) (currentByte << 2);
                        if (i + 1 < from.length) {
                            currentByte = (char) (currentByte | (from[i + 1] & lead2byte) >>> 6);
                        }
                        break;
                    case 6:
                        currentByte = (char) (from[i] & last2byte);
                        currentByte = (char) (currentByte << 4);
                        if (i + 1 < from.length) {
                            currentByte = (char) (currentByte | (from[i + 1] & lead4byte) >>> 4);
                        }
                }

                to.append(encodeTable[currentByte]);
            }
        }

        if (to.length() % 4 != 0) {
            for (i = 4 - to.length() % 4; i > 0; --i) {
                to.append("=");
            }
        }

        return to.toString();
    }
}

3.文件转换工具类

/**
 * 文件读取工具类
 */
public class FileUtil {

    /**
     * 读取文件内容，作为字符串返回
     */
    public static String readFileAsString(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            throw new FileNotFoundException(filePath);
        }

        if (file.length() > 1024 * 1024 * 1024) {
            throw new IOException("File is too large");
        }

        StringBuilder sb = new StringBuilder((int) (file.length()));
        // 创建字节输入流  
        FileInputStream fis = new FileInputStream(filePath);
        // 创建一个长度为10240的Buffer
        byte[] bbuf = new byte[10240];
        // 用于保存实际读取的字节数  
        int hasRead = 0;
        while ((hasRead = fis.read(bbuf)) > 0) {
            sb.append(new String(bbuf, 0, hasRead));
        }
        fis.close();
        return sb.toString();
    }

    /**
     * 根据文件路径读取byte[] 数组
     */
    public static byte[] readFileByBytes(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            throw new FileNotFoundException(filePath);
        } else {
            ByteArrayOutputStream bos = new ByteArrayOutputStream((int) file.length());
            BufferedInputStream in = null;

            try {
                in = new BufferedInputStream(new FileInputStream(file));
                short bufSize = 1024;
                byte[] buffer = new byte[bufSize];
                int len1;
                while (-1 != (len1 = in.read(buffer, 0, bufSize))) {
                    bos.write(buffer, 0, len1);
                }

                byte[] var7 = bos.toByteArray();
                return var7;
            } finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                } catch (IOException var14) {
                    var14.printStackTrace();
                }

                bos.close();
            }
        }
    }


    /**
     * 将Url转换为File
     *
     * @param url
     * @return
     * @throws Exception
     */
    public static File urlToFile(String url) throws Exception {
        HttpURLConnection httpUrl = (HttpURLConnection) new URL(url).openConnection();
        httpUrl.connect();
        InputStream ins = httpUrl.getInputStream();
        //System.getProperty("java.io.tmpdir")缓存
        File file = new File(System.getProperty("java.io.tmpdir") + File.separator + "xie");
        if (file.exists()) {
            //如果缓存中存在该文件就删除
            file.delete();
        }
        OutputStream os = new FileOutputStream(file);
        int bytesRead;
        int len = 8192;
        byte[] buffer = new byte[len];
        while ((bytesRead = ins.read(buffer, 0, len)) != -1) {
            os.write(buffer, 0, bytesRead);
        }
        os.close();
        ins.close();
        return file;
    }

    /**
     * 将File对象转换为byte[]的形式
     *
     * @param file
     * @return
     */
    public static byte[] fileToByte(File file) {
        FileInputStream fileInputStream = null;
        byte[] imgData = null;

        try {
            imgData = new byte[(int) file.length()];
            //read file into bytes[]
            fileInputStream = new FileInputStream(file);
            fileInputStream.read(imgData);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return imgData;
    }

}

4.Http工具类

/**
 * http 工具类
 */
public class HttpUtil {

    public static String post(String requestUrl, String accessToken, String params)
            throws Exception {
        String contentType = "application/x-www-form-urlencoded";
        return HttpUtil.post(requestUrl, accessToken, contentType, params);
    }

    public static String post(String requestUrl, String accessToken, String contentType, String params)
            throws Exception {
        String encoding = "UTF-8";
        if (requestUrl.contains("nlp")) {
            encoding = "GBK";
        }
        return HttpUtil.post(requestUrl, accessToken, contentType, params, encoding);
    }

    public static String post(String requestUrl, String accessToken, String contentType, String params, String encoding)
            throws Exception {
        String url = requestUrl + "?access_token=" + accessToken;
        return HttpUtil.postGeneralUrl(url, contentType, params, encoding);
    }

    public static String postGeneralUrl(String generalUrl, String contentType, String params, String encoding)
            throws Exception {
        URL url = new URL(generalUrl);
        // 打开和URL之间的连接
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        // 设置通用的请求属性
        connection.setRequestProperty("Content-Type", contentType);
        connection.setRequestProperty("Connection", "Keep-Alive");
        connection.setUseCaches(false);
        connection.setDoOutput(true);
        connection.setDoInput(true);

        // 得到请求的输出流对象
        DataOutputStream out = new DataOutputStream(connection.getOutputStream());
        out.write(params.getBytes(encoding));
        out.flush();
        out.close();

        // 建立实际的连接
        connection.connect();
        // 获取所有响应头字段
        Map<String, List<String>> headers = connection.getHeaderFields();
        // 遍历所有的响应头字段
        for (String key : headers.keySet()) {
            System.err.println(key + "--->" + headers.get(key));
        }
        // 定义 BufferedReader输入流来读取URL的响应
        BufferedReader in = null;
        in = new BufferedReader(
                new InputStreamReader(connection.getInputStream(), encoding));
        String result = "";
        String getLine;
        while ((getLine = in.readLine()) != null) {
            result += getLine;
        }
        in.close();
        System.err.println("result:" + result);
        return result;
    }
}

三.图片识别

图片识别工具类

@Slf4j
public class BaiduAiImageUtil {

    // 参考：https://ai.baidu.com/ai-doc/IMAGERECOGNITION/Xk3bcxe21

    /**
     * 重要提示代码中所需工具类
     * FileUtil,Base64Util,HttpUtil,GsonUtils请从
     * https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72
     * https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2
     * https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3
     * https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3
     * 下载
     */
     //图片为文件格式
    public static String advancedGeneralByImage(MultipartFile file, String accessToken) {
        if (ObjectUtil.isEmpty(file) || StringUtils.isAnyBlank(accessToken)) {
            return null;
        }
        // 请求url
        String url = "https://aip.baidubce.com/rest/2.0/image-classify/v2/advanced_general";
        try {
            byte[] imgData = file.getBytes();
            String imgStr = Base64Util.encode(imgData);
            String imgParam = URLEncoder.encode(imgStr, "UTF-8");

            String param = "image=" + imgParam;

            String result = HttpUtil.post(url, accessToken, param);

            log.info("上传图片：{}，AI图像识别结果：{}", file, result);
            return result;
        } catch (Exception e) {
            log.error("AI图像识别错误！错误原因：{}", e.getMessage());
            e.printStackTrace(System.err);
        }
        return null;
    }

 	//图片为URL格式
    public static String advancedGeneralByUrl(String remoteUrl, String accessToken) {
        if (StringUtils.isAnyBlank(remoteUrl, accessToken)) {
            return null;
        }
        // 请求url
        String url = "https://aip.baidubce.com/rest/2.0/image-classify/v2/advanced_general";
        try {
            String urlParam = URLEncoder.encode(remoteUrl, "UTF-8");

            String param = "url=" + urlParam;

            String result = HttpUtil.post(url, accessToken, param);

            log.info("oss图片链接：{}，AI图像识别结果：{}", remoteUrl, result);
            return result;
        } catch (Exception e) {
            log.error("AI图像识别错误！错误原因：{}", e.getMessage());
            e.printStackTrace(System.err);
        }
        return null;
    }

}

接口

    /**
     * ai垃圾分类-图像识别
     *
     * @param file 图像文件
     * @return Result<ComClassificationRespDTO>
     */
    @PostMapping(value = {"/image"})
    public Result<List<AiRespDTO>> aiImage(@RequestParam("file") MultipartFile file) {
        return success(iAiClassifyRecordService.aiImageV2(file));
    }

实现类

	@SneakyThrows
    @Override
    public List<ComClassificationRespDTO> aiImageV2(MultipartFile file) {
        // 获取.后缀名
        String ext = checkExt(file);
        byte[] bytes = file.getBytes();
        String encode = Base64.getEncoder().encodeToString(bytes);
        String auth = getBaiDuAuth();
        String aiResult = BaiduAiImageUtil.advancedGeneralByImage(file, auth);
        AiImageResponse aiImageResponse=JSONObject.parseObject(aiResult, AiImageResponse.class);
        //拿取关键词
        List<AiImageResult> result = aiImageResponse.getResult();
    }

百度接口数据返回格式

@Data
public class AiImageResponse {

    // 参考：https://ai.baidu.com/ai-doc/IMAGERECOGNITION/Xk3bcxe21
    /**
     * 唯一的log id，用于问题定位
     */
    private String log_id;

    /**
     * 返回结果数目，及result数组中的元素个数，最多返回5个结果
     */
    private String result_num;

    /**
     * 标签结果数组
     */
    private List<AiImageResult> result;
}

@Data
public class AiImageResult {

    // 参考：https://ai.baidu.com/ai-doc/IMAGERECOGNITION/Xk3bcxe21
    /**
     * 置信度，0-1
     */
    private float score;

    /**
     * 识别结果的上层标签，有部分钱币、动漫、烟酒等tag无上层标签
     */
    private String root;

    /**
     * 图片中的物体或场景名称
     */
    private String keyword;
}

检查图片格式

    public String checkExt(MultipartFile file) {
        String ext = FilenameUtils.getExtension(file.getOriginalFilename());
        if ("jpg".equals(ext) || "png".equals(ext) || "bmp".equals(ext) || "jpeg".equals(ext)) {
            return ext;
        } else {
            throw new ScException("只支持'jpg','png','bmp','jpeg'格式的图像文件");
        }
    }

四.语音识别

语音识别工具类

@Slf4j
public class BaiduAiVoiceUtil {

    // 参考：https://ai.baidu.com/ai-doc/SPEECH/jkhq0ohzz

    static final okhttp3.OkHttpClient HTTP_CLIENT = new okhttp3.OkHttpClient().newBuilder().build();

    /**
     * 语音识别
     */
    public static String advancedGeneral(String remoteUrl, String userId, String accessToken, String ext) {
        if (StringUtils.isAnyBlank(remoteUrl, userId, accessToken, ext)) {
            return null;
        }
        // 请求url
        String url = "https://vop.baidu.com/pro_api";
        try {
            File file = FileUtil.urlToFile(remoteUrl);
            int length = (int) file.length();
            byte[] voiceData = FileUtil.fileToByte(file);
            String voiceStr = Base64Util.encode(voiceData);

            AiVoiceRequest aiVoiceRequest = new AiVoiceRequest();
            aiVoiceRequest.setFormat(ext);
            aiVoiceRequest.setCuid(userId);
            aiVoiceRequest.setToken(accessToken);
            aiVoiceRequest.setSpeech(voiceStr);
            aiVoiceRequest.setLen(length);

            MediaType mediaType = MediaType.parse("application/json");
            // speech 可以通过 getFileContentAsBase64("C:\fakepath\Skype_Notification.m4a") 方法获取
            okhttp3.RequestBody body = okhttp3.RequestBody.create(mediaType, new JSONObject(aiVoiceRequest).toString());
            Request request = new Request.Builder()
                    .url(url)
                    .method("POST", body)
                    .addHeader("Content-Type", "application/json")
                    .addHeader("Accept", "application/json")
                    .build();
            okhttp3.Response response = HTTP_CLIENT.newCall(request).execute();
            String result = response.body().string();
            log.info("oss音频链接：{}，AI语音识别结果：{}", remoteUrl, result);
            return result;
        } catch (Exception e) {
            log.error("AI语音识别错误！错误原因：{}", e.getMessage());
            e.printStackTrace(System.err);
        }
        return null;
    }

    /**
     * 获取文件base64编码
     *
     * @param path 文件路径
     * @return base64编码信息，不带文件头
     * @throws IOException IO异常
     */
    static String getFileContentAsBase64(String path) throws IOException {
        byte[] b = Files.readAllBytes(Paths.get(path));
        return Base64.getEncoder().encodeToString(b);
    }

}

接口

    /**
     * ai垃圾分类-语音识别
     * @param bean 条件
     * @return Result<ComClassificationRespDTO>
     */
    @PostMapping(value = {"/voice"}, produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public List<ComClassificationRespDTO> aiVoice(@RequestBody @Validated AiClassifyRecordQueryDTO bean) {
        return iAiClassifyRecordService.aiVoiceV2(bean);
    }

实现类

public ComClassificationRespDTO aiVoice(MultipartFile file, Integer type) {
        String curUid = Context.getUserID;
        // 获取.后缀名
        String ext = this.getAndCheckExt(file);
        // 获取远程链接
        String remoteUrl = this.uploadFile(file);
        if (StringUtils.isBlank(remoteUrl)) {
            throw new ScException(RespCode.UPLOAD_FILE_FAILED);
        }
        String auth = getBaiDuAuth();
        String aiResult = BaiduAiVoiceUtil.advancedGeneral(remoteUrl, curUid, auth, ext);
        AiVoiceResponse aiVoiceResponse = JSONObject.parseObject(aiResult, AiVoiceResponse.class);
        List<String> result = aiVoiceResponse.getResult();

	    return null;
}

百度语音识别接口返回数据格式

@Data
public class AiVoiceResponse {

    // 参考：https://ai.baidu.com/ai-doc/SPEECH/Ykhq0pqq8
    /**
     * 错误码
     */
    private String err_no;

    /**
     * 错误码描述
     */
    private String err_msg;

    /**
     * 语音数据唯一标识，系统内部产生。如果反馈及debug请提供sn。
     */
    private String sn;

    /**
     * 识别结果数组，返回1个最优候选结果。utf-8 编码。
     */
    private List<String> result;
}

百度语音识别接口请求入参数据格式

@Data
public class AiVoiceRequest {

    // 参考：https://ai.baidu.com/ai-doc/SPEECH/Ikhq0parc
    /**
     * 语音文件的格式，pcm/wav/amr/m4a。不区分大小写。推荐pcm文件
     */
    private String format;

    /**
     * 采样率，16000，固定值
     */
    private Integer rate = 16000;

    /**
     * 声道数，仅支持单声道，请填写固定值 1
     */
    private Integer channel = 1;

    /**
     * 用户唯一标识，用来区分用户，计算UV值。建议填写能区分用户的机器 MAC 地址或 IMEI 码，长度为60字符以内。
     */
    private String cuid;

    /**
     * 开放平台获取到的开发者[access_token]获取 Access Token "access_token")
     */
    private String token;

    /**
     * 80001（极速版输入法模型）
     */
    private Integer dev_pid = 80001;

    /**
     * 本地语音文件的的二进制语音数据 ，需要进行base64 编码。与len参数连一起使用。
     */
    private String speech;

    /**
     * 本地语音文件的的字节数，单位字节
     */
    private Integer len;
}

检查语音格式

    public String getAndCheckExt(MultipartFile file) {
        String ext = FilenameUtils.getExtension(file.getOriginalFilename());
        if ("pcm".equals(ext) || "wav".equals(ext) || "amr".equals(ext) || "m4a".equals(ext)) {
            return ext;
        } else {
            throw new ScException("只支持'pcm','wav','amr','m4a'格式的音频文件");
        }
    }
BlogY
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
鸿蒙HarmonyOS开发实战—AI功能开发（分词）_如何调用鸿蒙系统的ai接口(1)
2401_84182097的博客
04-14 1026
static int | REQUEST_TYPE_LOCAL = 0，本地请求。
图形识别工具-百度AI接口实现
sxl123123123的博客
02-14 809
简介：借出百度AI平台后看到有一个图像识别工具，就简单实现了下，效果挺好的，使用也简单。 百度提供了两种实现方式： 1.api方式调用； 2.sdk方式调用（此方式简单，本文就以此为主讲一下） a. 先下载图像识别sdk 地址：https://cloud.baidu.com/doc/IMAGERECOGNITION/index.html b. 解压缩后拷贝到项目中，按照规范进行开发...
快速调用百度AI开放平台的API，以OCR通用文字识别为例（封装函数进行连续调用）
荆鹏的博客
09-07 3943
（最新保姆级教程）百度开放平台允许开发者访问和利用百度的各种服务和功能，包括语音识别、人脸识别、文字识别、自然语言处理等等。这些API能够满足我们绝大部分需求，来供我们学习和使用。本文就OCR文字识别为例，详细介绍新手小白如何调用百度开放平台的API。
百度ai平台接口使用记录
TranSad的博客
04-30 4075
前一段时间在做毕业设计，打算做一些风格转换相关的项目，想自己制作一份数据集用于训练，于是发现了百度ai平台提供的api接口可以实现“人脸动漫化”、“图像风格转换”等功能。按照一定步骤操作后，只要通过post请求就可以将本地的图片进行风格转换了。感觉还不错，比直接使用现有数据集好多了，起码数据质量上可以自己保证~ 当然按照教程来做也非常简单，不过还是做个记录，下次就不用研究教程了。 记录一下操作步骤： 打开百度ai的平台： 里面有很多功能，我使用的图像转换和人脸动漫化（其实都差不多）...
项目实训——AI接口
最新发布
XZH_iD的博客
05-29 1137
Prompt，指的是给定给AI系统的一段文本信息或指令，其目的是引导或激发AI模型产生特定的输出或执行相应的操作。市面上有许多第三方网站提供AI服务，这些网站的一大优势是精简了调用AI的流程，可以自由设置智能体提前设定问答的角色，有的网站甚至提供了SDK可以直接调用AI。在实际测试中，我们小组发现，大多数AI服务方提供的免费方案使用的都是较为落后的模型，如GLM3甚至GLM2，经过测试，这些落后模型无法满足要求。按照Prompt要求的格式传入数据，调用AI方法，向通义千问传递发送请求，得到数据。
前端js调用百度翻译api接口
m0_46043168的博客
02-12 2804
js调用百度翻译api接口
百度AI开放平台 OCR调用与 open api qps result limit reached error code 18
bitcarmanlee的博客
06-29 793
上面的错误提示显示是qps调用超出了上限，但是很明显，我们就一个java代码，应该不存在说qps太大超过上限的问题。先在开放平台注册完毕，并创建一个应用，得到AppID, API Key, Secret Key等参数。最近项目中要使用到OCR功能，发现百度AI开放平台这部分能力比较强，于是注册账号并调用相关API。经过搜索发现，是我们在创建应用的时候，还需要主动去领取免费的额度！如上图，有个领取免费资源的按钮，点击该按钮领取即可。等上述准备工作就绪，开始测试OCR相关的功能模块。
基于QT、ARM开发板、Linux系统并对接百度AI的停车管理系统
01-02
4. **AI（人工智能）**：对接百度AI可能指的是利用百度提供的智能技术服务，如图像识别。在停车管理场景下，通过摄像头捕获车牌信息，然后运用AI算法进行车牌识别，实现自动放行和计费功能。 5. **C语言**：作为...
百度语音合成接口.zip
07-28
百度语音合成为一项基于人工智能技术的服务，它允许开发者将文本转换为自然流畅的语音输出，广泛应用在各种场景，如智能助手、在线教育、有声读物等。此压缩包文件"百度语音合成接口.zip"提供了与百度智能云的语音...
微信小程序图像识别源码，微信小程序百度AI接口源码，微信小程序图片上传显示缩放缩略图,人工智能，图像识别，人脸颜值分析，植物
02-21
本文将详细讲解基于微信小程序开发的图像识别技术，结合了人工智能和百度AI接口，实现了一系列功能，如图片上传、显示缩略图、图像识别、人脸颜值分析以及多种对象的识别。我们将深入探讨这些关键技术点，并提供相关...
PHP利用百度ai实现文本和图片审核
10-17
首先，我们需要了解的是，百度AI提供了一系列的API接口，可以帮助开发者进行内容审核，包括文本审查和图像识别，以检测潜在的违规或不适宜内容。 **一、文本审核** 1. **注册和获取API密钥** 在开始之前，你需要...
百度API接口实例
12-09
使用DemoSite需要先修改： 1.修改web.config文件appSettings节点下的api_key、secret_key的值。 2.修改Default.aspx.cs、callback.aspx.cs中"http://wxz.com:12146/callback.aspx"为你应用中callback.aspx页面所在的实际地址。
C#调用百度人脸识别源码
12-28
总的来说，"C#调用百度人脸识别源码"项目涉及到了C#编程、计算机视觉、人工智能、网络通信等多个领域的知识。通过这个项目，开发者不仅可以学习到如何整合不同技术栈，还能深入了解人脸识别技术的工作原理及其在实际...
百度地图接口调用
qq_50854662的博客
08-23 2025
百度地图接口调用
百度API接口研究01-介绍及概述
图灵追幕者博客录
12-20 3580
简单概述： 论起人工智能的研究，BAT应该都是国内的佼佼者。尤其是百度公司，开放了API接口供大家研究学习用，里面的模块功能很全，虽然每天有次数限制，但是对于体验者来说还是非常不错的。在工作中，有时候急切需要解决某一类问题，花大量的时间去研究又来不及的话，调用现成的百度API接口是个报错的选择。最近工作不是那么忙，所以准备静下心来好好研究一下百度API相关的调用。 百度API平台地址：https://ai.baidu.com/ 首页界面： 常见的...
百度map 3.0初探
xiangzhihong8的专栏
07-09 1492
1.简介     在使用百度地图SDK为您提供的各种LBS能力之前，您需要获取百度地图移动版的开发密钥，该密钥与您的百度账户相关联。因此，您必须先有百度帐户，才能获得开发密钥。并且，该密钥与您创建的过程名称有关，具体流程请参考如下介绍。     Key的申请地址为：http://lbsyun.baidu.com/apiconsole/key     注意：     1. 为了给用户提供更安
API接口智能化测试探索与实践
zouhui1003it的专栏
12-23 476
导读：API接口自动化测试在服务端分层测试体系中占有重要地位，在持续追求提升研发交付效能的背景下，传统的自动化测试工具面临质量与效率的更高挑战。智能化测试的本质是利用数据和算法相结合赋能质...
百度API连接
Rory898863935的博客
02-11 3267
百度API连接分为两步：1、使用API key和secret key获取token2、连接调用方法。1、获取token。 public static String getAuth() { // 官网获取的 API Key 更新为你注册的 String clientId = "XP8YaCKuqZW7GIfEf05iFa"; // 官网获取的 Secr...
python程序能够免费对接国内AI接口的平台有哪些？给出flask程序对接示例代码
07-13
下面是一个使用Flask框架对接阿里云人工智能接口的示例代码： ```python from flask import Flask, jsonify, request import requests app = Flask(__name__) @app.route('/api/ai', methods=['POST']) def ai_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值