最近AI圈有个大新闻：谷歌大脑（Google Brain）的几位核心研究员，包括Jeff Dean这样的泰斗级人物，纷纷离职，创立了一家名为“Discovery Loop”的新公司。这消息一出，技术社区都炸了锅。大家一方面好奇，这些站在AI研究金字塔尖的人，究竟看到了什么新机会？另一方面，也在猜测“Discovery Loop”这个充满探索意味的名字背后，到底要做什么。

对于咱们开发者来说，这不仅仅是茶余饭后的谈资。顶尖研究员的动向，往往预示着技术浪潮的下一个方向。从“AI Agent开发”到“AI模型部署”，再到“AI工程实践”，这些热搜词和网络热词，其实都指向了一个核心问题：当大模型的基础能力逐渐普及时，下一个价值高地在哪里？很可能就是如何让AI更自主、更可靠、更深入地理解世界并采取行动——这正是“Discovery Loop”可能瞄准的领域。

本文将结合这起行业事件，深入探讨其背后可能的技术趋势，并以此为引，系统性地梳理从AI研究到工程化落地的完整路径。无论你是对AI前沿动态感兴趣，还是正在实践中摸索如何构建可靠的AI应用，这篇文章都将为你提供一个清晰的视角和一套可操作的实战指南。

1. 背景与核心概念：从研究到创业的“发现循环”

要理解这件事的意义，我们得先搞清楚几个关键角色和概念。

Jeff Dean是谁？ 在AI和分布式系统领域，Jeff Dean是一个传奇。他是谷歌大脑的联合创始人，也是TensorFlow等核心基础设施的主要设计者之一。他的离职，某种程度上标志着AI发展从“基础设施构建”阶段，进入了“应用与发现”的新阶段。

什么是“Discovery Loop”？ 从字面意思看，是“发现循环”。在AI语境下，这很可能指的是一种新型的AI系统范式： 一个能够自主提出假设、设计实验、分析结果，并不断迭代优化，从而加速科学发现、技术探索或商业决策的闭环系统。 它超越了当前大多数AI模型被动回答问题的模式，转向主动探索未知。

为什么是现在？ 这波创业潮的出现，离不开几个技术前提的成熟：

  1. 大模型成为基础能力 ：像GPT-4、Gemini这样的模型，提供了强大的世界知识和推理基础。
  2. AI Agent技术兴起 ：让AI能够调用工具、执行计划、与环境交互。
  3. 计算成本与自动化 ：云计算和自动化ML（AutoML）降低了大规模实验的门槛。

简单来说， “Discovery Loop”可能代表着下一代AI：从“内容生成”走向“世界探索” 。这对于开发者而言，意味着新的技术栈、新的架构模式和新的职业机会。

2. 环境准备与版本说明：构建AI探索系统的技术基座

如果我们想自己动手，尝试构建一个简化版的“发现循环”系统，需要准备哪些环境？这里我们以一个基于Python的AI Agent实验平台为例。

核心环境清单：

  • 操作系统 ：Ubuntu 20.04 LTS 或更高版本（Windows可使用WSL2，macOS也可）。
  • Python ：3.9 或 3.10（3.11+需注意部分库的兼容性）。这是当前大多数AI库最稳定的支持版本。
  • 关键库与框架 ：
    • LangChain / LlamaIndex ：用于构建AI应用编排框架。本文示例将使用LangChain。
    • OpenAI API / 本地大模型 ：作为核心“大脑”。为方便演示，我们使用OpenAI GPT-4 API，但你完全可以替换为本地部署的Llama 3、Qwen等开源模型。
    • 代码执行环境 ： docker-py 或 subprocess ，用于安全地运行AI生成的代码或实验脚本。
    • 实验记录与可视化 ： MLflow 或 Weights & Biases (wandb) ，用于跟踪实验过程和数据。
    • 向量数据库 ： Chroma (轻量) 或 Weaviate ，用于存储和管理探索过程中产生的知识。

版本管理建议： 强烈建议使用 conda 或 venv 创建独立的Python环境，并使用 requirements.txt 或 pyproject.toml 严格管理依赖。AI领域库更新频繁，版本冲突是常见坑点。

一个基础的 requirements.txt 可能如下所示：

