东哥教你如何用Orange Ai pro为家里做一个垃圾分类检测机器

简介: ## 摘要本文由东哥原创,介绍了使用Orange AI Pro开发板进行AI项目开发的体验。这款开发板主打强大的AI算力,搭载昇腾AI芯片,提供8-12TOPS的性能,媲美英伟达RTX3080显卡。它支持外接eMMC和4K显示器,适合实时视频流模型部署。作者详细阐述了从购买、烧录镜像到环境配置的过程,包括安装ACLLite库、模型转换工具ATC的使用,以及YOLOv5模型的转换和部署。文章还展示了如何建立一个垃圾检测项目,利用计算机视觉进行实时垃圾分类,并分享了性能体验,认为开发板在散热和噪音控制上表现良好,适合AI爱好者和开发者进行DIY项目。

说明

本文为东哥原创,东哥科技,畅想未来科技,官方网站:www.dgstudyblog.top

前言

最近入手了一块香橙派(Orange Ai Pro)的板子,他们的口号是:为AI而生,这让一个算法工程师按捺不住了, 之前主要是在RKNN和ESP32等设备上部署AI模型,看到官方介绍的强大AI算力,很想知道能否满足工作生活中的实时视频流模型部署,也为未来公司的战略部署多做一份准备。

AIpro是一款采用昇腾AI技术路线的强大开发板,配备4核64位处理器, 8GB的LPDDR4X内存,就足以满足大部分的AI推理应用场景,AI Pro 配备8TOPS-12TOPS的AI算力,相当于英伟达的RTX3080显卡,同时很多车企早期L2级自动驾驶的算力需求也才2-2.5TOPS,所以在AI 算力方面完全是充足的。

同时开发板支持外接eMMC模块,从32GB到256GB, 充足的存储空间能够满足日常开发所需。

AI Pro还支持外接4K的高清显示器,能够利用HDMI帮我们更好的可视化操作,大大提升了开发体验,只需要自带一个小的显示屏,便可以做一台便携mini电脑。

更多的开发板信息可以参考下面的这个硬件配置图

准备

  1. 一块Orange Ai Pro
  2. 相关的硬件资料可参考:Orange Ai Pro 介绍和应用
  3. 购买地址: 淘宝京东
  4. 一个USB 摄像头
  5. 主要用于实时检测素材
  6. 外接鼠标、键盘

  7. 显示器

  8. 用于可视化操作Orange Ai Pro

    镜像烧录

    需要下载官方的烧录工具, 将镜像烧录到存储卡内,官方镜像地址:下载地址

    开机登录

    接好设备后,就可以点击开机按钮, 我这边的设备主要是1个摄像头,1块32G的存储卡,系统这边用的是Ubuntu系统,比较适合个人的习惯

环境准备

配置编译依赖的头文件与库文件路径

export DDK_PATH=/usr/local/Ascend/ascend-toolkit/latest 
export NPU_HOST_LIB=$DDK_PATH/runtime/lib64/stub

安装ACLLite库和ffmpeg

Tips: ACLLite是必备的库文件

apt-get install ffmpeg libavcodec-dev libswscale-dev libavdevice-dev

获取ACLLite 源码

git clone https://gitee.com/ascend/ACLLite.git

进入到项目目录进行编译, 会编译到上面设置的lib 目录

bash build_so.sh

到这里环境的基本配置已经完成了,接下来就是代码的准备和编译了

官方的Ai Demo项目

git clone https://gitee.com/ascend/EdgeAndRobotics.git

这是官方提供的sample demo ,里面有基础的图像检测,分类,人脸识别等demo,可以帮助我们快速上手,同时也适合在源码上根据需要进行二次修改。

模型转换

Orange Ai pro 需要的是.om的格式,我们需要把pt 的模型转成onnx 再利用平台的 Atc工具转成.om的格式

什么是ATC
昇腾张量编译器(Ascend Tensor Compiler,简称ATC)是昇腾CANN架构体系下的模型转换工具,类似RKNN或hisi 都有自己处理器需要的模型格式,CANN架构也不例外。

  • 它可以将开源框架的网络模型(例如TensorFlow、ONNX等)转换为昇腾AI处理器支持的模型文件(.om格式),用于后续的模型推理
  • 它可以将基于Ascend IR定义的单算子描述文件(*.json格式)转换为昇腾AI处理器支持的模型文件(.om格式),后续在整网中验证算子功能

