龍魂 · 记忆压缩引擎 v1.0 — Memory Compaction Engine (OpenClaw三层记忆模型吸收)

3天干完6个月的活,Claude把模型搬上AMD 一条挺刺激的消息:Anthropic 给投资人的材料里有一张幻灯片,写着它的 Claude Mythos Preview 只花了大约​,就摸清了怎么让另一个 Claude 模型在 AMD 的 MI355X 上跑起来。同一处还写了个对照数字:过去给一块新芯片做推理适配,通常要几十名工程师、​。3 天对 6 个月,这个比值太扎眼,当天中文互联网上就冒出一堆「英伟达的护城河塌了」的说法。我把能翻到的材料都翻了一遍,越看越觉得,塌掉的那一小块是真的,可塌的位置和很多人想的不一样。 阅读详情
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
🐉 龍魂 · 记忆压缩引擎 v1.0 — Memory Compaction Engine (OpenClaw三层记忆模型吸收)

来源: OpenClaw记忆系统最佳实践 (陈广亮, 2026-02-23)
吸收: Context→Compaction→MemoryFiles 三层记忆模型的Compaction自动压缩层
对标: OpenClaw memoryFlush + 遗忘曲线 + 写入路由

核心机制:
  1. Token阈值触发: 工作记忆接近耗尽时自动触发压缩
  2. 混合衰减: OpenClaw e^(-λ×age) 指数衰减 + 龍魂 η=T^(-α_τ) 幂律衰减
  3. 三层记忆流: Working(上下文) → Compaction(短期摘要) → Daily(每日日志)
  4. 防记忆污染: 验证过的知识→MEMORY.md, 临时结果→不写文件
  5. 静默写入: 同OpenClaw memoryFlush, 用户无感知