# 核心AI与编排
langchain==0.1.0
langchain-openai==0.0.5
openai==1.12.0

# 实验与数据管理
mlflow==2.11.3
pandas==2.0.3
numpy==1.24.3

# 轻量级向量数据库
chromadb==0.4.22

# 工具调用与安全
docker==6.1.3
python-dotenv==1.0.0

重要提示 ：以上版本为示例，实际开发时应查看各库官方文档，使用当前推荐的最新稳定版本。本文重点在于演示架构和思路，代码需根据你的具体环境进行调整。

3. 核心原理与技术拆解：如何构建一个“循环”

一个完整的“Discovery Loop”系统，其核心在于“感知-思考-行动-学习”的闭环。我们可以用以下几个关键技术模块来理解它。

3.1 智能体（Agent）与工具调用（Tool Calling）

这是系统的“四肢”。AI智能体不再只是聊天，而是可以通过预定义的工具（如搜索API、代码执行器、数据库查询）来影响外部世界。

关键概念 ：

  • ReAct模式 ：让模型在回答时显式地进行“推理”（Reasoning）和“行动”（Acting），形成“Thought -> Action -> Observation”的循环。
  • 工具定义 ：每个工具都是一个函数，有清晰的名称、描述和参数。模型学习在何时调用何种工具。

一个简单的工具定义示例（使用LangChain）：

from langchain.tools import tool
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_openai import ChatOpenAI
import subprocess
import json

@tool
def run_python_script(script_code: str) -> str:
    """在安全沙箱中运行一段Python代码，并返回其输出或错误。"""
    try:
        # 警告：生产环境需要更严格的安全隔离，如Docker容器
        result = subprocess.run(['python', '-c', script_code],
                                 capture_output=True, text=True, timeout=30)
        if result.returncode == 0:
            return f"执行成功:\n{result.stdout}"
        else:
            return f"执行失败:\n{result.stderr}"
    except subprocess.TimeoutExpired:
        return "错误：代码执行超时。"
    except Exception as e:
        return f"未知错误：{str(e)}"

# 初始化模型和智能体
llm = ChatOpenAI(model="gpt-4-turbo-preview", temperature=0)
tools = [run_python_script]
prompt = hub.pull("hwchase17/react") # 一个标准的ReAct提示模板

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

3.2 规划与反思（Planning & Reflection）

这是系统的“大脑”。AI需要能够将复杂目标分解为子任务（规划），并在行动后评估结果，修正策略（反思）。

实现方式 ：

  • 思维链（Chain-of-Thought） ：提示模型一步步推理。
  • 任务分解 ：使用一个“规划器”模型先将目标拆解成步骤列表。
  • 反思循环 ：在每一步或最终，让另一个模型或同一模型检查结果是否合理，是否需要调整方向。