如何转换

atc --model=yolov5s.onnx --framework=5 --output=yolov5s --input_shape="images:1,3,640,640"  --soc_version=Ascend310B4  --insert_op_conf=aipp.cfg

--framework:原始网络模型框架类型,5表示onnx。
--soc_version:模型转换时昇腾AI处理器的版本,例如Ascend310B1。
--model:原始网络模型文件,含扩展名。
--weight:原始网络模型权重文件路径,含文件名,仅当原始网络模型是Caffe时需要指定。
--output:转换后的*.om模型文件路径,含文件名,转换成功后,模型文件名自动以.om后缀结尾
--insert_op_conf: 模型相关的配置文件,包含图像大小,预处理等参数

tips: 内存小于8G最好将atc 的进程数减少,否则转换可能会报错

export TE_PARALLEL_COMPILER=1
export MAX_COMPILE_CORE_NUMBER=1

你也可以下载官方的yolov5 模型

#下载yolov5s的模型和转换模型
wget https://obs-9be7.obs.cn-east-2.myhuaweicloud.com/003_Atc_Models/yolov5s/yolov5s.onnx --no-check-certificate
wget https://obs-9be7.obs.cn-east-2.myhuaweicloud.com/003_Atc_Models/yolov5s/aipp.cfg --no-check-certificate

搭建Orange Ai Pro 垃圾检测项目

项目说明

项目的重点是利用计算机视觉技术,外接摄像头进行实时检测,对生活中的垃圾进行检测分类,辅助人们进行垃圾的投递,提升垃圾回收效率。

在这里插入图片描述
在这里插入图片描述

数据集
我这里是利用了之前公司做的垃圾分类数据集训练的垃圾分类模型,训练数据总共19000张,验证集3000张,准确率92%。

模型
利用yolov5 原有基础上进行模型的搭建,修改了核心的backbone, 加入了注意力机制。

