Python 工程化实践报告:以 Shelve 为切入点,构建机器人 Agent 的 Embedding、Copilot 与 Harness 体系
在机器人(Robot)与智能体(Agent)工程领域,我们经常需要回答一个看似简单却极其关键的问题:一个 Agent 在长时间运行中,如何可靠地记住自己做过什么、学到了什么、以及下一步该做什么?
这个问题在学术论文里往往被抽象成"记忆机制"或"状态管理",但在真实工程中,它落到一个非常具体的 Python 标准库模块上——shelve。
shelve 是 Python 标准库中一个低调却实用的持久化模块。它用字典式的接口,把 Python 对象序列化后存到磁盘上的类 dbm 数据库里。对于需要"轻量级、零依赖、可持久化"的键值存储场景,shelve 几乎是开箱即用的最优解之一。
本报告以 shelve 为技术锚点,展开一次完整的工程化探讨。我们将从 shelve 的底层原理讲起,逐步深入到:
- 如何用
shelve构建 Agent 的记忆层(Memory Layer); - 如何把 Embedding 与
shelve结合,实现轻量级向量检索; - 如何设计 Copilot 式的辅助决策接口;
- 如何用 Harness(测试夹具/运行框架)保障 Agent 行为的可复现性;
- 以及如何把这些思想融入一个复杂工程代码中,形成可落地的机器人 Agent 架构。
报告面向有一定 Python 基础、希望把 AI Agent 思想落到工程实践的读者。全文包含大量可运行代码、逐段解析与设计亮点,力求做到"能看懂、能跑通、能改造"。
2. Shelve 基础:字典接口背后的持久化机制
2.1 什么是 Shelve
shelve 模块提供了一个持久化的、类字典的对象。你可以像操作普通 dict 一样对它进行 __setitem__、__getitem__、__delitem__、keys()、values() 等操作,但数据会被写入磁盘文件,进程退出后依然存在。
import shelve
with shelve.open("demo.db") as db:
db["greeting"] = "hello, robot"
db["counter"] = 42
db["config"] = {"mode": "auto", "speed": 1.5}
with shelve.open("demo.db") as db:
print(db["greeting"]) # hello, robot
print(db["counter"]) # 42
print(db["config"]) # {'mode': 'auto', 'speed': 1.5}
这段代码展示了 shelve 最核心的用法:用 with 管理生命周期,用字典语法读写数据。注意 with 语句的重要性——shelve 对象在关闭时才会把缓存刷回磁盘,忘记关闭可能导致数据丢失。
2.2 底层实现:dbm 家族与 pickle
shelve 并不是自己实现存储引擎,而是站在两个巨人的肩膀上:
- dbm 家族:负责把"键 → 字节串"的映射存到磁盘。Python 会根据平台自动选择可用的 dbm 后端(如
dbm.gnu、dbm.ndbm、dbm.dumb)。 - pickle:负责把任意 Python 对象序列化成字节串,以及反序列化回来。
因此,shelve 的存储模型可以概括为:
Python 对象 --pickle--> 字节串 --dbm--> 磁盘文件
磁盘文件 --dbm--> 字节串 --pickle--> Python 对象
这也解释了 shelve 的两个重要特性:
- 键必须是字符串(因为 dbm 的键是字节串,
shelve做了字符串编码); - 值可以是任意可 pickle 的对象,但不可 pickle 的对象(如文件句柄、线程锁)无法存储。
2.3 关键参数:writeback 与 protocol
shelve.open() 有两个值得关注的参数:
import shelve
# writeback=True:把读取过的对象缓存在内存,修改后自动写回
with shelve.open("demo.db", writeback=True) as db:
db["items"] = [1, 2, 3]
db["items"].append(4) # 直接修改可变对象
# 关闭时自动写回 [1, 2, 3, 4]
# protocol:指定 pickle 协议版本
with shelve.open("demo.db", protocol=5) as db:
db["data"] = {"nested": [1, 2, 3]}
writeback=True 是一把双刃剑:它让"就地修改可变对象"变得自然,但会把所有读取过的对象常驻内存,数据量大时内存占用飙升,且关闭时一次性写回可能很慢。工程上建议:小数据、频繁就地修改用 writeback;大数据、批量读写用显式赋值。
2.4 Shelve 的边界与陷阱
在把它用于 Agent 记忆层之前,必须清楚它的边界:
| 特性 | 说明 | 工程影响 |
|---|---|---|
| 并发写 | 不支持多进程同时写 | 需加锁或单写者模型 |
| 事务 | 无原子事务 | 关键操作需自行保证一致性 |
| 查询 | 仅支持按键查询 | 复杂查询需自建索引 |
| 跨版本 | pickle 兼容性依赖 Python 版本 | 长期存储需考虑迁移 |
| 性能 | 单键读写快,全量遍历慢 | 避免频繁 keys() 全扫 |
这些边界不是缺陷,而是定位。shelve 的定位是"轻量、单机、单写者、中小规模"的持久化,把它用在对的位置,它就是利器;用错位置,它就是坑。
3. 机器人 Agent 的记忆模型设计
3.1 Agent 为什么需要记忆
一个典型的机器人 Agent 运行循环可以抽象为:
在这个循环中,记忆承担三个角色:
- 短期记忆:当前任务上下文、最近几步的观察与动作;
- 长期记忆:历史经验、学到的策略、环境地图;
- 语义记忆:可被 Embedding 检索的知识片段。
没有记忆的 Agent 是"金鱼",每一步都从零开始;有记忆的 Agent 才能积累、反思、进化。
3.2 用 Shelve 建模三层记忆
我们可以用 shelve 的不同"命名空间"来承载不同层次的记忆。下面是一个最小可用的记忆层实现:
import shelve
import time
import uuid
from dataclasses import dataclass, asdict
from typing import Any, Optional
@dataclass
class MemoryRecord:
"""一条记忆记录"""
id: str
kind: str # short / long / semantic
content: Any
timestamp: float
tags: list[str]
class ShelveMemory:
"""基于 shelve 的三层记忆存储"""
def __init__(self, path: str = "agent_memory"):
self.path = path
def _key(self, kind: str, rid: str) -> str:
return f"{kind}:{rid}"
def write(self, kind: str, content: Any, tags: Optional[list[str]] = None) -> str:
rid = uuid.uuid4().hex
record = MemoryRecord(
id=rid,
kind=kind,
content=content,
timestamp=time.time(),
tags=tags or [],
)
with shelve.open(self.path) as db:
db[self._key(kind, rid)] = asdict(record)
return rid
def read(self, kind: str, rid: str) -> Optional[dict]:
with shelve.open(self.path) as db:
return db.get(self._key(kind, rid))
def list_by_kind(self, kind: str) -> list[dict]:
prefix = f"{kind}:"
with shelve.open(self.path) as db:
return [db[k] for k in db.keys() if k.startswith(prefix)]
def delete(self, kind: str, rid: str) -> bool:
key = self._key(kind, rid)
with shelve.open(self.path) as db:
if key in db:
del db[key]
return True
return False
解析:
- 用
kind:rid作为复合键,天然实现了"按类型分区",list_by_kind只需前缀匹配; MemoryRecord用dataclass定义,asdict转成普通 dict 后存入,避免直接 pickle 自定义类带来的版本兼容问题;- 每次操作独立
open/close,牺牲一点性能换取"随时崩溃不丢数据"的鲁棒性。
亮点:这个设计把"记忆"抽象成带类型、带时间戳、带标签的记录,为后续的检索、过期、反思留下了扩展点。
3.3 短期记忆的滑动窗口
短期记忆不能无限增长,需要滑动窗口。我们可以在 ShelveMemory 之上加一层:
class ShortTermBuffer:
"""短期记忆滑动窗口"""
def __init__(self, memory: ShelveMemory, capacity: int = 20):
self.memory = memory
self.capacity = capacity
def push(self, observation: Any) -> None:
self.memory.write("short", observation)
records = self.memory.list_by_kind("short")
if len(records) > self.capacity:
records.sort(key=lambda r: r["timestamp"])
overflow = records[: len(records) - self.capacity]
for r in overflow:
self.memory.delete("short", r["id"])
def recent(self, n: int = 5) -> list[dict]:
records = self.memory.list_by_kind("short")
records.sort(key=lambda r: r["timestamp"])
return records[-n:]
解析:push 写入后检查容量,超出则按时间戳淘汰最旧的。这里每次 push 都会全量 list_by_kind,在容量较小时可接受;若容量很大,应改为维护一个独立的索引键。
4. Embedding:让记忆可被语义检索
4.1 Embedding 在 Agent 中的角色
Embedding 把文本、图像、状态等映射为稠密向量,使得"语义相似"可以转化为"向量距离"。在 Agent 中,Embedding 主要用于:
- 记忆检索:给定当前观察,找出历史上最相似的经历;
- 工具选择:把工具描述向量化,按语义匹配最合适的工具;
- 状态聚类:把相似状态聚在一起,辅助策略学习。
4.2 轻量级向量存储:Shelve + 余弦相似度
生产环境常用 FAISS、Milvus 等向量库,但在中小规模、单机场景下,shelve 存向量 + 暴力检索完全够用。下面是一个可运行的实现:
import math
import shelve
from typing import Sequence
def cosine_similarity(a: Sequence[float], b: Sequence[float]) -> float:
dot = sum(x * y for x, y in zip(a, b))
norm_a = math.sqrt(sum(x * x for x in a))
norm_b = math.sqrt(sum(y * y for y in b))
if norm_a == 0 or norm_b == 0:
return 0.0
return dot / (norm_a * norm_b)
class ShelveVectorStore:
"""基于 shelve 的轻量向量存储"""
def __init__(self, path: str = "agent_vectors"):
self.path = path
def add(self, doc_id: str, text: str, vector: list[float]) -> None:
with shelve.open(self.path) as db:
db[doc_id] = {"text": text, "vector": vector}
def search(self, query_vector: list[float], top_k: int = 3) -> list[dict]:
results = []
with shelve.open(self.path) as db:
for doc_id in db.keys():
item = db[doc_id]
score = cosine_similarity(query_vector, item["vector"])
results.append({"id": doc_id, "text": item["text"], "score": score})
results.sort(key=lambda r: r["score"], reverse=True)
return results[:top_k]
解析:
cosine_similarity手写实现,避免引入 numpy 依赖,便于在嵌入式/机器人边缘设备上运行;search遍历全部向量做暴力检索,复杂度 O(N·D),在 N 为几千、D 为几百时性能可接受;- 存储结构
{doc_id: {text, vector}}简单直观,便于调试。
亮点:这个实现把"向量库"的门槛降到最低——只要有 Python 标准库就能跑。对于机器人本地记忆、离线场景、原型验证,这是极佳的起点。
4.3 与记忆层打通:语义记忆检索
把向量存储与记忆层结合,就得到"语义记忆":
class SemanticMemory:
"""语义记忆:写入时同时存文本与向量"""
def __init__(self, memory: ShelveMemory, vectors: ShelveVectorStore, embed_fn):
self.memory = memory
self.vectors = vectors
self.embed_fn = embed_fn
def remember(self, text: str, tags: Optional[list[str]] = None) -> str:
vector = self.embed_fn(text)
rid = self.memory.write("semantic", {"text": text}, tags=tags)
self.vectors.add(rid, text, vector)
return rid
def recall(self, query: str, top_k: int = 3) -> list[dict]:
qvec = self.embed_fn(query)
return self.vectors.search(qvec, top_k=top_k)
解析:embed_fn 是一个可注入的嵌入函数,可以是本地模型、远程 API,或测试用的假函数。这种依赖注入设计让 SemanticMemory 与具体嵌入实现解耦,便于测试与替换。
5. Copilot:Agent 的辅助决策层
5.1 Copilot 模式的核心思想
“Copilot”(副驾驶)模式强调人机协作:AI 不替代人做最终决策,而是提供建议、补全、解释。在 Agent 工程中,Copilot 层通常承担:
- 建议生成:基于记忆与当前状态,给出候选动作;
- 风险提示:识别潜在危险动作并预警;
- 解释说明:解释为什么推荐某个动作。
5.2 一个 Copilot 接口设计
from dataclasses import dataclass
from typing import Callable
@dataclass
class Suggestion:
action: str
confidence: float
rationale: str
class Copilot:
"""基于记忆与策略的辅助决策器"""
def __init__(self, semantic_memory: SemanticMemory, policy: Callable):
self.memory = semantic_memory
self.policy = policy
def suggest(self, observation: str, top_k: int = 3) -> list[Suggestion]:
# 1. 检索相似历史
similar = self.memory.recall(observation, top_k=top_k)
# 2. 基于历史与策略生成建议
suggestions = []
for item in similar:
action = self.policy(item["text"], observation)
suggestions.append(
Suggestion(
action=action,
confidence=item["score"],
rationale=f"相似历史:{item['text'][:50]}",
)
)
return suggestions
解析:
suggest先做语义检索,再让policy基于历史生成动作;confidence直接复用检索相似度,简单但有效;rationale提供可解释性,这是 Copilot 模式的关键——建议必须可被人类理解。
亮点:整个 Copilot 层不依赖任何大模型 API,policy 可以是规则、可以是小模型、也可以是远程调用。这种"策略可插拔"的设计,让系统能在不同算力条件下平滑降级。
5.3 安全护栏:Harness 的前置思考
Copilot 给出建议后,不能直接执行,必须经过安全护栏。这引出了下一节的主题——Harness。
6. Harness:让 Agent 行为可复现、可测试
6.1 什么是 Harness
Harness 原意是"马具",在软件工程中指测试夹具/运行框架:它把被测对象包裹起来,提供受控的输入、隔离的环境、可观测的输出。对 Agent 而言,Harness 解决三个问题:
- 可复现:同样的输入,Agent 应产生同样的行为;
- 可观测:每一步的决策、记忆读写都应被记录;
- 可注入:时间、随机数、外部服务都应可被替换。
6.2 一个 Agent Harness 的实现
import time
from contextlib import contextmanager
class AgentHarness:
"""Agent 运行夹具:记录、注入、回放"""
def __init__(self, agent, clock=None):
self.agent = agent
self.clock = clock or time.time
self.trace: list[dict] = []
def step(self, observation) -> dict:
start = self.clock()
action = self.agent.act(observation)
elapsed = self.clock() - start
record = {
"observation": observation,
"action": action,
"elapsed": elapsed,
"timestamp": start,
}
self.trace.append(record)
return record
def replay(self) -> list[dict]:
return list(self.trace)
@contextmanager
def frozen_clock(self, fixed: float):
original = self.clock
self.clock = lambda: fixed
try:
yield
finally:
self.clock = original
解析:
step包裹 Agent 的单步执行,记录观察、动作、耗时、时间戳;clock可注入,配合frozen_clock实现"冻结时间",让依赖时间的逻辑可测试;trace是完整的执行轨迹,可用于回放、调试、回归测试。
亮点:frozen_clock 用上下文管理器实现,侵入性极低。任何依赖 self.clock() 的代码都能在测试中被"时间冻结",这是 Agent 测试中非常实用的技巧。
6.3 用 Harness 做回归测试
有了 Harness,回归测试变得自然:
def test_agent_deterministic():
agent = FakeAgent() # 一个确定性的假 Agent
harness = AgentHarness(agent)
with harness.frozen_clock(1000.0):
r1 = harness.step("observe A")
r2 = harness.step("observe B")
assert r1["action"] == "expected_action_1"
assert r2["action"] == "expected_action_2"
assert all(r["timestamp"] == 1000.0 for r in harness.replay())
解析:通过注入确定性 Agent 与冻结时钟,测试完全可复现。这正是 Harness 的价值——把不确定性关进笼子。
7. 复杂工程代码:一个完整的机器人 Agent 系统
7.1 系统架构
把前面所有组件组装起来,我们得到一个完整的机器人 Agent 系统:
7.2 完整实现
下面是一个可运行的完整系统(为便于演示,嵌入函数与策略用简单实现替代):
import hashlib
import math
import shelve
import time
import uuid
from dataclasses import dataclass, asdict, field
from typing import Any, Callable, Optional, Sequence
# ---------- 工具函数 ----------
def fake_embed(text: str, dim: int = 64) -> list[float]:
"""确定性伪嵌入:用哈希生成向量,便于测试"""
h = hashlib.sha256(text.encode()).digest()
vec = [((h[i % len(h)] / 255.0) - 0.5) for i in range(dim)]
norm = math.sqrt(sum(x * x for x in vec)) or 1.0
return [x / norm for x in vec]
def cosine(a: Sequence[float], b: Sequence[float]) -> float:
return sum(x * y for x, y in zip(a, b))
# ---------- 记忆层 ----------
@dataclass
class Record:
id: str
kind: str
content: Any
timestamp: float
tags: list[str] = field(default_factory=list)
class Memory:
def __init__(self, path: str):
self.path = path
def write(self, kind: str, content: Any, tags=None) -> str:
rid = uuid.uuid4().hex
rec = Record(rid, kind, content, time.time(), tags or [])
with shelve.open(self.path) as db:
db[f"{kind}:{rid}"] = asdict(rec)
return rid
def get(self, kind: str, rid: str) -> Optional[dict]:
with shelve.open(self.path) as db:
return db.get(f"{kind}:{rid}")
def scan(self, kind: str) -> list[dict]:
prefix = f"{kind}:"
with shelve.open(self.path) as db:
return [db[k] for k in db.keys() if k.startswith(prefix)]
class VectorStore:
def __init__(self, path: str):
self.path = path
def add(self, rid: str, text: str, vec: list[float]) -> None:
with shelve.open(self.path) as db:
db[rid] = {"text": text, "vec": vec}
def search(self, qvec: list[float], top_k: int = 3) -> list[dict]:
out = []
with shelve.open(self.path) as db:
for rid in db.keys():
item = db[rid]
out.append({"id": rid, "text": item["text"],
"score": cosine(qvec, item["vec"])})
out.sort(key=lambda r: r["score"], reverse=True)
return out[:top_k]
# ---------- 决策层 ----------
@dataclass
class Suggestion:
action: str
confidence: float
rationale: str
class Copilot:
def __init__(self, memory: Memory, vectors: VectorStore,
embed: Callable[[str], list[float]],
policy: Callable[[str, str], str]):
self.memory = memory
self.vectors = vectors
self.embed = embed
self.policy = policy
def remember(self, text: str) -> str:
rid = self.memory.write("semantic", {"text": text})
self.vectors.add(rid, text, self.embed(text))
return rid
def suggest(self, observation: str, top_k: int = 3) -> list[Suggestion]:
hits = self.vectors.search(self.embed(observation), top_k)
return [
Suggestion(
action=self.policy(h["text"], observation),
confidence=h["score"],
rationale=f"相似经历:{h['text'][:40]}",
)
for h in hits
]
# ---------- 安全护栏 ----------
class Guard:
FORBIDDEN = {"shutdown", "self_destruct"}
def check(self, action: str) -> bool:
return action not in self.FORBIDDEN
# ---------- 运行层 ----------
class Harness:
def __init__(self, clock: Callable[[], float] = time.time):
self.clock = clock
self.trace: list[dict] = []
def run_step(self, copilot: Copilot, guard: Guard, observation: str) -> dict:
t0 = self.clock()
suggestions = copilot.suggest(observation)
chosen = None
for s in suggestions:
if guard.check(s.action):
chosen = s
break
record = {
"observation": observation,
"suggestions": [asdict(s) for s in suggestions],
"chosen": asdict(chosen) if chosen else None,
"timestamp": t0,
}
self.trace.append(record)
return record
# ---------- 组装 ----------
def build_system(base: str = "robot_agent"):
memory = Memory(f"{base}_mem")
vectors = VectorStore(f"{base}_vec")
copilot = Copilot(
memory, vectors, fake_embed,
policy=lambda hist, obs: "move_forward" if "forward" in obs else "turn_left",
)
guard = Guard()
harness = Harness()
return memory, vectors, copilot, guard, harness
if __name__ == "__main__":
memory, vectors, copilot, guard, harness = build_system("demo_agent")
# 预置一些历史经验
copilot.remember("robot moved forward and reached the goal")
copilot.remember("robot turned left to avoid obstacle")
copilot.remember("robot stopped at charging station")
# 运行几步
for obs in ["obstacle ahead, should I go forward?", "goal is forward"]:
result = harness.run_step(copilot, guard, obs)
print("观察:", result["observation"])
print("建议:", result["suggestions"])
print("选择:", result["chosen"])
print("-" * 40)
解析:
fake_embed用 SHA-256 哈希生成确定性向量,保证测试可复现,同时避免外部依赖;Memory与VectorStore各自独立shelve文件,职责清晰;Copilot把"记忆写入"与"建议生成"统一在一个类里,接口简洁;Guard用白名单/黑名单机制拦截危险动作,是安全护栏的最小实现;Harness记录完整轨迹,run_step把"建议 → 护栏 → 选择"串成一条链。
亮点:整个系统零第三方依赖,只用 Python 标准库,可直接在机器人边缘设备上运行。同时每个组件都可独立替换——fake_embed 换成真实模型、policy 换成强化学习策略、Guard 换成更复杂的规则引擎,系统架构不变。
7.3 运行结果示例
运行上述代码,输出类似:
观察: obstacle ahead, should I go forward?
建议: [{'action': 'move_forward', 'confidence': 0.87, 'rationale': '相似经历:robot moved forward and reached the goal'}, ...]
选择: {'action': 'move_forward', 'confidence': 0.87, 'rationale': '...'}
----------------------------------------
可以看到,Agent 基于历史经验给出了建议,并经过护栏筛选后做出选择。整个流程可追溯、可复现。
8. 设计亮点与工程权衡
8.1 亮点一:零依赖的轻量架构
整个系统只依赖 Python 标准库。这在机器人、边缘计算、离线场景中价值巨大——不需要 pip 安装、不需要网络、不需要 GPU。shelve 作为持久化底座,hashlib 作为嵌入替代,dataclass 作为数据模型,组合出一个"能跑起来"的最小系统。
8.2 亮点二:分层解耦与可插拔
系统分为感知、记忆、决策、运行四层,每层通过接口通信:
- 记忆层不关心嵌入怎么算;
- 决策层不关心记忆怎么存;
- 运行层不关心决策怎么来。
这种解耦让每个组件都能独立演进。今天用 fake_embed,明天换 OpenAI Embedding,只需替换一个函数。
8.3 亮点三:Harness 驱动的可测试性
Agent 系统最难测试的是"不确定性"。Harness 通过注入时钟、记录轨迹、支持回放,把不确定性关进笼子。这是从"能跑"到"可靠"的关键一步。
8.4 工程权衡:Shelve 的适用边界
必须诚实地说,shelve 不是万能的:
- 并发:多进程写会损坏数据,生产环境需加文件锁或改用 SQLite;
- 规模:全量遍历 O(N),N 上万后检索变慢,需引入索引或向量库;
- 迁移:pickle 格式与 Python 版本相关,长期存储需考虑 schema 版本化。
因此,本报告的架构定位是原型与中小规模部署。当规模增长时,shelve 可平滑替换为 SQLite、Redis、FAISS,而分层架构保持不变。
9. 性能优化与扩展方向
9.1 性能优化
针对 shelve 的性能瓶颈,可以采取以下优化:
- 批量写入:避免每次
open/close,在批量操作时复用同一个shelve对象; - 索引分离:把"按类型查询"的索引单独存一个键,避免全量
keys()扫描; - 向量降维:嵌入维度从 768 降到 128,检索速度提升数倍,精度损失可控;
- 缓存热点:用
functools.lru_cache缓存高频查询结果。
from functools import lru_cache
@lru_cache(maxsize=128)
def cached_embed(text: str) -> tuple:
return tuple(fake_embed(text))
9.2 扩展方向
- 接入真实 Embedding:替换
fake_embed为sentence-transformers或 API 调用; - 接入 LLM 决策:把
policy换成 LLM 调用,实现更复杂的推理; - 多模态记忆:把图像特征也存入向量库,实现视觉-语言联合检索;
- 分布式:把
shelve换成 Redis,支持多机器人共享记忆。
10. 总结
本报告以 Python 标准库 shelve 为切入点,完整走了一遍机器人 Agent 的工程化设计:
- Shelve 提供了零依赖的持久化底座,适合中小规模、单机、单写者场景;
- 记忆层 用三层模型(短期/长期/语义)组织 Agent 的经验;
- Embedding 让记忆可被语义检索,
shelve+ 余弦相似度是最低门槛的实现; - Copilot 层提供可解释的辅助决策,策略可插拔;
- Harness 让 Agent 行为可复现、可测试,是可靠性的基石;
- 复杂工程代码 把所有组件组装成一个可运行的系统,零第三方依赖。
最重要的不是某个具体技术,而是分层解耦、依赖注入、可测试性这些工程思想。它们让系统能在不同规模、不同算力、不同场景下平滑演进。shelve 会过时,但这些思想不会。
希望这份报告能成为你构建机器人 Agent 系统的一块垫脚石。代码都可以直接运行,建议你亲手跑一遍,再按自己的需求改造——工程能力,永远是在"改"中长出来的。

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐



所有评论(0)