# 一个简化的规划与反思循环伪代码
def discovery_loop(initial_goal: str, max_iterations: int = 5):
    current_plan = planner_agent.invoke(f“将以下目标分解为步骤：{initial_goal}”)
    accumulated_knowledge = “”
    
    for i in range(max_iterations):
        print(f“\n=== 迭代 {i+1}：执行计划 ===")
        # 执行当前计划中的一个步骤
        result = agent_executor.invoke({“input”: current_plan.steps[i]})
        
        # 将结果存入知识库
        accumulated_knowledge += f“\n步骤结果：{result['output']}”
        
        # 反思：基于新结果，计划是否需要调整？
        reflection = reflection_agent.invoke({
            “goal”: initial_goal,
            “original_plan”: current_plan,
            “result_so_far”: accumulated_knowledge
        })
        
        if reflection.should_adjust_plan:
            print(“根据反思调整计划...”)
            current_plan = planner_agent.invoke(f“基于以下目标和已有结果，重新规划：{initial_goal}\n已知：{accumulated_knowledge}”)
        else:
            print(“计划进展顺利，继续...”)
            
        # 判断目标是否达成
        if evaluation_agent.invoke({“goal”: initial_goal, “current_state”: accumulated_knowledge}).is_achieved:
            print(“目标已达成！”)
            break
    
    return accumulated_knowledge

3.3 记忆与知识管理（Memory & Knowledge）

这是系统的“经验库”。循环中产生的所有数据、代码、结果都需要被有效存储、索引和检索，以供后续循环学习。

技术栈 ：

  1. 向量数据库 ：将文本、代码片段转换为向量（嵌入），实现基于语义的相似性搜索。当智能体遇到新问题时，可以先从知识库中寻找类似解决方案。
  2. 实验跟踪系统 ：记录每次实验的输入参数、代码、输出、环境状态和性能指标。 MLflow 是绝佳选择。
import chromadb
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema import Document

# 初始化向量数据库客户端
client = chromadb.PersistentClient(path="./discovery_loop_db")
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(client=client, embedding_function=embeddings)

def store_knowledge(observation: str, metadata: dict):
    """将一次观察结果存储到向量数据库"""
    doc = Document(page_content=observation, metadata=metadata)
    vectorstore.add_documents([doc])
    print(f“知识已存储：{observation[:100]}...”)

def retrieve_similar_knowledge(query: str, k=3):
    """从知识库中检索相似经验"""
    docs = vectorstore.similarity_search(query, k=k)
    return [f“相关经验 {i+1}: {doc.page_content}” for i, doc in enumerate(docs)]

4. 完整实战案例：构建一个自动化数据洞察探索器

现在，让我们将这些模块组合起来，构建一个简化但完整的“Discovery Loop”应用： 一个能自动分析给定数据集，发现模式、提出假设并尝试验证的AI智能体。

项目目标 ：用户上传一个CSV文件（如鸢尾花数据集），AI智能体自动执行探索性数据分析（EDA），提出关于数据关系的假设（例如“花瓣长度与种类相关”），并编写和运行统计检验代码来验证假设，最后生成报告。

4.1 项目结构创建

discovery_loop_demo/
├── main.py              # 主程序入口
├── agents/              # 智能体模块
│   ├── __init__.py
│   ├── planner.py       # 规划智能体
│   ├── executor.py      # 执行智能体（含工具）
│   └── reflector.py     # 反思智能体
├── tools/               # 工具定义
│   ├── __init__.py
│   ├── data_tools.py    # 数据处理工具
│   └── code_tools.py    # 代码执行工具
├── memory/              # 记忆与知识
│   ├── __init__.py
│   └── vector_store.py
├── utils/               # 工具函数
│   └── __init__.py
├── data/                # 存放上传的数据
│   └── iris.csv
├── requirements.txt     # 依赖列表
└── .env                 # 环境变量（存储API Key）

4.2 核心工具定义

首先，在 tools/code_tools.py 中定义一个更安全的代码执行工具。

# tools/code_tools.py
import subprocess
import tempfile
import os
from langchain.tools import tool

@tool
def execute_python_script(script_content: str, script_name: str = “analysis_script.py”) -> str:
    """在一个临时目录中创建并执行Python脚本，返回输出。相对安全。"""
    with tempfile.TemporaryDirectory() as tmpdir:
        script_path = os.path.join(tmpdir, script_name)
        with open(script_path, ‘w’, encoding=‘utf-8’) as f:
            f.write(script_content)
        
        try:
            # 可以在这里添加依赖检查或安装，例如 `pip install pandas scipy`
            result = subprocess.run(
                [‘python’, script_path],
                cwd=tmpdir,
                capture_output=True,
                text=True,
                timeout=60
            )
            output = f“STDOUT:\n{result.stdout}\n”
            if result.stderr:
                output += f“STDERR:\n{result.stderr}\n”
            output += f“返回码：{result.returncode}”
            return output
        except subprocess.TimeoutExpired:
            return “错误：脚本执行超时（60秒）。”
        except Exception as e:
            return f“执行过程异常：{str(e)}”

在 tools/data_tools.py 中定义数据处理工具。

# tools/data_tools.py
import pandas as pd
from langchain.tools import tool

@tool
def load_and_describe_data(file_path: str) -> str:
    """加载CSV文件并返回其基本描述（形状、列名、头部几行）。"""
    try:
        df = pd.read_csv(file_path)
        description = f“数据加载成功！\n”
        description += f“数据形状：{df.shape}（行 x 列）\n”
        description += f“列名：{list(df.columns)}\n”
        description += f“前5行数据：\n{df.head().to_string()}\n”
        description += f“基本统计信息：\n{df.describe().to_string()}”
        return description
    except FileNotFoundError:
        return f“错误：找不到文件 {file_path}”
    except Exception as e:
        return f“加载数据时出错：{str(e)}”

4.3 智能体编排与主循环

在 main.py 中，我们编排整个发现循环。

# main.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from tools.data_tools import load_and_describe_data
from tools.code_tools import execute_python_script
from memory.vector_store import store_knowledge, retrieve_similar_knowledge

# 加载环境变量（OPENAI_API_KEY）
load_dotenv()

def main():
    # 1. 初始化大模型
    llm = ChatOpenAI(model=“gpt-4-turbo-preview”, temperature=0.2)
    
    # 2. 准备工具
    tools = [load_and_describe_data, execute_python_script]
    
    # 3. 创建执行智能体
    prompt = hub.pull(“hwchase17/react”)
    agent = create_react_agent(llm, tools, prompt)
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True,
        max_iterations=10
    )
    
    # 4. 定义探索目标
    data_file = “./data/iris.csv”
    goal = f“请对数据集 {data_file} 进行探索性数据分析。首先了解数据，然后提出至少两个关于数据内变量关系的科学假设，最后编写Python代码（使用scipy或statsmodels库）来统计检验这些假设，并解释结果。”
    
    print(f“开始发现循环，目标：{goal}\n”)
    
    # 5. 启动循环
    iteration = 1
    max_iterations = 5
    all_findings = “”
    
    while iteration <= max_iterations:
        print(f“\n{‘=’*50}”)
        print(f“迭代 {iteration}”)
        print(f“{‘=’*50}”)
        
        # 构建当前输入：目标 + 已有发现
        current_input = goal
        if all_findings:
            current_input += f“\n\n到目前为止的发现：\n{all_findings}”
        
        # 检索相似历史知识（模拟记忆）
        similar_past = retrieve_similar_knowledge(current_input, k=2)
        if similar_past:
            current_input += f“\n\n相关历史经验：\n” + “\n”.join(similar_past)
        
        # 执行智能体
        try:
            result = agent_executor.invoke({“input”: current_input})
            observation = result[“output”]
            print(f“\n智能体输出：\n{observation}”)
            
            # 存储本次观察
            store_knowledge(observation, {“iteration”: iteration, “goal”: goal})
            all_findings += f“\n--- 迭代{iteration}结果 ---\n{observation}\n”
            
        except Exception as e:
            print(f“智能体执行出错：{e}”)
            observation = f“执行错误：{e}”
        
        # 简单反思：是否已经完成了核心任务？（这里用关键词简单判断）
        if “假设” in observation and “检验” in observation and “p值” in observation.lower():
            print(“\n检测到假设提出与检验已完成，循环结束。”)
            break
            
        iteration += 1
    
    print(f“\n{‘*’*50}”)
    print(“发现循环结束。最终发现摘要：”)
    print(all_findings[-1500:]) # 打印最后一部分结果
    print(f“{‘*’*50}”)