class SE(nn.Module):
    def __init__(self, c1, c2, ratio=16):
            super(SE, self).__init__()
                    #c*1*1
                            self.avgpool = nn.AdaptiveAvgPool2d(1)
                                    self.l1 = nn.Linear(c1, c1 // ratio, bias=False)
                                            self.relu = nn.ReLU(inplace=True)
                                                    self.l2 = nn.Linear(c1 // ratio, c1, bias=False)
                                                            self.sig = nn.Sigmoid()
                                                                def forward(self, x):
                                                                        b, c, _, _ = x.size()
                                                                                y = self.avgpool(x).view(b, c)
                                                                                        y = self.l1(y)
                                                                                                y = self.relu(y)
                                                                                                        y = self.l2(y)
                                                                                                                y = self.sig(y)
                                                                                                                        y = y.view(b, c, 1, 1)
                                                                                                                                return x * y.expand_as(x)
                                                                                                                            **模型部署**
                                                                                                                            在源码demo中,基于 YOLOV5USBCamera 项目进行修改,基本上官方已经很好的把模型的加载和推理等模块,基于这个项目进行修改部署。
                                                                                                                            ```c
                                                                                                                            class sampleYOLOV7(object):
                                                                                                                                '''load the model, and do preprocess, infer, postprocess'''
                                                                                                                                    def __init__(self, model_path, model_width, model_height):
                                                                                                                                            self.model_path = model_path
                                                                                                                                                    self.model_width = model_width
                                                                                                                                                            self.model_height = model_height

                                                                                                                                                                def init_resource(self):
                                                                                                                                                                        # initial acl resource, create image processor, create model
                                                                                                                                                                                self._resource = AclLiteResource()
                                                                                                                                                                                        self._resource.init()

                                                                                                                                                                                                    self._dvpp = AclLiteImageProc(self._resource) 
                                                                                                                                                                                                            self._model = AclLiteModel(self.model_path)

                                                                                                                                                                                                                def preprocess(self, frame):
                                                                                                                                                                                                                        # resize frame, keep original image
                                                                                                                                                                                                                                self.src_image = frame
                                                                                                                                                                                                                                        self.resized_image = cv2.resize(frame, (self.model_width, self.model_height))

                                                                                                                                                                                                                                            def infer(self):
                                                                                                                                                                                                                                                    # infer frame
                                                                                                                                                                                                                                                            image_info = np.array([640, 640,
                                                                                                                                                                                                                                                                                        640, 640],
                                                                                                                                                                                                                                                                                                                    dtype=np.float32)
                                                                                                                                                                                                                                                                                                                            self.result = self._model.execute([self.resized_image, image_info])

                                                                                                                                                                                                                                                                                                                            ```
                                                                                                                                                                                                                                                                                                                            也可以参考这个官方项目:[ https://gitee.com/ascend/samples/tree/master/python/contrib/garbage_picture](https://gitee.com/ascend/samples/tree/master/python/contrib/garbage_picture)

                                                                                                                                                                                                                                                                                                                            ## 模型准备
                                                                                                                                                                                                                                                                                                                            利用yolov5 代码训练出垃圾分类的模型, yolov5 源码可以在github 下载。
                                                                                                                                                                                                                                                                                                                            运行export导出onnx模型,拷贝到orange ai pro里。
                                                                                                                                                                                                                                                                                                                            ### 转换模型
                                                                                                                                                                                                                                                                                                                            将我们的模型转成om的格式,参考上面的模型转换内容。

                                                                                                                                                                                                                                                                                                                            这里可以直接用官方的python版本进行修改
                                                                                                                                                                                                                                                                                                                            ```c
                                                                                                                                                                                                                                                                                                                            /home/HwHiAiUser/project/EdgeAndRobotics/Samples/YOLOV5USBCamera/python/
                                                                                                                                                                                                                                                                                                                            ```
                                                                                                                                                                                                                                                                                                                            **项目的目录设计如下**
                                                                                                                                                                                                                                                                                                                            ```c
                                                                                                                                                                                                                                                                                                                            - index.py 模型推理的核心代码,包含推理类
                                                                                                                                                                                                                                                                                                                            - main.py  应用的主函数入口
                                                                                                                                                                                                                                                                                                                            - imgs    存放推理的结果
                                                                                                                                                                                                                                                                                                                            - logs    存放运行的日志
                                                                                                                                                                                                                                                                                                                            ```
                                                                                                                                                                                                                                                                                                                            编写index.py, 加入自己的预处理和后处理逻辑

                                                                                                                                                                                                                                                                                                                            ```c
                                                                                                                                                                                                                                                                                                                            def preprocess_image(image, cfg, bgr2rgb=True):
                                                                                                                                                                                                                                                                                                                                """图片预处理"""
                                                                                                                                                                                                                                                                                                                                    img, scale_ratio, pad_size = letterbox(image, new_shape=cfg['input_shape'])
                                                                                                                                                                                                                                                                                                                                        if bgr2rgb:
                                                                                                                                                                                                                                                                                                                                                img = img[:, :, ::-1]
                                                                                                                                                                                                                                                                                                                                                    img = img.transpose(2, 0, 1)  # HWC2CHW
                                                                                                                                                                                                                                                                                                                                                        img = np.ascontiguousarray(img, dtype=np.float32)
                                                                                                                                                                                                                                                                                                                                                            return img, scale_ratio, pad_size


                                                                                                                                                                                                                                                                                                                                                            def draw_bbox(bbox, img0, color, wt, names):
                                                                                                                                                                                                                                                                                                                                                                """在图片上画预测框"""
                                                                                                                                                                                                                                                                                                                                                                    det_result_str = ''
                                                                                                                                                                                                                                                                                                                                                                        for idx, class_id in enumerate(bbox[:, 5]):
                                                                                                                                                                                                                                                                                                                                                                                if float(bbox[idx][4] < float(0.05)):
                                                                                                                                                                                                                                                                                                                                                                                            continue
                                                                                                                                                                                                                                                                                                                                                                                                    img0 = cv2.rectangle(img0, (int(bbox[idx][0]), int(bbox[idx][1])), (int(bbox[idx][2]), int(bbox[idx][3])),
                                                                                                                                                                                                                                                                                                                                                                                                                                 color, wt)
                                                                                                                                                                                                                                                                                                                                                                                                                                        img0 = cv2.putText(img0, str(idx) + ' ' + names[int(class_id)], (int(bbox[idx][0]), int(bbox[idx][1] + 16)),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          img0 = cv2.putText(img0, '{:.4f}'.format(bbox[idx][4]), (int(bbox[idx][0]), int(bbox[idx][1] + 32)),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            det_result_str += '{} {} {} {} {} {}\n'.format(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        names[bbox[idx][5]], str(bbox[idx][4]), bbox[idx][0], bbox[idx][1], bbox[idx][2], bbox[idx][3])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            return img0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ### 推理结果
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            在完成推理后,输出模型的推理结果同时保存推理图像
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ```c
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2-纸盒纸箱
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2-纸盒纸箱
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            3-筷子
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            5-垃圾桶
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            9-塑料玩具
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            16-干电池
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            22-洗护用品
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            30-茶叶渣
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            28-调料瓶
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ![](https://i-blog.csdnimg.cn/direct/eda41b04192c4d34980fcd238c65d3e6.jpeg#pic_center)经过测试发现,推理一张图像耗费的时间大约为16-20ms之间,后续还有优化的空间

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ```c
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             handler img 18.02ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             hanlder img 16.01ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             handler img 19.92ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             handler img 15.02ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             handler img 18.24ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             handler img 17.02ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             handler img 16.82ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             handler img 14.92ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ## 性能体验
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            对于开发版的表现,总体来说是比较丝滑的,上手体验较好。
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            **1、负载**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            能够实时进行推理60FPS的视频,同时推理一张640*640的图像大约只要15-20ms,目前没有做量化设计,精度还是float16, 做完Int量化后,应该还可以进一步提升。
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            **2、散热**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/124505382a394492809be45c234250cd.png)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Orange AI Pro 在散热方面还是做的比较好的,配备了散热风扇, 运行3个小时后,板子的温度还是处于一个较低的温度,个人觉得散热效果还是比较让人满意的。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            **噪音**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            体验了3天下来,只有在开机启动的时候大约有6~10s左右比较大的声音,但也在可接受范围内,平时运行各种AI模型都是静默的,几乎感受不到风扇的声音存在。
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ## 使用总结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1、本来以为可能部署会比较麻烦, 需要大量查阅资料后才能完成部署流程,体验下来发现官方的材料和项目demo还是比较完善的,基本上可以很快上手,各种环境的部署也有相应完善的文档, 比我预期的难度要小的多。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2、同时在AI算力上,推理的速度也非常给力,npu的推理速度可以满足大部分的实时处理需求,能够满足我做一些diy的智能家居方向。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            3、丰富的硬件功能,Orang ai pro 配备了丰富的硬件接口,给开发更复杂的AI应用提供了更多可能性。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            总体来说,Orang AI Pro 强大的AI能力和便捷的使用体验,还是给我留下了美好的印象,未来我也希望能通过Orange AI Pro 创作出更多的AI应用,喜欢的朋友千万不要错过!!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            接下来,我也会利用Orange AI Pro 做一些新的尝试和AI应用, 希望能带给大家一些参考意见。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [点我查看更多精彩内容:www.dgstudyblog.top](www.dgstudyblog.top)
相关文章
|
3月前
|
人工智能 JSON 小程序
【一步步开发AI运动APP】七、自定义姿态动作识别检测——之规则配置检测
本文介绍了如何通过【一步步开发AI运动APP】系列博文,利用自定义姿态识别检测技术开发高性能的AI运动应用。核心内容包括:1) 自定义姿态识别检测,满足人像入镜、动作开始/停止等需求;2) Pose-Calc引擎详解,支持角度匹配、逻辑运算等多种人体分析规则;3) 姿态检测规则编写与执行方法;4) 完整示例展示左右手平举姿态检测。通过这些技术,开发者可轻松实现定制化运动分析功能。
|
3月前
|
存储 人工智能 安全
AI驱动的幼儿跌倒检测——视频安全系统的技术解析
幼儿跌倒检测系统基于AI视频技术,融合人体姿态识别与实时报警功能,为幼儿园安全管理提供智能化解决方案。系统通过YOLOv9、OpenPose等算法实现高精度跌倒检测(准确率达98%),结合LSTM时间序列分析减少误报,支持目标分类区分幼儿与成人,并具备事件存储、实时通知及开源部署优势。其高效、灵活、隐私合规的特点显著提升安全管理效率,助力优化园所运营。
135 0
AI驱动的幼儿跌倒检测——视频安全系统的技术解析
|
2月前
|
人工智能 小程序 API
【一步步开发AI运动APP】九、自定义姿态动作识别检测——之关键点追踪
本文介绍了【一步步开发AI运动APP】系列中的关键点追踪技术。此前分享的系列博文助力开发者打造了多种AI健身场景的小程序,而新系列将聚焦性能更优的AI运动APP开发。文章重点讲解了“关键点位变化追踪”能力,适用于动态运动(如跳跃)分析,弥补了静态姿态检测的不足。通过`pose-calc`插件,开发者可设置关键点(如鼻子)、追踪方向(X或Y轴)及变化幅度。示例代码展示了如何在`uni-app`框架中使用`createPointTracker`实现关键点追踪,并结合人体识别结果完成动态分析。具体实现可参考文档与Demo示例。
|
3月前
|
SQL 数据采集 人工智能
“服务器老被黑?那是你没上AI哨兵!”——聊聊基于AI的网络攻击检测那些事儿
“服务器老被黑?那是你没上AI哨兵!”——聊聊基于AI的网络攻击检测那些事儿
172 12
|
3月前
|
机器学习/深度学习 人工智能 运维
AI“捕风捉影”:深度学习如何让网络事件检测更智能?
AI“捕风捉影”:深度学习如何让网络事件检测更智能?
82 8
|
3月前
|
人工智能 自然语言处理 测试技术
谷歌AI 多模态 Gemini 2.5 Pro的国内使用教程
在人工智能(AI)的星辰大海中,谷歌再次投下一枚重磅炸弹 💣!他们倾注心血打造的智慧结晶
1623 0
|
3月前
|
人工智能 小程序 API
【一步步开发AI运动APP】八、自定义姿态动作识别检测——之姿态相似度比较
本文介绍了如何通过姿态相似度比较技术简化AI运动应用开发。相比手动配置规则,插件`pose-calc`提供的姿态相似度比较器可快速评估两组人体关键点的整体与局部相似度,降低开发者工作量。文章还展示了在`uni-app`框架下调用姿态比较器的示例代码,并提供了桌面辅助工具以帮助提取标准动作样本,助力开发者打造性能更优、体验更好的AI运动APP。
|
5月前
|
传感器 人工智能 机器人
【01】人形机器人研究试验-被有些网友痛骂“工业垃圾”“人工智障”上春晚的人形AI机器人-宇树科技机器人到底怎么样??-本系列优雅草卓伊凡亲自尝试下人形机器人的制造-从0开始学习并且制作机器人-可以跟随卓伊凡
【01】人形机器人研究试验-被有些网友痛骂“工业垃圾”“人工智障”上春晚的人形AI机器人-宇树科技机器人到底怎么样??-本系列优雅草卓伊凡亲自尝试下人形机器人的制造-从0开始学习并且制作机器人-可以跟随卓伊凡
251 1
【01】人形机器人研究试验-被有些网友痛骂“工业垃圾”“人工智障”上春晚的人形AI机器人-宇树科技机器人到底怎么样??-本系列优雅草卓伊凡亲自尝试下人形机器人的制造-从0开始学习并且制作机器人-可以跟随卓伊凡
|
3月前
|
传感器 人工智能 自然语言处理
跨越机器物理世界和AI虚拟世界之间的鸿沟,是软硬件一体化创新关键 法思诺创新 法思诺创新​
法思诺创新专注于跨越机器物理世界与AI虚拟世界的鸿沟,推动软硬件一体化创新。在物理世界中,机器人虽有强壮躯体却缺乏灵活大脑;而在虚拟世界里,AI虽智慧无穷却无实体行动力。两者融合是未来智能化发展的关键。通过AI赋能,智能机器人已在智能制造、智慧物流、智慧服务及特种作业等领域大显身手。例如,AI工业机器人提升生产精度与效率,仓储机器人优化物流调度,服务机器人提供人性化交互,特种机器人执行危险任务。软硬件一体化创新实现了机器人感知、决策、运动和人机交互的全面智能化,是智能化时代的大势所趋。正如威廉·吉布森所言:“未来已来,只是尚未均匀分布。”率先拥抱软硬件一体化创新者,将赢得未来。
|
5月前
|
人工智能 算法 API
重磅:谷歌AI Gemini 2.0 Pro/Flash已来,国内用户怎么使用?
当人工智能的浪潮席卷全球,谷歌再次站在了时代的潮头。Gemini 2.0,这个名字如今已成为 AI 领域最耀眼的明星。它不仅仅是一个模型的升级,更代表着一场技术革命的开端。2024 年末,Gemini 2.0 Flash 以其疾风骤雨般的速度震撼登场,紧接着,2025 年初,Gemini 2.0 Pro 系列的发布,则将这场革命推向了高潮。谷歌正式宣告,我们已步入 Gemini 2.0 时代!
458 15

热门文章

最新文章