DNA: #龍芯⚡️丙午·丙申·癸丑·申时·需-MEMORY-COMPACTION-ENGINE-v1.0
来源: knowledge/ai-ecosystem/xclaw_openclaw_deep_learning_v1.0.md §2.2
确认: #CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z#ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️-DEVICE-BIND-SOUL
📇 项目身份 · 联系 · 支持 → assets/PUBLIC_IDENTITY.md
"""

from __future__ import annotations

import json
import math
import os
import pathlib
import re
import time
from dataclasses import dataclass, field
from datetime import datetime, timezone, timedelta
from enum import Enum
from typing import Any, Dict, List, Optional, Tuple

# 项目根路径
ROOT = pathlib.Path(__file__).resolve().parents[2]
MEMORY_DIR = ROOT / ".codebuddy" / "memory"
COMPACTION_STATE_FILE = ROOT / "L7_数据层" / "auto_compressor" / "compressor_state.json"
COMPACTION_LOG = ROOT / "L7_数据层" / "auto_compressor" / "compaction_events.jsonl"

DNA = "#龍芯⚡️丙午·丙申·癸丑·申时·需-MEMORY-COMPACTION-ENGINE-v1.0"


class CompactionLevel(str, Enum):
    """压缩级别"""
    LIGHT = "light"        # 轻度压缩: 合并连续消息
    MEDIUM = "medium"      # 中度压缩: 摘要生成
    HEAVY = "heavy"        # 重度压缩: 跨会话知识蒸馏
    FLUSH = "flush"        # Memory Flush: 静默写入文件


class DecayModel(str, Enum):
    """衰减模型"""
    EXPONENTIAL = "exponential"   # OpenClaw: e^(-λ×age)
    POWER_LAW = "power_law"       # 龍魂公式01: η=T^(-α_τ)
    DUAL = "dual"                 # 双模: 日志→指数, 规则→幂律


@dataclass
class TokenBudget:
    """Token预算管理"""
    context_window: int = 200000       # 上下文窗口总容量
    reserve_floor: int = 20000         # 预留token底限 (OpenClaw标准)
    soft_threshold_trigger: int = 4000 # 触发memoryFlush的软阈值
    current_usage: int = 0
    last_compaction_at: float = 0.0


@dataclass
class MemoryChunk:
    """记忆块"""
    id: str
    content: str
    source: str  # working / compacted / daily / permanent
    timestamp: float
    importance: float = 1.0  # 0.0-1.0
    decay_model: DecayModel = DecayModel.DUAL
    half_life_days: int = 30  # OpenClaw默认
    alpha_tau: float = 1.0    # 龍魂幂律衰减系数
    verified: bool = False    # 是否经验证
    tags: List[str] = field(default_factory=list)


@dataclass
class CompactionResult:
    """压缩结果"""
    level: CompactionLevel
    input_chunks: int
    output_chunks: int
    token_saved: int
    compression_ratio: float
    duration_ms: float
    summary: str
    dna: str


class MemoryCompactionEngine:
    """
    龍魂记忆压缩引擎
    
    吸收OpenClaw三层记忆模型, 为龍魂工作记忆增加自动压缩层。
    
    工作流:
      Working Memory (上下文窗口)
        ↓ Token接近耗尽
      Compaction (自动摘要压缩)  ← 本引擎核心
        ↓ Memory Flush静默写入
      Memory Files (持久化Markdown)
        ↓ 夜反思归档
      MEMORY.md (长期策略记忆)
    """

    DNA = DNA

    # Token估算: 中文约1.5字符/token, 英文约4字符/token
    CHARS_PER_TOKEN = 2.5

    # 各压缩级别的触发阈值 (token剩余百分比)
    THRESHOLDS = {
        CompactionLevel.LIGHT:  0.70,  # 剩余70%时轻度合并
        CompactionLevel.MEDIUM: 0.50,  # 剩余50%时摘要生成
        CompactionLevel.HEAVY:  0.30,  # 剩余30%时知识蒸馏
        CompactionLevel.FLUSH:  0.15,  # 剩余15%时静默写入
    }

    # 写入路由规则 (对标OpenClaw)
    WRITE_ROUTES = {
        "user_preference": "MEMORY.md",       # 用户偏好
        "strategic_decision": "MEMORY.md",    # 策略决策
        "lesson_learned": "MEMORY.md",        # 经验教训
        "project_state": "MEMORY.md",         # 长期项目状态
        "daily_progress": "memory/YYYY-MM-DD.md",  # 当日任务进展
        "temp_decision": "memory/YYYY-MM-DD.md",   # 临时决策
        "tech_research": "memory/YYYY-MM-DD.md",   # 技术调研
        "todo_item": "memory/YYYY-MM-DD.md",       # 待办
    }

    # 禁止写入的类型
    FORBIDDEN_WRITE = [
        "api_key", "password", "token", "secret",
        "temp_calculation", "tool_raw_output", "sensitive_credential",
    ]

    def __init__(self, root: pathlib.Path = ROOT):
        self.root = root
        self.memory_dir = root / ".codebuddy" / "memory"
        self.token_budget = TokenBudget()
        self.chunks: List[MemoryChunk] = []
        self.history: List[CompactionResult] = []
        self._load_state()

    # ───────────────── 状态持久化 ─────────────────

    def _load_state(self) -> None:
        """加载压缩器状态"""
        if COMPACTION_STATE_FILE.exists():
            try:
                state = json.loads(COMPACTION_STATE_FILE.read_text("utf-8"))
                self.token_budget = TokenBudget(**state.get("token_budget", {}))
                self.chunks = [
                    MemoryChunk(**c) for c in state.get("chunks", [])
                ]
            except Exception:
                pass

    def _save_state(self) -> None:
        """保存压缩器状态"""
        COMPACTION_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
        state = {
            "dna": self._gen_dna("STATE-SAVE"),
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "token_budget": {
                "context_window": self.token_budget.context_window,
                "reserve_floor": self.token_budget.reserve_floor,
                "soft_threshold_trigger": self.token_budget.soft_threshold_trigger,
                "current_usage": self.token_budget.current_usage,
                "last_compaction_at": self.token_budget.last_compaction_at,
            },
            "chunks": [
                {
                    "id": c.id,
                    "content": c.content[:200] + "..." if len(c.content) > 200 else c.content,
                    "source": c.source,
                    "timestamp": c.timestamp,
                    "importance": c.importance,
                    "decay_model": c.decay_model.value,
                    "half_life_days": c.half_life_days,
                    "alpha_tau": c.alpha_tau,
                    "verified": c.verified,
                    "tags": c.tags,
                }
                for c in self.chunks
            ],
        }
        COMPACTION_STATE_FILE.write_text(json.dumps(state, ensure_ascii=False, indent=2))

    def _log_event(self, event: Dict[str, Any]) -> None:
        """记录压缩事件到JSONL"""
        COMPACTION_LOG.parent.mkdir(parents=True, exist_ok=True)
        with open(COMPACTION_LOG, "a", encoding="utf-8") as f:
            f.write(json.dumps(event, ensure_ascii=False, default=str) + "\n")

    # ───────────────── Token估算 ─────────────────

    @staticmethod
    def estimate_tokens(text: str) -> int:
        """估算文本占用的token数"""
        if not text:
            return 0
        # 简化的token估算: 中英文混合
        chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', text))
        other_chars = len(text) - chinese_chars
        return int(chinese_chars / 1.5 + other_chars / 4.0)

    def total_tokens(self) -> int:
        """当前记忆库总token数"""
        return sum(self.estimate_tokens(c.content) for c in self.chunks)

    def remaining_tokens(self) -> int:
        """剩余可用token"""
        return max(0, self.token_budget.context_window - self.total_tokens() - self.token_budget.reserve_floor)

    def usage_ratio(self) -> float:
        """Token使用率"""
        return self.total_tokens() / self.token_budget.context_window

    # ───────────────── 衰减计算 ─────────────────

    @staticmethod
    def exponential_decay(initial_score: float, age_days: float, half_life: int = 30) -> float:
        """
        OpenClaw指数衰减: decayScore = score × e^(-λ × ageDays)
        λ = ln(2) / halfLifeDays
        """
        lam = math.log(2) / half_life
        return initial_score * math.exp(-lam * age_days)

    @staticmethod
    def power_law_decay(initial_score: float, age_days: float, alpha_tau: float = 1.0) -> float:
        """
        龍魂公式01幂律衰减: η = T^(-α_τ)
        L0永恒(α_τ=0, η=1) / L1百年(0.01) / L2十年(0.1) / L3日常(1.0) / L4瞬时(∞)
        """
        if alpha_tau <= 0:
            return initial_score  # L0永恒
        age_days = max(1, age_days)  # 避免除零
        return initial_score * (age_days ** (-alpha_tau))

    def get_chunk_score(self, chunk: MemoryChunk) -> float:
        """获取记忆块的衰减后得分"""
        age_days = (time.time() - chunk.timestamp) / 86400.0

        if chunk.decay_model == DecayModel.EXPONENTIAL:
            score = self.exponential_decay(chunk.importance, age_days, chunk.half_life_days)
        elif chunk.decay_model == DecayModel.POWER_LAW:
            score = self.power_law_decay(chunk.importance, age_days, chunk.alpha_tau)
        else:  # DUAL: 取加权平均
            exp_score = self.exponential_decay(chunk.importance, age_days, chunk.half_life_days)
            pl_score = self.power_law_decay(chunk.importance, age_days, chunk.alpha_tau)
            score = 0.5 * exp_score + 0.5 * pl_score

        return score

    # ───────────────── 核心压缩逻辑 ─────────────────

    def add_chunk(self, content: str, source: str = "working",
                  importance: float = 1.0, verified: bool = False,
                  tags: Optional[List[str]] = None,
                  decay_model: DecayModel = DecayModel.DUAL) -> str:
        """添加记忆块"""
        chunk_id = self._gen_dna("CHUNK")
        chunk = MemoryChunk(
            id=chunk_id,
            content=content,
            source=source,
            timestamp=time.time(),
            importance=importance,
            decay_model=decay_model,
            verified=verified,
            tags=tags or [],
        )
        self.chunks.append(chunk)
        self.token_budget.current_usage = self.total_tokens()

        # 检查是否需要触发压缩
        ratio = self.usage_ratio()
        if ratio > (1.0 - self.THRESHOLDS[CompactionLevel.FLUSH]):
            self.compact(CompactionLevel.FLUSH)
        elif ratio > (1.0 - self.THRESHOLDS[CompactionLevel.HEAVY]):
            self.compact(CompactionLevel.HEAVY)
        elif ratio > (1.0 - self.THRESHOLDS[CompactionLevel.MEDIUM]):
            self.compact(CompactionLevel.MEDIUM)
        elif ratio > (1.0 - self.THRESHOLDS[CompactionLevel.LIGHT]):
            self.compact(CompactionLevel.LIGHT)

        return chunk_id

    def compact(self, level: CompactionLevel = CompactionLevel.MEDIUM) -> CompactionResult:
        """执行记忆压缩"""
        start_time = time.time()
        input_count = len(self.chunks)
        tokens_before = self.total_tokens()

        if level == CompactionLevel.LIGHT:
            self._light_compact()
        elif level == CompactionLevel.MEDIUM:
            self._medium_compact()
        elif level == CompactionLevel.HEAVY:
            self._heavy_compact()
        elif level == CompactionLevel.FLUSH:
            self._memory_flush()

        tokens_after = self.total_tokens()
        token_saved = max(0, tokens_before - tokens_after)
        duration_ms = (time.time() - start_time) * 1000

        result = CompactionResult(
            level=level,
            input_chunks=input_count,
            output_chunks=len(self.chunks),
            token_saved=token_saved,
            compression_ratio=token_saved / max(1, tokens_before),
            duration_ms=duration_ms,
            summary=f"{level.value}压缩: {input_count}→{len(self.chunks)}块, 节省{token_saved}tokens ({duration_ms:.0f}ms)",
            dna=self._gen_dna(f"COMPACT-{level.value.upper()}"),
        )

        self.history.append(result)
        self.token_budget.last_compaction_at = time.time()
        self.token_budget.current_usage = tokens_after

        # 记录事件
        self._log_event({
            "event": "compaction",
            "level": level.value,
            "dna": result.dna,
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "input_chunks": input_count,
            "output_chunks": len(self.chunks),
            "token_saved": token_saved,
            "compression_ratio": result.compression_ratio,
            "duration_ms": duration_ms,
        })

        self._save_state()
        return result

    def _light_compact(self) -> None:
        """轻度压缩: 合并相邻同源的低重要度记忆块"""
        merged = []
        i = 0
        while i < len(self.chunks):
            chunk = self.chunks[i]
            # 查找相邻同源块
            j = i + 1
            combined = chunk.content
            while (j < len(self.chunks) and
                   self.chunks[j].source == chunk.source and
                   self.chunks[j].importance < 0.5 and
                   len(combined) < 2000):
                combined += "\n" + self.chunks[j].content
                j += 1

            if j > i + 1:
                # 合并成功
                chunk.content = combined
                chunk.tags.append("merged")
                i = j
            else:
                i += 1
            merged.append(chunk)

        self.chunks = merged

    def _medium_compact(self) -> None:
        """中度压缩: 低重要性记忆块做摘要, 高重要性保留"""
        kept = []
        for chunk in self.chunks:
            score = self.get_chunk_score(chunk)

            if score < 0.1:
                # 几乎遗忘: 丢弃
                continue
            elif score < 0.3:
                # 低重要性: 截断摘要
                if len(chunk.content) > 500:
                    chunk.content = chunk.content[:500] + "...[摘要已压缩]"
                    chunk.tags.append("compacted")
                kept.append(chunk)
            else:
                # 保留
                kept.append(chunk)

        self.chunks = kept

    def _heavy_compact(self) -> None:
        """重度压缩: 知识蒸馏 — 提取关键信息, 丢弃冗余"""
        # 先执行中度压缩
        self._medium_compact()

        # 对验证过的块做知识蒸馏
        verified = [c for c in self.chunks if c.verified]
        unverified = [c for c in self.chunks if not c.verified]

        # 未验证的记忆: 严重衰减
        for chunk in unverified:
            chunk.importance *= 0.3
            chunk.tags.append("distilled")

        # 验证过的记忆: 轻微衰减
        for chunk in verified:
            chunk.importance *= 0.8

        # 再次过滤
        self.chunks = [c for c in self.chunks if self.get_chunk_score(c) > 0.05]

    def _memory_flush(self) -> None:
        """
        Memory Flush: 静默写入文件 (对标OpenClaw memoryFlush)
        
        将重要信息按写入路由规则写入对应文件, 释放工作记忆。
        """
        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
        daily_file = self.memory_dir / f"{today}.md"

        flush_content: Dict[str, List[str]] = {
            "MEMORY.md": [],
            f"memory/{today}.md": [],
        }

        for chunk in self.chunks:
            score = self.get_chunk_score(chunk)
            if score < 0.2:
                continue  # 太旧, 不写入

            # 写入路由判定
            route = self._determine_write_route(chunk)
            if route and not self._is_forbidden(chunk):
                flush_content.setdefault(route, []).append(
                    f"- [{datetime.fromtimestamp(chunk.timestamp).strftime('%H:%M')}] "
                    f"{chunk.content[:300]}"
                )

        # 执行静默写入
        for route, lines in flush_content.items():
            if not lines:
                continue
            filepath = self.root / route
            filepath.parent.mkdir(parents=True, exist_ok=True)

            if route.endswith("MEMORY.md"):
                # MEMORY.md: 追加到文件末尾
                with open(filepath, "a", encoding="utf-8") as f:
                    f.write(f"\n## Memory Flush · {today}\n\n")
                    f.write("\n".join(lines))
                    f.write("\n")
            else:
                # 每日日志: 追加
                with open(filepath, "a", encoding="utf-8") as f:
                    f.write(f"\n### Memory Flush · Auto Compact\n\n")
                    f.write("\n".join(lines))
                    f.write("\n")

        self._log_event({
            "event": "memory_flush",
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "routes_written": list(flush_content.keys()),
            "total_lines": sum(len(v) for v in flush_content.values()),
        })

    def _determine_write_route(self, chunk: MemoryChunk) -> Optional[str]:
        """基于内容特征判定写入路由"""
        content = chunk.content.lower()

        if chunk.verified:
            return "MEMORY.md"

        route_keywords = {
            "MEMORY.md": ["偏好", "策略", "经验", "教训", "项目状态", "偏好设置",
                          "preference", "strategy", "lesson", "project"],
            f"memory/{datetime.now(timezone.utc).strftime('%Y-%m-%d')}.md": [
                "进度", "任务", "调研", "临时", "待办", "今日",
                "progress", "task", "research", "temp", "todo", "today",
            ],
        }

        for route, keywords in route_keywords.items():
            if any(kw in content for kw in keywords):
                return route

        # 默认写入每日日志
        return f"memory/{datetime.now(timezone.utc).strftime('%Y-%m-%d')}.md"

    def _is_forbidden(self, chunk: MemoryChunk) -> bool:
        """检查是否为禁止写入类型"""
        content = chunk.content.lower()
        return any(fw in content for fw in self.FORBIDDEN_WRITE)

    # ───────────────── 工具函数 ─────────────────

    @staticmethod
    def _gen_dna(prefix: str) -> str:
        import hashlib
        ts = datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S%f")[:-3]
        h = hashlib.sha256(f"{prefix}|{ts}|MEMORY-COMPACTION".encode()).hexdigest()[:8].upper()
        return f"#龍芯⚡️丙午·丙申·癸丑·申时·需-{prefix}-{h}"

    # ───────────────── 查询接口 ─────────────────

    def get_memory_snapshot(self) -> Dict[str, Any]:
        """获取记忆库快照"""
        return {
            "total_chunks": len(self.chunks),
            "total_tokens": self.total_tokens(),
            "remaining_tokens": self.remaining_tokens(),
            "usage_ratio": round(self.usage_ratio(), 4),
            "verified_count": sum(1 for c in self.chunks if c.verified),
            "avg_importance": round(
                sum(c.importance for c in self.chunks) / max(1, len(self.chunks)), 4
            ),
            "compaction_history": len(self.history),
            "last_compaction": (
                datetime.fromtimestamp(self.token_budget.last_compaction_at).isoformat()
                if self.token_budget.last_compaction_at > 0 else None
            ),
        }

    def search_memory(self, query: str, top_k: int = 5) -> List[MemoryChunk]:
        """
        简单关键词检索记忆块 (后续可升级为混合检索 Vector+BM25)
        """
        query_lower = query.lower()
        scored = []
        for chunk in self.chunks:
            content_lower = chunk.content.lower()
            # 简单TF匹配
            score = content_lower.count(query_lower) / max(1, len(content_lower))
            # 乘以衰减系数
            score *= self.get_chunk_score(chunk)
            # tag匹配加分
            if any(query_lower in t.lower() for t in chunk.tags):
                score *= 1.5
            scored.append((score, chunk))

        scored.sort(key=lambda x: x[0], reverse=True)
        return [c for _, c in scored[:top_k]]

    def get_compaction_stats(self) -> Dict[str, Any]:
        """压缩统计"""
        if not self.history:
            return {"total_compactions": 0}

        total_saved = sum(r.token_saved for r in self.history)
        levels = {}
        for r in self.history:
            lv = r.level.value
            if lv not in levels:
                levels[lv] = 0
            levels[lv] += 1

        return {
            "total_compactions": len(self.history),
            "total_tokens_saved": total_saved,
            "avg_compression_ratio": round(
                sum(r.compression_ratio for r in self.history) / len(self.history), 4
            ),
            "by_level": levels,
            "avg_duration_ms": round(
                sum(r.duration_ms for r in self.history) / len(self.history), 1
            ),
        }


# ═══════════════════════════════════════════════════════════════════
# 全局实例
# ═══════════════════════════════════════════════════════════════════

_engine: Optional[MemoryCompactionEngine] = None


def get_compaction_engine() -> MemoryCompactionEngine:
    """获取全局压缩引擎实例 (单例)"""
    global _engine
    if _engine is None:
        _engine = MemoryCompactionEngine()
    return _engine


# ═══════════════════════════════════════════════════════════════════
# CLI
# ═══════════════════════════════════════════════════════════════════

if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="龍魂记忆压缩引擎")
    parser.add_argument("command", choices=["status", "compact", "flush", "search", "stats"])
    parser.add_argument("--level", choices=["light", "medium", "heavy", "flush"],
                        default="medium", help="压缩级别")
    parser.add_argument("--query", type=str, help="搜索关键词")
    parser.add_argument("--text", type=str, help="添加测试记忆")
    args = parser.parse_args()

    eng = get_compaction_engine()

    if args.command == "status":
        snapshot = eng.get_memory_snapshot()
        print(json.dumps(snapshot, ensure_ascii=False, indent=2))

    elif args.command == "compact":
        level = CompactionLevel(args.level)
        result = eng.compact(level)
        print(f"✅ {result.summary}")

    elif args.command == "flush":
        result = eng.compact(CompactionLevel.FLUSH)
        print(f"✅ Memory Flush完成: {result.summary}")

    elif args.command == "search" and args.query:
        results = eng.search_memory(args.query)
        print(f"🔍 搜索 '{args.query}': {len(results)} 结果")
        for i, chunk in enumerate(results[:10]):
            score = eng.get_chunk_score(chunk)
            print(f"  [{i+1}] score={score:.3f} tags={chunk.tags}")
            print(f"      {chunk.content[:200]}...")

    elif args.command == "stats":
        stats = eng.get_compaction_stats()
        print(json.dumps(stats, ensure_ascii=False, indent=2))

    elif args.command == "status" and args.text:
        chunk_id = eng.add_chunk(args.text, source="cli_test")
        print(f"✅ 已添加记忆块: {chunk_id}")
如何处理动态语言(Python / JS)的“隐形”调用链? 本文揭示动态语言(Python/JS)中静态AST解析导致调用链“断链”的核心问题,提出通过运行时追踪补全图谱的解决方案。基于Code-Graph-RAG的cgr trace机制,分别利用pytest插件与V8 Profiler捕获真实调用路径,将动态边合并至静态图谱,并在权重体系中提升动态边优先级。实践表明,该方法可显著提升图谱覆盖率,实现“结构+行为”双视角理解代码,为MCP与Rerank系统提供可靠支持。 阅读详情

相关推荐

Playwright: Pytest vs Library vs LibraryAsync:三者如何选?

Python中Playwright的3个Target:Pytest(推荐用于E2E自动化测试,支持报告、并行、重试)、Library(同步脚本,适合爬虫与简单任务,需手动管理浏览器)、LibraryAsync(异步脚本,适用于高并发批量操作)。选择依据:测试项目选Pytest,轻量脚本选Library,高并发场景选LibraryAsync。

SmallBull的博客 229

本地化部署 DeepSeek,构建单细胞与空间转录组 AI 分析平台

本地化部署 DeepSeek,构建单细胞与空间转录组 AI 分析平台

weixin_53637133的博客 187

银河飞腾FT6678实战指南:OpenMP多核并行编程优化技巧

本文详细介绍了在银河飞腾FT6678多核处理器上使用OpenMP进行并行编程的实战技巧与优化方法。从基础语法到环境配置,再到性能优化的五大核心技巧,包括循环并行化、并行粒度控制、reduction子句使用等,帮助开发者充分发挥FT6678的8核计算能力。通过实际案例展示如何将图像处理算法从200ms优化到28ms,并深入探讨了任务调度、内存访问优化等进阶主题。

weixin_29234423的博客 289

【第 009 讲】全面掌握 Python 注释:注释的定义与作用 | 单行注释 | 三引号与多行注释 | 注释使用的最佳实践

本文系统讲解 Python 注释的完整知识体系:从注释的定义与作用讲起,梳理单行注释的书写位置、临时屏蔽用法与 PEP 8 排版规范,剖析注释被忽略的底层机制;进而说明三引号字符串的本质与嵌套问题;最后给出注释使用的三条实践原则,帮助读者写好可读性高的注释。

大模型全栈工程师 · Thanks_ks 1180

智能车竞赛卡丁快跑组:自动驾驶与人车交互技术实战解析

本文深入解析了智能车竞赛卡丁快跑组的技术核心,重点探讨了自动驾驶与人车交互两大模块的实战方案。文章详细拆解了从环境感知、路径规划到语音识别、命令执行的完整流程,并分享了基于单片机平台的调试心法与赛场经验,为参赛者提供了一套从零开始、分步攻坚的系统性备赛指南。

f0g1h2的博客 1179

Python画常见分布的概率密度图

因为做概随大作业,了解了一些python画概率分布图的方法。

qq_44807946的博客 5204

AI全栈实战 | 3.9-01 爬虫入门:requests 加 BeautifulSoup 三分钟跑通,但 90% 的人栽在这 4 个“礼貌“问题上

⚠️:本文内容仅用于。请遵守目标站点的服务条款与相关法律法规,不得对目标服务造成负担,不得采集、传播个人隐私数据。技术是中性的,边界在你手里。爬虫的入门技术(requests 发请求 + BeautifulSoup 解析)三分钟就能学会。真正区分"会用爬虫"和"会做爬虫的人"的,是这篇我们跑通"请求→解析→存储"的最小闭环,然后重点把"合规与礼貌"这根弦给你绷上。

源码获取 | 运行部署 | 定制二开修改,如果回复不及时请耐心等待,请见谅。 444

【unity实战】Unity手搓脚本工具实现合并网格功能

本文介绍了在Unity中优化网格性能的方法,通过合并重复网格减少绘制调用。主要使用Mesh.CombineMeshes方法实现网格合并,支持统一材质和多材质处理。核心内容包括:1)基础合并脚本实现,将子网格合并到父对象并禁用原网格;2)统一材质设置,支持自定义或默认材质;3)多材质合并方案,通过设置mergeSubMeshes=false保留子网格材质索引。文章还提供了完整代码示例和操作演示,适用于实际项目中的网格优化需求。

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 561

Python 的 yield from 到底转发了什么:拆开 send、throw 和那个 return 值

很多人把yield from记成「省一层 for 循环的语法糖」。写和写,结果看着一样,于是就当它只是少敲几个字。这个理解会在三个地方翻车:调用方.send()的值送不进去、子生成器return的值拿不到、异常和close()传不下去。yield from真正做的事是,外层生成器退成一个透明通道。本文所有输出来自本机 CPython 3.13.14 实测。yield from不是循环,是委托——nextsendthrowclose四个方向的流量全部直通子生成器,并且子生成器return。

小小张说故事的博客 163

Yolo8行人车辆目标检测实战分享 完整项目代码可直接运行

Yolo8行人车辆目标检测实战分享 完整项目代码可直接运行

1295

人工智能之数学基础:弄懂数学本质,让我们不再害怕数学

数学的用途远远超过了人们的想象,甚至无处不在,任何领域都需要用到数学知识,人工智能也不例外。我将尽可能地将数学知识和机器学习算法相结合,让大家知道这些数学知识咋人工智能领域中的应用,使得数学的学习不会过于枯燥,同时也帮助大家扫清在学习算法过程中的数学障碍。除此之外,我还希望帮助大家建立一种不一样的数学思维,不再将数学看成是符号的演算、公式的推导,而是将数学看成是一种描述这个世界的工具,这样你就会发现这个世界处处有数学。当我们面对问题的时候,你是否会对问题进行抽象,然后通过数学来解决问题?

huanfeng_AI的博客 634

从一段视频到可漫游的 4D 有声场景:思路拆解与最小复现手记

只需一段手机视频,你就能生成可"走进去"的 4D 有声场景:转头时狗叫声方向随之变化,走近时声音更清晰。本文拆解 Video-to-4DAVScene 的核心思路,手把手带你用几十行 Python 搭出最小管线,把视频中的运动物体变成带空间位置的声源,并附上三个真实踩坑的排障经验,代码可直接跑。🎧

helloagent的博客 246

HTML5+CSS3+JS小实例:扇形展开折叠菜单

你肯定见过那种圆形浮动按钮(FAB),点一下弹出几个选项。大部分实现就是菜单项从底下往上"弹"出来,排成一列——能用,但没啥记忆点。后来我看到 Path 那个经典的扇形菜单,点一下,五个按钮像花瓣一样从中心散开,每个带不同的延迟和弹性曲线。当时就觉得:这才对嘛,交互就该有点"戏剧性"。今天拆一个纯手写版本,HTML + CSS + JS,不依赖任何库。六菜单项、扇形 144° 展开、弹性过渡、点击关闭、键盘可达——该有的都有。

艾恩小灰灰的博客 166

【每天一个 Python 小案例30】Python 基础知识综合小项目:我的工具盒

作为系列收官,本篇把前 29 篇的知识点合成一个能直接用的命令行工具"我的工具盒":计算器(用 ast 解析表达式,不碰 eval)、单位换算与温度转换(一张换算表 + 特例分支)、记账与分类统计(Decimal + JSON 持久化)、以及用"字典当命令表"把菜单和业务逻辑解耦的主循环。文中对比了 eval 的安全隐患与 ast 白名单的做法,解释了 lambda 闭包在字典里的写法与晚绑定陷阱,并在最后给出整个系列的知识地图,把变量、数据结构、控制流、函数、类、异常、文件、标准库八块内容对应到具体篇目。

xinjiyaya的博客 432

【异常检测】新版异常检测库anomalib的使用

异常检测库anomalib的使用。

胡侃有料的博客 4393

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

双路径优化+双容差校准

默认使用向量化路径处理常规数据,当检测到内存非连续或需要极致短路性能时,自动切换至 Numba JIT 路径。“当 CI 宽度中位数为 $W$ 时,实际判定容差为 $10^{-12} + 10^{-9} \times W$"针对表征谱算子 2 的实际输出量纲(例如 $10^{-3}$ 至 $10^3$),调整。准确标记了哪些数组被复制。非短路、静默拷贝风险、量纲耦合容差),本方案重构了核心逻辑。,并完善审计元数据以记录内存拷贝状态。, 确保在不同量纲下判定标准的一致性。,否则需排查上游数据生成逻辑。

2301_77211362的博客 202

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

yolo 和 deft 算法的区别

你应该是打错了:是,不是 defrat;

曾大强博客 290

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级 备考:莫队算法离线区间查询详解

备赛进行时:第十八届蓝桥杯软件赛报名已于 2026-10-08 10:00 开启、12-18 14:00 截止,省赛定在 2027-04-10(C/C++·Python 程序设计 9:00–13:00);中国电子学会 2026 年 12 月软件编程(C/C++ 一级至十级、Python 一级至六级)考级报名 9/23–12/2 16:00、统考 12-12;全国青少年信息素养大赛 2026—2027 赛季算法应用主题赛也已进入复盘练兵窗口。

IT_Scratch的博客 184

两张表合并之后,行数悄悄多了一倍

pandas merge 行数异常膨胀源于右表键不唯一,导致数据静默复制。实测显示,未聚合的右表(756行)与左表合并后行数增至504行,合计膨胀3.5倍,但无报错。validate 参数仅在检查键唯一性时有效,one_to_one 和 many_to_one 可拦截问题,但需结合 duplicated() 前置检查。正确做法为先按键聚合右表,再合并,避免重复。建议合并前后核对行数、合计,并使用 indicator=True 排查匹配情况,确保数据一致性。

patrickstar231的博客 252

我用 200 行代码写了个“代码屎山检测器“,扫完公司的老项目后我沉默了

这个工具不能帮你把屎山铲平,但至少能让你知道自己面对的是多大的山,也能在代码评审时用数据说话——“这个 PR 把圈复杂度从 12 推到了 18,能不能拆一下?毕竟,不能量化的东西,就没法改进。

xixiaoyunya的博客 277

智慧农业实战:育秧车间秧盘计数与苗情分级的Python实现

首先,建立统一的数据结构,保存每盘秧苗的编号、批次、覆盖度、叶色得分和播种天数。A = "壮苗"B = "合格苗"C = "弱苗"@dataclassdays: int。

荆棘鸟智能的博客 138

Java Arrays.asList 常见坑详解|UnsupportedOperationException、数组联动、基本类型 bug

解析 Arrays.asList 常见开发陷阱,演示 UnsupportedOperationException、底层数组引用共享、基本类型数组问题,区分 Arrays 内部 ArrayList 与 java.util.ArrayList,给出数组转 List 的各种场景正确代码。

weixin_42617033的博客 511

【每天一个 Python 小案例29】Python 实现商品购物车

本篇实现一个购物车:商品目录、加入商品、修改数量、移除商品、查看小计、计算满减与 VIP 折扣、结算扣库存。核心设计是"目录与购物车分离"——目录存商品主数据,购物车只存 {商品编号: 数量};金额一律用 Decimal 并做 ROUND_HALF_UP 舍入。折扣部分讲清阶梯满减的匹配顺序(阈值从高到低、命中即停)与叠加顺序(先满减、后打折),并用一次完整结算演示 706 元如何变成 613.70 元。

xinjiyaya的博客 220

Python的字典

Python字典是存储键值对的数据结构,通过键(key)快速查找对应的值(value)。可使用{}定义,支持增删改查操作:通过dict[key]查询或修改值,get()方法安全获取并设置默认值,del dict[key]删除键值对,keys()、values()和items()用于遍历。items()结合双变量循环可高效遍历所有键值对,提升代码可读性与灵活性。

qq_43010954的博客 199

黄仁勋走了,护城河留下了什么

11 月 12 日,英伟达董事会批准黄仁勋辞去总裁、CEO 和董事职务,即刻生效,CFO 克雷斯出任临时 CEO;股价开盘一度跌 14.35%,收盘只跌 4.34%,市值单日蒸发 1820 亿美元;本文把「创始人走了护城河就没了」这个流行说法拆开——CUDA 还在,但 CUDA 正在被 Claude 三天凿穿,真正决定下一段路的是三个可以核对的东西:治理结构、决策机制、以及下一个百亿美元由谁拍板。

领码SPARK - 以无代码之星火,燎原数字之未来! 188

基于深度学习的工业表面缺陷检测系统-毕业设计

只用正常样本训练的工业表面缺陷检测系统:15 类工业品、5354 张图、73 种缺陷。PatchCore-lite 图像级 AUROC 0.896、像素级 0.951,单张 CPU 推理 115 毫秒;附 PaDiM 与整图基线对照,含 Django 系统、论文与使用文档。

csbysj2020 210
上一篇: 龙虾开发者社区(xclaw) · OpenClaw生态深度学习融合 v1.0
下一篇: 龍魂系统 · AI 操作手册(还没完善)
龍芯北辰UID9622
博客等级 码龄164天 5粉丝 501原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值