if __name__ == “__main__”:
    main()

4.4 运行与结果说明

  1. 准备环境 ：将鸢尾花数据集 iris.csv 放入 ./data/ 目录。在项目根目录创建 .env 文件，填入 OPENAI_API_KEY=你的密钥 。
  2. 安装依赖 ： pip install -r requirements.txt
  3. 运行程序 ： python main.py

预期流程 ：

  • 智能体首先会调用 load_and_describe_data 工具，读取并总结数据。
  • 然后，它会基于数据描述，提出类似“setosa品种的花瓣宽度与其他品种有显著差异”的假设。
  • 接着，它会调用 execute_python_script 工具，生成并运行进行t检验或ANOVA的Python代码。
  • 代码执行后，智能体会得到p值等结果，并对其进行解释。
  • 主循环会判断关键结果是否出现，从而决定是否结束探索。

输出示例（简化） ：

开始发现循环，目标：请对数据集 ./data/iris.csv 进行探索性数据分析...
==================================================
迭代 1
==================================================
> 进入新的AgentExecutor链...
思考：我需要先查看数据。
行动：load_and_describe_data
行动输入：{“file_path”: “./data/iris.csv”}
观察：数据加载成功！数据形状：(150, 5)...
思考：数据有150行，5列... 我注意到有‘species’列。我可以提出关于不同物种间测量值差异的假设。
行动：execute_python_script
行动输入：{“script_content”: “import pandas as pd...\n# 进行setosa和versicolor的花瓣长度t检验\n...”, “script_name”: “hypothesis_test1.py”}
观察：STDOUT: t-statistic: -15.386, p-value: 6.89e-28 ...
> 链结束。
智能体输出：我提出了假设‘setosa的花瓣长度显著小于versicolor’，并进行了独立样本t检验。p值远小于0.05，假设成立。
...
检测到假设提出与检验已完成，循环结束。

这个案例展示了一个微型的“发现循环”：AI自动完成了从数据感知到假设验证的完整过程。在更复杂的系统中，这个循环可以嵌套更多层次，探索更广阔的空间。

5. 常见问题与排查思路

在构建和运行此类AI探索系统时，你会遇到一些典型问题。

问题现象 可能原因 排查与解决思路
智能体陷入循环，不结束 1. 目标定义模糊。
2. 反思机制未触发或条件太苛刻。
3. 工具调用失败但未正确处理错误。		 1. 将大目标拆解为清晰、可验证的子目标。
2. 优化反思提示词，或设置基于迭代次数和关键结果检测的混合终止条件。
3. 增强工具的错误处理，确保任何失败都能被智能体观察到并作为“观察”输入。
代码执行工具不安全或依赖缺失 1. 直接执行未经验证的代码。
2. 生成的代码需要未安装的第三方库。		 1. 必须使用沙箱环境 ，如Docker容器，限制资源（CPU、内存、网络、运行时间）。
2. 在工具中预装常用科学计算库（如 numpy, pandas, scipy ），或让智能体在代码中尝试 import 并处理 ImportError 。
向量数据库检索结果不相关 1. 嵌入模型不适合领域文本。
2. 存储的文档块太大或太小，语义不清晰。
3. 查询语句构造不佳。		 1. 尝试不同的嵌入模型（如 text-embedding-3-small ）。
2. 对长文本进行智能分块（如 RecursiveCharacterTextSplitter ）。
3. 在查询时使用 HyDE 等技术，让模型先生成一个假设答案，再用它去检索。
API调用成本过高或速度慢 1. 循环迭代次数过多。
2. 每次调用都使用大上下文。
3. 未使用流式输出或异步调用。		 1. 设定严格的迭代上限和预算上限。
2. 优化提示词，精简上下文。使用摘要记忆而非完整历史。
3. 对于非关键步骤，可考虑使用更小、更快的模型（如 gpt-3.5-turbo ）。
智能体做出的决策不可靠 1. 模型“幻觉”，生成虚假信息或代码。
2. 工具反馈未被正确理解。		 1. 引入“验证”步骤。例如，让一个“验证者”模型或规则系统检查代码逻辑、统计结果的合理性。
2. 结构化工具的输出，使其更易于解析。使用 JSON 格式作为工具和智能体间的通信协议。

6. 最佳实践与工程建议

要将“Discovery Loop”从演示推向生产，需要遵循严格的工程准则。

1. 安全第一：沙箱与权限

  • 代码执行必须隔离 ：永远不要在主机环境中直接执行AI生成的代码。使用Docker容器，并配置严格的资源限制、只读文件系统和无网络访问（除非必要）。
  • 工具访问控制 ：为智能体定义最小权限工具集。例如，一个数据分析智能体不需要数据库 DELETE 权限。
  • 输入输出净化 ：对所有用户输入和AI生成的、用于系统调用的字符串进行严格的验证和转义，防止注入攻击。

2. 可靠性设计：容错与监控

  • 结构化输出 ：要求模型以JSON等格式输出，便于程序解析，减少解析失败。
  • 心跳与超时 ：为每个工具调用和Agent循环设置超时。实现健康检查，防止僵尸进程。
  • 全面日志记录 ：记录每个循环的输入、输出、工具调用、耗时和Token使用量。这不仅是调试的需要，也是分析智能体行为、优化成本的基础。
  • 熔断与降级 ：当某个工具或API连续失败时，触发熔断机制，并尝试降级方案（如使用备用模型、简化任务）。

3. 性能与成本优化

  • 分层记忆系统 ：不要将所有对话历史都塞进上下文。使用向量数据库存储长期记忆，仅将高度相关的摘要放入短期上下文。
  • 缓存 ：对常见的、确定性的查询结果（如数据描述、特定计算）进行缓存，避免重复计算和API调用。
  • 模型路由 ：根据任务复杂度动态选择模型。简单分类用小型模型，复杂规划再用大型模型。
  • 预算管理 ：实现一个预算跟踪器，当成本接近阈值时发出警报或自动停止循环。

4. 可解释性与评估

  • 可视化探索路径 ：将智能体的“思考-行动”链可视化，帮助人类理解其决策过程。
  • 定义成功指标 ：对于“发现”系统，成功指标可能是“提出新假设的数量”、“已验证假设的显著性”、“发现未知模式的 novelty”等。需要设计具体的评估函数。
  • 人类在环（Human-in-the-loop） ：在关键决策点（如发布结论、执行高风险操作前）引入人工审核。这是确保AI探索方向正确、结果可信的最后防线。

5. 迭代与持续学习

  • A/B测试提示词 ：系统化地测试不同提示词对任务完成率和质量的影响。
  • 从失败中学习 ：将失败的循环案例（如陷入死循环、产生错误代码）也存入知识库，并在未来遇到类似情况时提醒智能体。
  • 工具库进化 ：根据智能体频繁尝试但失败的操作，识别缺失的工具，并开发新的工具来扩展系统的能力边界。

7. 总结与学习路线

Jeff Dean等大牛的创业，无疑为AI领域投下了一颗信号弹：纯粹的模型规模竞赛之后， 如何构建能够自主、安全、高效探索和解决问题的AI系统，将成为新的前沿 。“Discovery Loop”正是这一理念的具象化。

通过本文的拆解和实战，我们理解了这样一个系统的核心组件： 具备规划和反思能力的智能体、安全可靠的工具调用、以及持续积累的记忆知识库 。我们从零搭建了一个能自动分析数据、提出并验证假设的微型探索系统，并深入探讨了其背后的工程挑战与最佳实践。

如果你想继续深入，可以遵循以下学习路线：

  1. 夯实基础 ：
    • LangChain / LlamaIndex ：熟练掌握这两个最流行的AI应用框架，理解其Agent、Chain、Tool、Memory等核心抽象。
    • 大模型API与本地部署 ：深入理解OpenAI、Anthropic、Cohere等商用API，以及Llama、Qwen、DeepSeek等开源模型的本地部署与调优。
  2. 专精技术栈 ：
    • AI Agent高级模式 ：研究ReAct、Plan-and-Execute、CrewAI等多智能体协作框架。
    • 向量数据库 ：深入学习Chroma、Weaviate、Pinecone、Milvus的原理和优化。
    • 实验管理与可观测性 ：掌握MLflow、Weights & Biases在复杂AI工作流中的应用。
  3. 深入系统设计 ：
    • 分布式系统与并发 ：学习如何将多个AI智能体任务并行化，管理任务队列和状态。
    • 安全工程 ：深入研究容器安全、权限模型、对抗性提示攻击防御。
    • 评估方法论 ：学习如何科学地评估一个“探索系统”的效能，超越简单的准确率指标。

这个领域正在飞速发展，每天都有新的工具和论文出现。最好的学习方式，就是像“Discovery Loop”的理念一样： 设定一个具体项目目标，动手搭建，在实践中循环迭代，不断发现和解决问题 。从自动化测试脚本，到智能数据分析助手，再到个性化的学习路径推荐，处处都是施展拳脚的舞台。

Logo
亚马逊云科技技术品牌专区

更多推荐

cover

大 硬 仗14小时：用2009年的上古亮机卡跑完深度学习，CPU满载但代码没崩

avatar 亚马逊云科技技术品牌专区
cover

原来AI、画图、导航都在用向量！

avatar 亚马逊云科技技术品牌专区
cover

害虫检测和识别3：基于深度学习YOLO26神经网络实现害虫检测和识别(含训练代码、数据集和GUI交互界面）

avatar 亚马逊云科技技术品牌专区