一文读懂：提示工程架构师的边缘智能提示系统设计门道
引言：边缘智能与提示工程的交汇点
在人工智能的浪潮中，我们正见证着一场静悄悄的革命。当大型语言模型(LLM)如GPT-4、Claude和PaLM在云端展现出惊人能力时，另一场同样重要的变革正在边缘设备上悄然发生——这就是边缘智能提示系统的崛起。
作为一名拥有15年经验的软件架构师，我有幸亲历了从传统软件开发到云原生架构，再到如今边缘智能时代的技术演进。在这个过程中，我发现一个新的关键角色正在形成：提示工程架构师。这个角色不仅需要精通提示工程的艺术与科学，还要深谙边缘计算的限制与潜能，能够在资源受限的环境中设计出高效、智能且可靠的提示系统。
本文将带领你深入探索提示工程架构师的核心领地——边缘智能提示系统的设计门道。我们将从基础概念到高级设计，从数学模型到实战代码，全面解析这一新兴领域的关键技术与最佳实践。
1. 边缘智能提示系统概述
1.1 什么是边缘智能提示系统？
边缘智能提示系统是一种部署在物理设备或接近数据源的边缘节点上，能够接收、处理、优化和生成提示，以驱动本地AI模型进行推理和决策的智能系统。
想象一下：你家中的智能音箱能够在断网情况下仍能理解你的基本指令；工厂的传感器不仅能够检测异常，还能智能提示可能的故障原因；自动驾驶汽车在毫秒级时间内根据环境变化生成安全驾驶提示。这些场景都依赖于高效的边缘智能提示系统。
与传统的云端提示系统相比，边缘智能提示系统具有以下显著特点：
| 特性 | 云端提示系统 | 边缘智能提示系统 |
|---|---|---|
| 部署位置 | 远程数据中心 | 本地设备或边缘节点 |
| 网络依赖 | 高度依赖网络连接 | 可离线或弱网运行 |
| 响应延迟 | 较高(几十到几百毫秒) | 极低(几毫秒到亚毫秒) |
| 数据隐私 | 数据需上传至云端 | 数据本地处理 |
| 资源消耗 | 几乎无本地资源限制 | 受限于边缘设备资源 |
| 可靠性 | 依赖云服务可用性 | 本地独立运行 |
1.2 提示工程架构师的角色与职责
提示工程架构师是边缘智能提示系统的设计者和建造者，他们需要融合提示工程、边缘计算、AI模型优化和系统架构设计的多方面知识。其核心职责包括：
- 系统架构设计：设计边缘提示系统的整体架构，包括模块划分、通信机制和资源管理策略
- 提示优化：开发适合边缘环境的提示优化技术，在有限资源下最大化AI模型效能
- 模型适配：选择和优化适合边缘部署的AI模型，实现提示与模型的高效协同
- 资源管理：设计在受限资源环境下的计算、存储和网络资源分配策略
- 性能调优：优化系统响应时间、吞吐量和能源效率
- 安全设计：确保提示数据的保密性、完整性和可用性
- 标准化与可扩展性：设计可扩展的系统架构，支持不同边缘设备和AI模型
1.3 边缘智能提示系统的核心组件
一个典型的边缘智能提示系统包含以下核心组件：
- 提示输入模块：接收来自用户、传感器或其他系统的原始提示输入
- 提示预处理模块：对原始提示进行清洗、标准化和特征提取
- 提示优化引擎：核心模块，负责提示重写、压缩、适配和增强
- 提示缓存管理器：管理常用提示的缓存，提高响应速度和资源利用率
- 模型推理协调器：根据提示类型和资源状况，选择合适的模型和推理策略
- 本地模型库：存储和管理边缘设备上的轻量级AI模型
- 边缘模型服务：提供跨设备的模型共享和分布式推理能力
- 推理结果处理器：处理模型输出，生成有意义的结果
- 提示反馈学习模块：基于推理结果和用户反馈，持续优化提示策略
- 输出生成模块：将处理结果格式化为用户或下游系统可理解的输出
- 资源监控与管理模块：监控和管理边缘设备的计算、存储和网络资源
- 安全与隐私保护模块：确保整个提示处理流程的安全性和隐私保护
2. 边缘智能提示系统设计原则
2.1 资源感知设计原则
边缘设备的资源限制是设计边缘智能提示系统时必须首要考虑的因素。资源感知设计要求系统能够动态感知和适应边缘设备的资源状况，包括CPU、内存、存储、电池电量和网络带宽。
2.1.1 资源约束模型
我们可以用以下数学模型表示边缘设备的资源约束：
设边缘设备的资源集合为 R={CPU,MEM,STORAGE,BATTERY,BANDWIDTH}R = \{CPU, MEM, STORAGE, BATTERY, BANDWIDTH\}R={CPU,MEM,STORAGE,BATTERY,BANDWIDTH}，每个资源有其最大容量 RmaxR_{max}Rmax 和当前利用率 RutilR_{util}Rutil，则可用资源 Ravail=Rmax×(1−Rutil)R_{avail} = R_{max} \times (1 - R_{util})Ravail=Rmax×(1−Rutil)。
提示系统的资源需求 Sreq={CPUreq,MEMreq,STORAGEreq,ENERGYreq,BANDWIDTHreq}S_{req} = \{CPU_{req}, MEM_{req}, STORAGE_{req}, ENERGY_{req}, BANDWIDTH_{req}\}Sreq={CPUreq,MEMreq,STORAGEreq,ENERGYreq,BANDWIDTHreq} 必须满足：
∀r∈R:Sreq(r)≤Ravail(r)\forall r \in R: S_{req}(r) \leq R_{avail}(r)∀r∈R:Sreq(r)≤Ravail(r)
当系统检测到资源不足时，需要触发资源适配策略，如降低提示复杂度、切换到更轻量级的模型或延迟非关键任务。
2.1.2 资源自适应算法
以下是一个简单的资源自适应提示处理算法示例，根据当前CPU利用率动态调整提示处理策略：
def adaptive_prompt_processing(prompt, cpu_utilization, memory_utilization):
"""
根据CPU和内存利用率动态调整提示处理策略
参数:
prompt: 原始提示文本
cpu_utilization: 当前CPU利用率(0-1)
memory_utilization: 当前内存利用率(0-1)
返回:
processed_prompt: 处理后的提示
model_selection: 推荐的模型选择
"""
# 基础策略
processing_strategy = {
"prompt_compression": 0.0, # 0-1，压缩程度
"prompt_enhancement": True, # 是否增强提示
"model_size": "medium", # 模型大小: small, medium, large
"max_tokens": 1024 # 最大token数
}
# 高CPU利用率时的调整策略
if cpu_utilization > 0.8:
processing_strategy["prompt_compression"] = 0.7
processing_strategy["prompt_enhancement"] = False
processing_strategy["model_size"] = "small"
processing_strategy["max_tokens"] = 512
elif cpu_utilization > 0.5:
processing_strategy["prompt_compression"] = 0.3
processing_strategy["model_size"] = "medium"
processing_strategy["max_tokens"] = 768
# 高内存利用率时的调整策略
if memory_utilization > 0.8:
processing_strategy["model_size"] = "small"
processing_strategy["max_tokens"] = 384
# 清理缓存
clear_prompt_cache(threshold=0.5) # 清理50%的缓存
# 应用处理策略
processed_prompt = prompt
if processing_strategy["prompt_compression"] > 0:
processed_prompt = compress_prompt(
prompt,
compression_level=processing_strategy["prompt_compression"]
)
if processing_strategy["prompt_enhancement"]:
processed_prompt = enhance_prompt(processed_prompt)
# 确保不超过最大token数
processed_prompt = truncate_prompt(
processed_prompt,
max_tokens=processing_strategy["max_tokens"]
)
return processed_prompt, processing_strategy["model_size"]
2.2 低延迟设计原则
边缘智能提示系统通常用于实时或近实时应用场景，如工业控制、自动驾驶和实时监控等，因此低延迟设计至关重要。
2.2.1 延迟来源分析
边缘智能提示系统的延迟主要来源于以下几个方面：
- 提示处理延迟：提示的接收、解析、优化和格式化所需时间
- 模型推理延迟：AI模型处理提示并生成响应所需时间
- 数据传输延迟：系统组件间或与外部设备通信的延迟
- 资源调度延迟：系统资源分配和任务调度的延迟
我们可以用以下公式表示系统总延迟 TtotalT_{total}Ttotal：
Ttotal=Tprompt+Tinference+Tcommunication+TschedulingT_{total} = T_{prompt} + T_{inference} + T_{communication} + T_{scheduling}Ttotal=Tprompt+Tinference+Tcommunication+Tscheduling
其中：
- TpromptT_{prompt}Tprompt: 提示处理延迟
- TinferenceT_{inference}Tinference: 模型推理延迟
- TcommunicationT_{communication}Tcommunication: 通信延迟
- TschedulingT_{scheduling}Tscheduling: 调度延迟
2.2.2 低延迟优化策略
为实现低延迟设计，提示工程架构师可以采用以下策略：
- 提示预处理缓存：缓存常用提示的预处理结果
- 模型推理优化：使用模型量化、剪枝和蒸馏等技术加速推理
- 硬件加速：利用边缘设备的硬件加速能力(如GPU、TPU、NPU)
- 任务优先级：为关键提示任务设置高优先级
- 预计算与预加载：预计算可能的提示响应并加载到内存
- 异步处理：将非关键提示处理任务异步化
以下是一个实现提示预处理缓存的示例代码：
class PromptPreprocessingCache:
def __init__(self, max_cache_size=1000, ttl_seconds=3600):
"""
提示预处理缓存
参数:
max_cache_size: 缓存的最大条目数
ttl_seconds: 缓存条目的生存时间(秒)
"""
self.cache = {}
self.max_cache_size = max_cache_size
self.ttl_seconds = ttl_seconds
self.access_order = [] # 用于LRU淘汰策略
def get(self, prompt, context_params):
"""获取缓存的预处理结果"""
cache_key = self._generate_cache_key(prompt, context_params)
# 检查缓存是否存在且未过期
if cache_key in self.cache:
entry = self.cache[cache_key]
current_time = time.time()
if current_time - entry["timestamp"] < self.ttl_seconds:
# 更新访问顺序(LRU策略)
if cache_key in self.access_order:
self.access_order.remove(cache_key)
self.access_order.append(cache_key)
return entry["preprocessed_prompt"]
return None
def put(self, prompt, context_params, preprocessed_prompt):
"""存储预处理结果到缓存"""
cache_key = self._generate_cache_key(prompt, context_params)
current_time = time.time()
# 如果缓存已满，使用LRU策略淘汰最久未使用的条目
if len(self.cache) >= self.max_cache_size and cache_key not in self.cache:
oldest_key = self.access_order.pop(0)
del self.cache[oldest_key]
# 存储缓存条目
self.cache[cache_key] = {
"preprocessed_prompt": preprocessed_prompt,
"timestamp": current_time
}
# 更新访问顺序
if cache_key in self.access_order:
self.access_order.remove(cache_key)
self.access_order.append(cache_key)
def _generate_cache_key(self, prompt, context_params):
"""生成唯一的缓存键"""
context_str = json.dumps(context_params, sort_keys=True)
return hashlib.md5(f"{prompt}|{context_str}".encode()).hexdigest()
def clear_expired(self):
"""清理过期的缓存条目"""
current_time = time.time()
expired_keys = [
key for key, entry in self.cache.items()
if current_time - entry["timestamp"] >= self.ttl_seconds
]
for key in expired_keys:
del self.cache[key]
if key in self.access_order:
self.access_order.remove(key)
2.3 可靠性设计原则
边缘设备通常工作在复杂多变的物理环境中，如工厂车间、户外场景等，因此边缘智能提示系统必须具备高度的可靠性。
2.3.1 故障模式分析
边缘智能提示系统可能面临的主要故障模式包括：
- 硬件故障：CPU、内存、存储或传感器故障
- 软件故障：操作系统、驱动程序或应用程序崩溃
- 网络故障：边缘节点间或与云端的连接中断
- 电源故障：电力供应不稳定或中断
- 数据故障：输入数据损坏、丢失或异常
- 模型故障：AI模型推理错误或性能下降
2.3.2 可靠性保障策略
为提高系统可靠性，提示工程架构师可以采用以下策略：
- 冗余设计：关键组件的硬件或软件冗余
- 故障检测与恢复：实时监控系统健康状态，自动检测并恢复故障
- 降级策略：定义明确的系统降级策略，在资源不足或组件故障时保证核心功能
- 数据校验：对输入输出数据进行校验，确保数据完整性
- 模型鲁棒性：增强提示和模型对噪声数据的容忍能力
- 版本控制：对提示模板和模型进行版本控制，支持回滚
以下是一个简单的系统健康监控与降级策略实现：
class SystemHealthMonitor:
def __init__(self, critical_components,降级_thresholds):
"""
系统健康监控器
参数:
critical_components: 需要监控的关键组件列表
降级_thresholds: 触发降级的阈值字典
"""
self.critical_components = critical_components
self.降级_thresholds = 降级_thresholds
self.current_health = {component: 1.0 for component in critical_components} # 1.0表示完全健康
self.system_mode = "normal" # normal, degraded, emergency
def update_health_status(self, component_metrics):
"""更新组件健康状态"""
for component, metrics in component_metrics.items():
if component in self.current_health:
# 根据指标计算健康分数(0-1)
health_score = self._calculate_health_score(component, metrics)
self.current_health[component] = health_score
# 确定系统模式
self._determine_system_mode()
return self.system_mode
def _calculate_health_score(self, component, metrics):
"""根据组件指标计算健康分数"""
if component == "cpu":
# CPU健康分数与利用率负相关
return max(0, 1.0 - (metrics["utilization"] / self.降级_thresholds[component]["max_utilization"]))
elif component == "memory":
# 内存健康分数与使用率负相关
return max(0, 1.0 - (metrics["usage"] / self.降级_thresholds[component]["max_usage"]))
elif component == "storage":
# 存储健康分数与使用率负相关
return max(0, 1.0 - (metrics["usage"] / self.降级_thresholds[component]["max_usage"]))
elif component == "network":
# 网络健康分数基于延迟和丢包率
latency_factor = max(0, 1.0 - (metrics["latency"] / self.降级_thresholds[component]["max_latency"]))
packet_loss_factor = max(0, 1.0 - metrics["packet_loss"])
return (latency_factor * 0.7 + packet_loss_factor * 0.3)
elif component == "model_service":
# 模型服务健康分数基于可用性和响应时间
availability_factor = metrics["availability"]
response_time_factor = max(0, 1.0 - (metrics["response_time"] / self.降级_thresholds[component]["max_response_time"]))
return (availability_factor * 0.8 + response_time_factor * 0.2)
else:
return 1.0 # 未知组件默认为健康
def _determine_system_mode(self):
"""根据组件健康状态确定系统模式"""
# 计算整体健康分数(加权平均)
weights = {
"cpu": 0.2,
"memory": 0.2,
"storage": 0.1,
"network": 0.1,
"model_service": 0.4
}
overall_health = sum(
self.current_health[component] * weights.get(component, 0.1)
for component in self.current_health
) / sum(weights.get(component, 0.1) for component in self.current_health)
# 根据整体健康分数确定系统模式
if overall_health > 0.8:
self.system_mode = "normal"
elif overall_health > 0.5:
self.system_mode = "degraded"
else:
self.system_mode = "emergency"
def get_degradation_strategy(self):
"""获取当前系统模式下的降级策略"""
if self.system_mode == "normal":
return {
"prompt_compression": 0.0,
"use_heavy_models": True,
"enable_enhancements": True,
"cache_ttl": 3600,
"max_tokens": 2048
}
elif self.system_mode == "degraded":
return {
"prompt_compression": 0.5,
"use_heavy_models": False,
"enable_enhancements": False,
"cache_ttl": 7200, # 延长缓存时间
"max_tokens": 1024
}
else: # emergency mode
return {
"prompt_compression": 0.8,
"use_heavy_models": False,
"enable_enhancements": False,
"cache_ttl": 14400, # 大幅延长缓存时间
"max_tokens": 512,
"enable_fallback": True, # 使用简化的回退逻辑
"critical_only": True # 只处理关键提示
}
2.4 数据隐私与安全设计原则
边缘智能提示系统通常处理敏感的本地数据，如工业数据、医疗信息或个人隐私数据，因此数据隐私与安全是设计时必须考虑的核心原则。
2.4.1 隐私保护策略
提示工程架构师可以采用以下隐私保护策略：
- 数据本地化：敏感数据在本地处理，不向云端传输原始数据
- 数据匿名化：对提示数据进行匿名化处理，去除个人身份信息(PII)
- 联邦学习：在保护数据隐私的前提下进行模型更新和优化
- 差分隐私：在提示数据中添加适量噪声，保护个体隐私
- 安全多方计算：在多个边缘节点间安全共享计算结果，不泄露原始数据
2.4.2 安全防护措施
为保护边缘智能提示系统免受安全威胁，应采取以下防护措施：
- 安全引导：确保边缘设备的安全启动过程
- 加密通信：组件间通信采用加密通道(如TLS/DTLS)
- 访问控制：实施严格的身份验证和授权机制
- 代码签名：验证提示模板和模型的完整性和真实性
- 异常检测：监控和检测异常提示模式，防止提示注入攻击
- 安全更新：提供安全的系统和模型更新机制
以下是一个实现提示数据匿名化的示例代码：
class PromptAnonymizer:
def __init__(self, pii_detectors=None, replacement_strategy="placeholder"):
"""
提示数据匿名化器
参数:
pii_detectors: PII检测器列表
replacement_strategy: 替换策略: placeholder, mask, shuffle
"""
# 初始化默认PII检测器
self.pii_detectors = pii_detectors or self._init_default_detectors()
self.replacement_strategy = replacement_strategy
self.entity_map = {} # 用于存储实体映射关系，保持一致性
def _init_default_detectors(self):
"""初始化默认的PII检测器"""
detectors = []
# 加载预训练的NER模型用于通用PII检测
try:
import spacy
self.nlp = spacy.load("en_core_web_sm")
detectors.append(self._spacy_ner_detector)
except ImportError:
pass
# 添加特定的正则表达式检测器
detectors.extend([
self._email_detector,
self._phone_detector,
self._credit_card_detector,
self._ssn_detector,
self._ip_address_detector
])
return detectors
def anonymize(self, prompt, preserve_context=False):
"""
对提示进行匿名化处理
参数:
prompt: 原始提示文本
preserve_context: 是否保留实体之间的上下文关系
返回:
anonymized_prompt: 匿名化后的提示
entity_info: 被匿名化的实体信息(用于后续恢复，如果需要)
"""
entities = []
# 使用所有检测器识别PII实体
for detector in self.pii_detectors:
detected_entities = detector(prompt)
entities.extend(detected_entities)
# 去重和排序(按在文本中出现的位置)
unique_entities = self._deduplicate_entities(entities)
sorted_entities = sorted(unique_entities, key=lambda x: x["start"])
# 应用替换策略
anonymized_prompt, entity_info = self._apply_replacement(
prompt, sorted_entities, preserve_context
)
return anonymized_prompt, entity_info
def _deduplicate_entities(self, entities):
"""去除重复或重叠的实体"""
if not entities:
return []
# 按长度排序，较长的实体优先(避免子串被误检测)
sorted_entities = sorted(entities, key=lambda x: x["end"] - x["start"], reverse=True)
unique_entities = []
for entity in sorted_entities:
overlap = False
# 检查与已有实体是否重叠
for existing in unique_entities:
if not (entity["end"] <= existing["start"] or entity["start"] >= existing["end"]):
overlap = True
break
if not overlap:
unique_entities.append(entity)
return unique_entities
def _apply_replacement(self, prompt, entities, preserve_context):
"""应用替换策略到识别出的实体"""
entity_info = []
anonymized_parts = []
last_end = 0
# 按出现顺序处理实体
for entity in entities:
entity_type = entity["type"]
entity_value = entity["value"]
start = entity["start"]
end = entity["end"]
# 添加实体前的文本
anonymized_parts.append(prompt[last_end:start])
# 根据策略生成替换值
if preserve_context and entity_value in self.entity_map:
# 如果需要保留上下文且已有映射，使用相同替换值
replacement = self.entity_map[entity_value]
else:
# 生成新的替换值
if self.replacement_strategy == "placeholder":
replacement = f"[{entity_type.upper()}]"
elif self.replacement_strategy == "mask":
replacement = "*" * len(entity_value)
elif self.replacement_strategy == "shuffle":
# 随机打乱字符顺序(对某些实体类型有效)
chars = list(entity_value)
random.shuffle(chars)
replacement = ''.join(chars)
else:
replacement = f"[{entity_type.upper()}]"
# 记录实体映射关系
if preserve_context:
self.entity_map[entity_value] = replacement
# 添加替换值
anonymized_parts.append(replacement)
# 记录实体信息
entity_info.append({
"original_value": entity_value,
"replacement_value": replacement,
"type": entity_type,
"start": start,
"end": end
})
last_end = end
# 添加剩余文本
anonymized_parts.append(prompt[last_end:])
return ''.join(anonymized_parts), entity_info
# 各种PII检测器实现
def _spacy_ner_detector(self, text):
"""使用spaCy的NER检测PII实体"""
doc = self.nlp(text)
entities = []
# 关注PII相关的实体类型
pii_entity_types = {"PERSON", "ORG", "GPE", "LOC", "DATE", "TIME", "MONEY", "QUANTITY"}
for ent in doc.ents:
if ent.label_ in pii_entity_types:
entities.append({
"type": ent.label_.lower(),
"value": ent.text,
"start": ent.start_char,
"end": ent.end_char
})
return entities
def _email_detector(self, text):
"""检测电子邮件地址"""
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
return self._regex_detector(text, email_pattern, "email")
def _phone_detector(self, text):
"""检测电话号码"""
phone_pattern = r'\b(?:\+?86)?1[3-9]\d{9}\b|\+?\d{1,3}[-.\s]?\(?\d{1,4}?\)?[-.\s]?\d{1,4}[-.\s]?\d{1,9}\b'
return self._regex_detector(text, phone_pattern, "phone")
def _credit_card_detector(self, text):
"""检测信用卡号"""
cc_pattern = r'\b(?:\d{4}[-\s]?){3}\d{4}\b|\b\d{16}\b'
return self._regex_detector(text, cc_pattern, "credit_card")
def _ssn_detector(self, text):
"""检测社会安全号码(SSN)"""
ssn_pattern = r'\b\d{3}-\d{2}-\d{4}\b'
return self._regex_detector(text, ssn_pattern, "ssn")
def _ip_address_detector(self, text):
"""检测IP地址"""
ip_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
return self._regex_detector(text, ip_pattern, "ip_address")
def _regex_detector(self, text, pattern, entity_type):
"""通用正则表达式检测器"""
entities = []
for match in re.finditer(pattern, text):
entities.append({
"type": entity_type,
"value": match.group(),
"start": match.start(),
"end": match.end()
})
return entities
3. 边缘提示优化技术
3.1 提示压缩技术
在边缘环境中，提示长度直接影响处理时间、内存占用和推理延迟。提示压缩技术旨在减少提示的大小，同时保留关键信息和语义。
3.1.1 提示压缩的数学模型
设原始提示为 PPP，长度为 L(P)L(P)L(P)，压缩后的提示为 P′P'P′，长度为 L(P′)L(P')L(P′)。压缩率 CrC_rCr 定义为：
Cr=1−L(P′)L(P)C_r = 1 - \frac{L(P')}{L(P)}Cr=1−L(P)L(P′)
理想的提示压缩应满足：
- 高压缩率：CrC_rCr 尽可能接近1
- 语义保留：压缩后的提示 P′P'P′ 应保留 PPP 的核心语义
- 推理效果保持：使用 P′P'P′ 进行推理的效果应接近或达到使用 PPP 的效果
我们可以将提示压缩视为一个优化问题，目标是最大化压缩率同时最小化推理效果损失：
maxCrs.t.E(P′)≥α⋅E(P)\max C_r \quad \text{s.t.} \quad E(P') \geq \alpha \cdot E(P)maxCrs.t.E(P′)≥α⋅E(P)
其中 E(P)E(P)E(P) 是使用提示 PPP 时的模型推理效果，α\alphaα 是可接受的效果损失阈值(通常为0.9或更高)。
3.1.2 提示压缩算法实现
以下是几种常用的提示压缩技术及其实现：
1. 基于关键词提取的压缩
def keyword_based_prompt_compression(prompt, compression_ratio=0.5, keep_original_structure=True):
"""
基于关键词提取的提示压缩
参数:
prompt: 原始提示文本
compression_ratio: 期望的压缩率(0-1)
keep_original_structure: 是否保持原始提示的结构
返回:
compressed_prompt:压缩后的提示
"""
# 计算目标长度
original_length = len(prompt.split())
target_length = max(5, int(original_length * (1 - compression_ratio)))
if original_length <= target_length:
return prompt
# 使用TextRank算法提取关键词
keywords = extract_keywords(prompt, top_n=target_length)
if not keep_original_structure:
# 直接返回关键词组合
return " ".join(keywords)
else:
# 尝试保留原始句子结构
sentences = sent_tokenize(prompt)
compressed_sentences = []
for sentence in sentences:
# 对每个句子提取关键词
sent_keywords = extract_keywords(sentence, top_n=max(1, int(len(sentence.split()) * (1 - compression_ratio))))
# 简单保留原始句子结构，只保留关键词
# 这里可以使用更复杂的算法来重构句子
compressed_sentence = " ".join(sent_keywords)
compressed_sentences.append(compressed_sentence)
return " ".join(compressed_sentences)
def extract_keywords(text, top_n=5):
"""使用TextRank算法提取关键词"""
from summa import keywords
# 提取关键词，设置分数阈值为0
extracted_keywords = keywords.keywords(text, ratio=0.2, scores=True)
# 按分数排序并取前top_n个关键词
extracted_keywords.sort(key=lambda x: x[1], reverse=True)
top_keywords = [kw for kw, score in extracted_keywords[:top_n]]
return top_keywords
2. 基于Transformer的提示压缩
class TransformerPromptCompressor:
def __init__(self, model_name="t5-small", device=None):
"""
基于Transformer的提示压缩器
参数:
model_name: 预训练模型名称
device: 运行设备(cpu或cuda)
"""
self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
# 加载预训练的T5模型和分词器
from transformers import T5Tokenizer, T5ForConditionalGeneration
self.tokenizer = T5Tokenizer.from_pretrained(model_name)
self.model = T5ForConditionalGeneration.from_pretrained(model_name).to(self.device)
# 模型评估模式
self.model.eval()
def compress(self, prompt, target_length_ratio=0.5, max_length=None):
"""
压缩提示文本
参数:
prompt: 原始提示文本
target_length_ratio: 目标长度与原始长度的比率
max_length: 最大长度(若指定则忽略target_length_ratio)
返回:
compressed_prompt: 压缩后的提示
"""
# 计算原始长度(以token为单位)
inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True).to(self.device)
original_length = inputs.input_ids.shape[1]
# 确定目标长度
if max_length is None:
target_length = max(8, int(original_length * target_length_ratio))
else:
target_length = max_length
if original_length <= target_length:
return prompt
# 构建压缩任务提示
compression_prompt = f"compress: {prompt}"
# 编码输入
inputs = self.tokenizer(
compression_prompt,
return_tensors="pt",
truncation=True,
max_length=512
).to(self.device)
# 生成压缩后的文本
with torch.no_grad():
outputs = self.model.generate(
**inputs,
max_length=target_length + 20, # 稍微放宽限制
min_length=max(5, int(target_length * 0.8)),
length_penalty=2.0, # 鼓励生成较短文本
num_beams=4,
early_stopping=True
)
# 解码输出
compressed_prompt = self.tokenizer.decode(
outputs[0],
skip_special_tokens=True,
clean_up_tokenization_spaces=True
)
# 如果生成的文本太短，尝试调整参数重试
if len(compressed_prompt.split()) < max(5, int(target_length * 0.5)):
with torch.no_grad():
outputs = self.model.generate(
**inputs,
max_length=target_length + 20,
min_length=target_length,
length_penalty=1.0, # 降低长度惩罚
num_beams=4,
early_stopping=True
)
compressed_prompt = self.tokenizer.decode(
outputs[0],
skip_special_tokens=True,
clean_up_tokenization_spaces=True
)
return compressed_prompt
def batch_compress(self, prompts, target_length_ratios=None, max_lengths=None):
"""批量压缩提示文本"""
results = []
for i, prompt in enumerate(prompts):
target_ratio = target_length_ratios[i] if target_length_ratios else 0.5
max_len = max_lengths[i] if max_lengths else None
compressed = self.compress(prompt, target_ratio, max_len)
results.append(compressed)
return results
3. 基于语义相似度的提示压缩
def semantic_similarity_prompt_compression(prompt, compression_ratio=0.5, model_name="all-MiniLM-L6-v2"):
"""
基于语义相似度的提示压缩
参数:
prompt: 原始提示文本
compression_ratio: 期望的压缩率(0-1)
model_name: 用于嵌入的模型名称
返回:
compressed_prompt: 压缩后的提示
"""
from sentence_transformers import SentenceTransformer, util
# 分割句子
sentences = sent_tokenize(prompt)
if len(sentences) <= 2:
return keyword_based_prompt_compression(prompt, compression_ratio)
# 计算目标句子数量
target_num_sentences = max(1, int(len(sentences) * (1 - compression_ratio)))
if len(sentences) <= target_num_sentences:
return prompt
# 加载嵌入模型
model = SentenceTransformer(model_name)
# 计算句子嵌入
sentence_embeddings = model.encode(sentences, convert_to_tensor=True)
# 计算句子与整个文档的相似度
document_embedding = model.encode(prompt, convert_to_tensor=True)
similarities = util.cos_sim(sentence_embeddings, document_embedding).squeeze().tolist()
# 结合句子位置信息(通常开头和结尾的句子更重要)
position_weights = []
for i, _ in enumerate(sentences):
# 位置权重: 开头和结尾的句子权重较高
pos = i / (len(sentences) - 1) if len(sentences) > 1 else 0.5
weight = 1.0 - abs(pos - 0.5) * 1.5 # 中心降低权重，两端提高权重
position_weights.append(weight)
# 综合相似度和位置权重得到最终分数
combined_scores = [s * w for s, w in zip(similarities, position_weights)]
# 选择分数最高的句子
top_indices = sorted(
range(len(combined_scores)),
key=lambda i: combined_scores[i],
reverse=True
)[:target_num_sentences]
# 按原始顺序排序
top_indices.sort()
# 构建压缩后的提示
compressed_sentences = [sentences[i] for i in top_indices]
compressed_prompt = " ".join(compressed_sentences)
# 如果仍过长，进一步使用关键词压缩
final_compressed = keyword_based_prompt_compression(
compressed_prompt,
compression_ratio=0.2 # 较小的二次压缩率
)
return final_compressed
3.2 提示模板化与参数化
提示模板化是一种将固定提示结构与可变参数分离的技术，能够显著减少重复提示内容的传输和存储开销，特别适合边缘环境。
3.2.1 提示模板化的优势
- 减少数据传输：只需传输参数而非完整提示
- 降低存储需求：模板只需存储一次，可重复使用
- 提高处理效率：模板可预编译或预加载，加速提示生成
- 增强一致性：确保相似任务使用一致的提示结构
- 简化维护：修改模板即可更新所有使用该模板的提示
3.2.2 提示模板引擎实现
class EdgePromptTemplateEngine:
def __init__(self, cache_size=50):
"""
边缘环境提示模板引擎
参数:
cache_size: 模板编译结果的缓存大小
"""
self.templates = {} # 存储模板: {template_id: (template_str, metadata)}
self.template_cache = LRUCache(max_size=cache_size) # 缓存编译后的模板
self.registered_functions = {
"date": self._fn_date,
"time": self._fn_time,
"format_number": self._fn_format_number,
"capitalize": self._fn_capitalize,
"lower": self._fn_lower,
"upper": self._fn_upper,
"if": self._fn_if,
"default": self._fn_default
}
def register_template(self, template_id, template_str, metadata=None):
"""
注册提示模板
参数:
template_id: 模板唯一标识符
template_str: 模板字符串
metadata: 模板元数据(如描述、参数列表等)
"""
# 验证模板字符串
self._validate_template(template_str)
# 存储模板
self.templates[template_id] = (template_str, metadata or {})
# 预编译模板并缓存
compiled_template = self._compile_template(template_str)
self.template_cache.put(template_id, compiled_template)
return True
def unregister_template(self, template_id):
"""注销提示模板"""
if template_id in self.templates:
del self.templates[template_id]
self.template_cache.delete(template_id)
return True
return False
def render_prompt(self, template_id, parameters, context=None):
"""
渲染提示模板
参数:
template_id: 模板ID
parameters: 模板参数字典
context: 渲染上下文(如当前时间、设备状态等)
返回:
rendered_prompt: 渲染后的提示文本
"""
if template_id not in self.templates:
raise ValueError(f"Template {template_id} not registered")
# 获取编译后的模板(从缓存或重新编译)
compiled_template = self.template_cache.get(template_id)
if compiled_template is None:
template_str, _ = self.templates[template_id]
compiled_template = self._compile_template(template_str)
self.template_cache.put(template_id, compiled_template)
# 合并参数和上下文
render_context = {**(context or {}), **parameters}
# 渲染模板
try:
rendered_prompt = compiled_template(render_context)
return rendered_prompt
except Exception as e:
# 如果渲染失败，尝试使用简化模式
template_str, _ = self.templates[template_id]
return self._simple_render(template_str, parameters)
def _compile_template(self, template_str):
"""编译模板字符串为可执行函数"""
# 这里使用简单的模板语法: {{variable}} 或 {{function:arg1,arg2}}
# 将模板转换为Python字符串格式化函数
# 查找所有模板表达式
pattern = r'\{\{(.+?)\}\}'
tokens = re.split(pattern, template_str)
# 构建渲染函数代码
code = ["def render(context):\n", " result = []\n"]
for i, token in enumerate(tokens):
if i % 2 == 0:
# 文本部分
if token.strip():
code.append(f' result.append("{token.replace('"', '\\"')}")\n')
else:
# 表达式部分
expr = token.strip()
code.append(f" result.append(str(eval({repr(expr)}, {self.registered_functions}, context)))\n")
code.append(" return ''.join(result)")
# 执行代码并返回渲染函数
namespace = {}
exec('\n'.join(code), namespace)
return namespace['render']
def _validate_template(self, template_str):
"""验证模板字符串的语法"""
# 检查模板表达式是否匹配正确的格式
pattern = r'\{\{(.+?)\}\}'
for match in re.findall(pattern, template_str):
expr = match.strip()
# 简单验证表达式是否可能有效
if not re.match(r'^[a-zA-Z0-9_.:(),\s]*$', expr):
raise ValueError(f"Invalid template expression: {expr}")
def _simple_render(self, template_str, parameters):
"""简单渲染方法(当复杂渲染失败时使用)"""
# 使用简单的字符串替换
rendered = template_str
for key, value in parameters.items():
rendered = rendered.replace(f"{{{{{key}}}}}", str(value))
return rendered
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
