完整的 `lh 掀黑箱` 引擎,用于审计任意平台/项目的技术主权风险。它扫描代码、依赖、配置,识别“黑箱”行为,并生成结构化报告。

「文智助手」全场景办公AI助理AI+OPC全流程实践方案(大赛作品) 阅读详情

脚本:bin/lh_掀黑箱.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
🐉 龍魂 · 掀黑箱审计引擎 v1.0
DNA: #龍芯⚡️丙午·丙申·乙巳·辛巳·☴巽-掀黑箱-v1.0-UID9622

功能:
  审计任意项目,识别技术主权风险,包括:
  - 闭源/未授权依赖
  - 数据外流接口(硬编码URL、IP)
  - 主权声明缺失
  - 外部云服务依赖(不可替换)
  - 疑似后门/加密通信未说明

输出:
  - 终端彩色报告(人类可读)
  - JSON 格式(机器可读)
  - 支持导出 HTML 报告

用法:
  lh 掀黑箱 [路径]                 # 审计当前目录或指定路径
  lh 掀黑箱 [路径] --json          # 输出 JSON
  lh 掀黑箱 [路径] --output report.html   # 生成 HTML 报告
  lh 掀黑箱 --help                 # 帮助
"""

import os
import sys
import re
import json
import hashlib
import argparse
import subprocess
from pathlib import Path
from typing import Dict, List, Any, Optional, Set, Tuple
from datetime import datetime
from collections import defaultdict

# ============================================================
# 配置
# ============================================================

PROJECT_ROOT = Path.home() / "longhun-system"
REPORT_DIR = PROJECT_ROOT / "reports"
REPORT_DIR.mkdir(parents=True, exist_ok=True)

# 风险等级
RISK_CRITICAL = "🔴 严重"
RISK_HIGH = "🟠 高危"
RISK_MEDIUM = "🟡 中危"
RISK_LOW = "🟢 低危"
RISK_INFO = "ℹ️ 信息"

# ============================================================
# 审计规则
# ============================================================

RULES = {
    # 闭源/受限依赖
    "proprietary_deps": {
        "name": "闭源/专有依赖",
        "severity": RISK_CRITICAL,
        "description": "项目依赖了闭源或受限许可证的软件,存在法律和主权风险。",
        "patterns": [
            r"oracle", r"mysql-connector", r"msodbcsql", r"ibm_db",
            r"pymssql", r"pyodbc", r"cx_Oracle", r"psycopg2-binary",
            r"django-", r"flask-", r"tensorflow", r"pytorch", r"transformers",
            r"langchain", r"llama-index", r"openai", r"anthropic",
        ],
        "check": "dependencies"
    },
    # 数据外流接口(硬编码URL)
    "data_exfiltration": {
        "name": "数据外流接口",
        "severity": RISK_CRITICAL,
        "description": "检测到硬编码的第三方API地址,可能将数据发送至外部。",
        "patterns": [
            r"https?://[a-zA-Z0-9\-\.]+\.(com|cn|net|org|io|cloud|ai)\S*",
            r"api\.", r"\.amazonaws\.com", r"\.azure\.com", r"\.googleapis\.com",
            r"\.openai\.com", r"\.anthropic\.com", r"\.huggingface\.co",
            r"\.github\.com", r"\.gitlab\.com",
        ],
        "check": "hardcoded_urls"
    },
    # 缺乏主权声明
    "sovereignty_missing": {
        "name": "主权声明缺失",
        "severity": RISK_HIGH,
        "description": "项目缺少LICENSE或主权声明文件,无法确定授权归属。",
        "patterns": [],
        "check": "sovereignty"
    },
    # 外部云服务依赖
    "cloud_dependency": {
        "name": "外部云服务依赖",
        "severity": RISK_HIGH,
        "description": "项目强依赖国外云服务,存在断供和合规风险。",
        "patterns": [
            r"aws", r"azure", r"gcp", r"google-cloud", r"amazon",
            r"boto3", r"azure-", r"google-api", r"firebase",
        ],
        "check": "dependencies"
    },
    # 未签名的二进制文件
    "unsigned_binaries": {
        "name": "未签名二进制文件",
        "severity": RISK_MEDIUM,
        "description": "项目中存在未签名的可执行文件或动态库,无法验证来源。",
        "patterns": [r"\.(exe|dll|so|dylib|bin)$"],
        "check": "files"
    },
    # 疑似后门/加密通信
    "backdoor_suspect": {
        "name": "疑似后门/隐蔽通信",
        "severity": RISK_CRITICAL,
        "description": "检测到可疑的加密通信或隐蔽通道,需人工核查。",
        "patterns": [
            r"cryptography\.fernet", r"cryptography.hazmat", r"openssl",
            r"pycryptodome", r"pynacl", r"paramiko", r"ssh", r"ssl",
            r"webhook", r"callback", r"reverse\s*shell", r"tunnel",
        ],
        "check": "code"
    },
    # 缺乏开源合规文件
    "compliance_missing": {
        "name": "开源合规文件缺失",
        "severity": RISK_MEDIUM,
        "description": "缺少 CONTRIBUTING、CODE_OF_CONDUCT 等治理文件。",
        "patterns": [],
        "check": "files"
    },
    # 未使用国产芯片/系统标记
    "domestic_incompatible": {
        "name": "未适配国产环境",
        "severity": RISK_MEDIUM,
        "description": "项目未标注支持鲲鹏、龙芯等国产平台,可能无法在信创环境运行。",
        "patterns": [],
        "check": "sovereignty"
    },
}

# ============================================================
# 审计引擎
# ============================================================

class BlackBoxAuditor:
    def __init__(self, target_path: Path):
        self.target = target_path.resolve()
        self.results = {
            "target": str(self.target),
            "timestamp": datetime.now().isoformat(),
            "findings": [],
            "summary": {
                "critical": 0,
                "high": 0,
                "medium": 0,
                "low": 0,
                "info": 0,
            },
            "files_scanned": 0,
            "dependencies": {},
        }
        self._loaded_files = {}

    def scan(self) -> Dict[str, Any]:
        """执行完整扫描"""
        # 1. 扫描文件
        self._scan_files()

        # 2. 分析依赖
        self._analyze_dependencies()

        # 3. 检查主权声明
        self._check_sovereignty()

        # 4. 检查硬编码URL
        self._check_hardcoded_urls()

        # 5. 应用规则
        self._apply_rules()

        # 6. 生成总结
        self._generate_summary()

        return self.results

    def _scan_files(self):
        """递归扫描文件"""
        for file_path in self.target.rglob("*"):
            if file_path.is_file():
                # 排除隐藏目录和二进制大文件
                if any(p.startswith(".") for p in file_path.parts):
                    continue
                if file_path.suffix in [".pyc", ".pyo", ".so", ".dylib", ".dll", ".exe"]:
                    continue
                if file_path.stat().st_size > 1024 * 1024:  # >1MB 跳过
                    continue
                try:
                    content = file_path.read_text(encoding="utf-8", errors="ignore")
                    self._loaded_files[str(file_path.relative_to(self.target))] = content
                except:
                    pass
        self.results["files_scanned"] = len(self._loaded_files)

    def _analyze_dependencies(self):
        """分析依赖文件"""
        deps = {}
        # requirements.txt
        req_file = self.target / "requirements.txt"
        if req_file.exists():
            deps["requirements.txt"] = req_file.read_text().splitlines()
        # package.json
        pkg_file = self.target / "package.json"
        if pkg_file.exists():
            try:
                data = json.loads(pkg_file.read_text())
                deps["package.json"] = data.get("dependencies", {}).keys()
            except:
                pass
        # setup.py
        setup_file = self.target / "setup.py"
        if setup_file.exists():
            deps["setup.py"] = ["手动检查"]
        # 龙魂特有:lh 命令依赖
        self.results["dependencies"] = deps

    def _check_sovereignty(self):
        """检查主权声明"""
        has_license = (self.target / "LICENSE").exists() or (self.target / "LICENSE.txt").exists()
        has_readme = (self.target / "README.md").exists() or (self.target / "README").exists()
        has_sovereignty = False
        if has_readme:
            readme_content = (self.target / "README.md").read_text(encoding="utf-8", errors="ignore") if (self.target / "README.md").exists() else ""
            if "主权" in readme_content or "sovereign" in readme_content.lower():
                has_sovereignty = True
        self.results["sovereignty"] = {
            "license": has_license,
            "readme": has_readme,
            "sovereignty_statement": has_sovereignty,
        }

    def _check_hardcoded_urls(self):
        """检测硬编码URL"""
        urls = []
        for rel_path, content in self._loaded_files.items():
            found = re.findall(RULES["data_exfiltration"]["patterns"][0], content)
            for url in found:
                # 过滤常见非外流URL(如本地、文档链接)
                if "localhost" in url or "127.0.0.1" in url or "example" in url:
                    continue
                urls.append({"file": rel_path, "url": url})
        self.results["hardcoded_urls"] = urls

    def _apply_rules(self):
        """应用所有规则"""
        findings = []

        # 1. 依赖检查
        for rule_name, rule in RULES.items():
            if rule["check"] == "dependencies":
                for dep_file, dep_list in self.results["dependencies"].items():
                    for dep in dep_list:
                        if any(re.search(p, dep, re.I) for p in rule["patterns"]):
                            findings.append({
                                "rule": rule_name,
                                "severity": rule["severity"],
                                "description": rule["description"],
                                "evidence": f"依赖 {dep} 在 {dep_file} 中",
                            })
                            break

        # 2. 主权检查
        sover = self.results.get("sovereignty", {})
        if not sover.get("license"):
            findings.append({
                "rule": "sovereignty_missing",
                "severity": RISK_HIGH,
                "description": RULES["sovereignty_missing"]["description"],
                "evidence": "未找到 LICENSE 文件",
            })
        if not sover.get("sovereignty_statement"):
            findings.append({
                "rule": "sovereignty_missing",
                "severity": RISK_MEDIUM,
                "description": "缺乏显式的主权声明,建议在 README 中说明数据主权归属。",
                "evidence": "README 中未提及主权",
            })
        # 国产适配检查
        if not sover.get("readme") or "鲲鹏" not in sover.get("readme_content", ""):
            findings.append({
                "rule": "domestic_incompatible",
                "severity": RISK_MEDIUM,
                "description": RULES["domestic_incompatible"]["description"],
                "evidence": "未在 README 中标注国产平台支持",
            })

        # 3. 硬编码URL
        for url_info in self.results.get("hardcoded_urls", []):
            findings.append({
                "rule": "data_exfiltration",
                "severity": RISK_CRITICAL,
                "description": f"发现外部API调用: {url_info['url']}",
                "evidence": f"文件: {url_info['file']}",
            })

        # 4. 文件检查
        for rel_path in self._loaded_files.keys():
            if any(re.search(p, rel_path, re.I) for p in RULES["unsigned_binaries"]["patterns"]):
                findings.append({
                    "rule": "unsigned_binaries",
                    "severity": RISK_MEDIUM,
                    "description": RULES["unsigned_binaries"]["description"],
                    "evidence": f"文件: {rel_path}",
                })

        # 5. 代码检查(后门可疑)
        for rel_path, content in self._loaded_files.items():
            for pattern in RULES["backdoor_suspect"]["patterns"]:
                if re.search(pattern, content, re.I):
                    findings.append({
                        "rule": "backdoor_suspect",
                        "severity": RISK_CRITICAL,
                        "description": RULES["backdoor_suspect"]["description"],
                        "evidence": f"在 {rel_path} 中发现疑似隐蔽通信代码: {pattern}",
                    })
                    break

        # 去重(基于 evidence)
        seen = set()
        unique_findings = []
        for f in findings:
            key = f["evidence"]
            if key not in seen:
                seen.add(key)
                unique_findings.append(f)

        self.results["findings"] = unique_findings

    def _generate_summary(self):
        """生成统计摘要"""
        summary = {"critical": 0, "high": 0, "medium": 0, "low": 0, "info": 0}
        for f in self.results["findings"]:
            sev = f["severity"]
            if sev == RISK_CRITICAL:
                summary["critical"] += 1
            elif sev == RISK_HIGH:
                summary["high"] += 1
            elif sev == RISK_MEDIUM:
                summary["medium"] += 1
            elif sev == RISK_LOW:
                summary["low"] += 1
            else:
                summary["info"] += 1
        self.results["summary"] = summary

# ============================================================
# 报告生成器
# ============================================================

def print_terminal_report(result: Dict[str, Any]):
    """终端彩色输出"""
    RED = '\033[91m'
    ORANGE = '\033[38;5;214m'
    YELLOW = '\033[93m'
    GREEN = '\033[92m'
    BOLD = '\033[1m'
    RESET = '\033[0m'

    lines = []
    lines.append(f"\n{BOLD}{'='*70}{RESET}")
    lines.append(f"{BOLD}🐉 龍魂 · 掀黑箱审计报告{RESET}")
    lines.append(f"{BOLD}{'='*70}{RESET}")
    lines.append(f"  目标: {result['target']}")
    lines.append(f"  时间: {result['timestamp']}")
    lines.append(f"  文件数: {result['files_scanned']}")
    lines.append(f"{BOLD}{'-'*70}{RESET}")

    # 摘要
    s = result["summary"]
    lines.append(f"\n📊 风险摘要")
    lines.append(f"  {RISK_CRITICAL}: {s['critical']}")
    lines.append(f"  {RISK_HIGH}: {s['high']}")
    lines.append(f"  {RISK_MEDIUM}: {s['medium']}")
    lines.append(f"  {RISK_LOW}: {s['low']}")

    if s['critical'] > 0:
        overall = f"{RED}🔴 高风险,建议立即处理{RESET}"
    elif s['high'] > 0:
        overall = f"{ORANGE}🟠 中高风险,建议排查{RESET}"
    else:
        overall = f"{GREEN}🟢 风险可控{RESET}"
    lines.append(f"\n  总体评估: {overall}")

    # 详细发现
    if result["findings"]:
        lines.append(f"\n{BOLD}🔍 详细发现{RESET}")
        lines.append("-" * 70)
        for i, f in enumerate(result["findings"], 1):
            sev = f["severity"]
            lines.append(f"{i}. {sev} {f['rule']}")
            lines.append(f"   {f['description']}")
            lines.append(f"   📎 {f['evidence']}")
            lines.append("")

    # 主权声明
    sover = result.get("sovereignty", {})
    lines.append(f"{BOLD}📜 主权声明检查{RESET}")
    lines.append(f"  LICENSE: {'✅ 存在' if sover.get('license') else '❌ 缺失'}")
    lines.append(f"  README: {'✅ 存在' if sover.get('readme') else '❌ 缺失'}")
    lines.append(f"  主权声明: {'✅ 已声明' if sover.get('sovereignty_statement') else '❌ 未声明'}")

    # 硬编码URL(脱敏展示前3个)
    urls = result.get("hardcoded_urls", [])
    if urls:
        lines.append(f"\n{BOLD}🌐 硬编码外部URL(前3个){RESET}")
        for u in urls[:3]:
            lines.append(f"  {u['url']} ({u['file']})")
        if len(urls) > 3:
            lines.append(f"  ... 还有 {len(urls)-3} 个")

    lines.append(f"\n{BOLD}{'='*70}{RESET}")
    lines.append(f"DNA: #龍芯⚡️{datetime.now().strftime('%Y%m%d%H%M%S')}-掀黑箱-UID9622")
    print("\n".join(lines))

def generate_html_report(result: Dict[str, Any], output_path: Path):
    """生成 HTML 报告"""
    html = f"""
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>龍魂 · 掀黑箱审计报告</title>
    <style>
        body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; max-width: 1000px; margin: 40px auto; padding: 20px; background: #f8f9fa; }}
        h1, h2, h3 {{ color: #1a1a2e; border-bottom: 2px solid #e9ecef; padding-bottom: 8px; }}
        .risk-critical {{ color: #e63946; font-weight: bold; }}
        .risk-high {{ color: #e67e22; font-weight: bold; }}
        .risk-medium {{ color: #f1c40f; font-weight: bold; }}
        .risk-low {{ color: #2ecc71; font-weight: bold; }}
        .finding {{ background: white; padding: 12px 16px; margin: 8px 0; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.06); }}
        .evidence {{ color: #6c757d; font-size: 0.9em; }}
        .summary {{ display: flex; gap: 20px; flex-wrap: wrap; margin: 20px 0; }}
        .summary-item {{ background: white; padding: 16px 24px; border-radius: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.06); flex: 1; min-width: 80px; text-align: center; }}
        .badge {{ display: inline-block; padding: 2px 8px; border-radius: 12px; font-size: 0.8em; color: white; }}
        .badge-critical {{ background: #e63946; }}
        .badge-high {{ background: #e67e22; }}
        .badge-medium {{ background: #f1c40f; }}
        .badge-low {{ background: #2ecc71; }}
        .footer {{ margin-top: 40px; border-top: 2px solid #e9ecef; padding-top: 20px; font-size: 0.9em; color: #6c757d; text-align: center; }}
        .dna {{ font-family: monospace; background: #1a1a2e; color: #ffd60a; padding: 4px 10px; border-radius: 4px; }}
    </style>
</head>
<body>
    <h1>🐉 龍魂 · 掀黑箱审计报告</h1>
    <p>目标: {result['target']} | 时间: {result['timestamp']} | 文件数: {result['files_scanned']}</p>

    <h2>📊 风险摘要</h2>
    <div class="summary">
        <div class="summary-item"><span class="badge badge-critical">严重</span> <strong>{result['summary']['critical']}</strong></div>
        <div class="summary-item"><span class="badge badge-high">高危</span> <strong>{result['summary']['high']}</strong></div>
        <div class="summary-item"><span class="badge badge-medium">中危</span> <strong>{result['summary']['medium']}</strong></div>
        <div class="summary-item"><span class="badge badge-low">低危</span> <strong>{result['summary']['low']}</strong></div>
    </div>

    <h2>🔍 详细发现</h2>
    {''.join(f'''
    <div class="finding">
        <strong>{f['severity']} {f['rule']}</strong>
        <p>{f['description']}</p>
        <div class="evidence">📎 {f['evidence']}</div>
    </div>
    ''' for f in result['findings']) if result['findings'] else '<p>🎉 未发现明显风险</p>'}

    <h2>📜 主权声明</h2>
    <ul>
        <li>LICENSE: {'✅ 存在' if result.get('sovereignty',{}).get('license') else '❌ 缺失'}</li>
        <li>README: {'✅ 存在' if result.get('sovereignty',{}).get('readme') else '❌ 缺失'}</li>
        <li>主权声明: {'✅ 已声明' if result.get('sovereignty',{}).get('sovereignty_statement') else '❌ 未声明'}</li>
    </ul>

    <div class="footer">
        DNA: <span class="dna">#龍芯⚡️{datetime.now().strftime('%Y%m%d%H%M%S')}-掀黑箱-UID9622</span>
        <br>© 龍魂系统 · 君子协议
    </div>
</body>
</html>
    """
    output_path.write_text(html, encoding="utf-8")

# ============================================================
# 命令行入口
# ============================================================

def main():
    parser = argparse.ArgumentParser(description="龍魂 · 掀黑箱审计引擎")
    parser.add_argument("target", nargs="?", default=".", help="要审计的目标路径(默认当前目录)")
    parser.add_argument("--json", action="store_true", help="输出 JSON 格式")
    parser.add_argument("--output", "-o", type=str, help="导出报告文件(支持 .json, .html)")
    parser.add_argument("--no-color", action="store_true", help="禁用彩色输出")
    args = parser.parse_args()

    target_path = Path(args.target).expanduser().resolve()
    if not target_path.exists():
        print(f"❌ 目标路径不存在: {target_path}")
        sys.exit(1)

    auditor = BlackBoxAuditor(target_path)
    result = auditor.scan()

    # 输出 JSON
    if args.json or (args.output and args.output.endswith(".json")):
        json_output = json.dumps(result, ensure_ascii=False, indent=2)
        if args.output:
            Path(args.output).write_text(json_output, encoding="utf-8")
            print(f"✅ JSON 报告已保存: {args.output}")
        else:
            print(json_output)
        return

    # 输出 HTML
    if args.output and args.output.endswith(".html"):
        generate_html_report(result, Path(args.output))
        print(f"✅ HTML 报告已生成: {args.output}")
        return

    # 终端输出
    print_terminal_report(result)

    # 如果指定了输出,保存 JSON 或 HTML(根据扩展名)
    if args.output:
        if args.output.endswith(".html"):
            generate_html_report(result, Path(args.output))
        else:
            Path(args.output).write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
        print(f"✅ 报告已保存: {args.output}")

if __name__ == "__main__":
    main()

集成到 lh 命令

在 bin/lh 中增加子命令:

lh_掀黑箱() {
    python3 ~/longhun-system/bin/lh_掀黑箱.py "$@"
}

使用方式

1️⃣ 审计当前项目(龙魂系统自身)

lh 掀黑箱

2️⃣ 审计其他项目/平台

lh 掀黑箱 /path/to/other/project

3️⃣ 输出 JSON(供其他工具消费)

lh 掀黑箱 --json

4️⃣ 生成 HTML 报告(可分享)

lh 掀黑箱 --output report.html

输出示例(终端)

======================================================================
🐉 龍魂 · 掀黑箱审计报告
======================================================================
  目标: /Users/uid9622/some-project
  时间: 2026-07-31T16:30:00
  文件数: 342
----------------------------------------------------------------------

📊 风险摘要
  🔴 严重: 2
  🟠 高危: 5
  🟡 中危: 8
  🟢 低危: 1

  总体评估: 🔴 高风险,建议立即处理

🔍 详细发现
----------------------------------------------------------------------
1. 🔴 严重 数据外流接口
   发现外部API调用: https://api.openai.com/v1/chat/completions
   📎 文件: src/ai/client.py

2. 🔴 严重 闭源/专有依赖
   依赖 tensorflow 在 requirements.txt 中
   📎 依赖 tensorflow 在 requirements.txt 中

3. 🟠 高危 主权声明缺失
   项目缺少LICENSE或主权声明文件,无法确定授权归属。
   📎 未找到 LICENSE 文件

...

📜 主权声明检查
  LICENSE: ❌ 缺失
  README: ✅ 存在
  主权声明: ❌ 未声明

🌐 硬编码外部URL(前3个)
  https://api.openai.com/v1/chat/completions (src/ai/client.py)
  https://cdn.jsdelivr.net/npm/... (static/index.html)
  https://fonts.googleapis.com/... (static/style.css)
  ... 还有 12 个

======================================================================
DNA: #龍芯⚡️20260731163000-掀黑箱-UID9622

审计规则说明

规则严重级别检测内容
闭源/专有依赖🔴 严重Oracle、MySQL Connector、TensorFlow 等
数据外流接口🔴 严重硬编码的外部 API URL
主权声明缺失🟠 高危缺少 LICENSE 或主权说明
外部云服务依赖🟠 高危AWS、Azure、GCP 等 SDK
未签名二进制🟡 中危.exe、.dll、.so 文件
疑似后门/隐蔽通信🔴 严重加密库、SSH、反向 Shell 等
开源合规文件缺失🟡 中危CONTRIBUTING、CODE_OF_CONDUCT
未适配国产环境🟡 中危未标注鲲鹏/龙芯支持

现在你有了一个 可审计任何平台 的掀黑箱引擎。对着任意项目跑一下,立马知道它有没有“技术卖国”的嫌疑。🐉

船载 OpenHarmony AIS 航海工作台:告警与防碰撞预警系统 船载OpenHarmony AIS航海工作台的告警与防碰撞系统,集成十余类告警(超速、偏航、会遇、SOS等),通过网格空间索引实现高效邻近判定,保障实时性。告警管理器统一调度规则、去重、通知与日志,支持悬浮球、语音、跑马灯、弹窗多渠道触达,确保航行安全。SOS紧急通道独立运行,避免干扰。系统设计强调性能优化与多场景适配,为航海安全提供核心支撑。 阅读详情

相关推荐

AI 应用开发:四维架构落地实战——以 HR Agent 为例拆解感知·推理·记忆·执行【意图路由、规划编排、长期记忆、工具执行、面试题】

本文基于四维架构(感知·推理·记忆·执行),以HR Agent为例,系统拆解大模型应用从“聊天”到“生产可用”的落地路径。通过Spring AI实现意图路由、规划编排、RAG检索与工具调用,结合真实踩坑复盘,揭示架构化设计对安全、成本与可维护性的关键价值,为AI Agent工程化提供可复用的实战框架。

王大师企业官方博客 1334

AI 写的测试测的是它自己:断言锁死输出,功能改错它也测不出来

AI 生成的测试跑得勤、全绿、上线前不报错,但三个月后维护时发现它已经"测的是自己"——断言用实现逻辑生成期望值,功能改错了测试还是绿的。这篇用一组沙箱演练量"可测性":同一个实现、同一批订单、两版测试(AI 风格·字面量锁死 vs 人写规范·业务谓词),走三组对照。结论反直觉:需求不变时两版测试都绿;需求一演进,A 版测试先误报(锁死输入结构,代码没 bug 却红),"修"完就变成测自己,之后功能改错它照样绿;B 版测试不误报、改错就红。跑得绿不等于测得住。

四六的六专栏 272

硬件基础(4):(7)ADC电压采集:软件校准(标定、拟合)

在实际项目中,**软件端校准**可以有效弥补硬件方面(分压电阻误差、放大器失调、参考源误差等)带来的系统性偏差,从而提高 ADC 测量精度。下面是一个常见的**多点实测校准**流程与思路,个人感觉传感器标定的原理也只这样。

FCZlll的博客 6250

AI 问数真的能替代 BI 报表吗?

AI问数赋能自然语言查询,提升临时分析效率,但无法替代传统报表。报表适用于稳定输出与持续监控,AI则擅长探索性提问。企业用好AI问数,关键在于夯实数据模型、统一指标口径、健全权限体系与结果校验机制。合理组合报表、仪表板与AI,才能实现高效、准确的业务洞察。

葡萄城技术团队博客 362

Monocle2在R 4.3环境下的终极避坑指南:从安装到可视化全流程解析

本文提供了在R 4.3环境下安装和运行Monocle2的完整解决方案,重点解决了依赖包兼容性、源码修改及BEAM分析报错等关键问题。文章详细解析了从环境准备、依赖包处理、源码安装验证到从Seurat对象转换、拟时轨迹构建、高级可视化及性能优化的全流程,旨在帮助用户顺利完成单细胞拟时分析。

weixin_29206669的博客 1359

高通SA8155P车载Camera开发避坑指南:从硬件拓扑到AIS服务调试全流程

本文详细解析了高通SA8155P车载Camera开发全流程,从硬件拓扑设计到AIS(Automotive Imaging System)服务调试,涵盖关键组件配置、软件架构剖析及高级调试技巧。通过实战经验分享,帮助开发者避开常见陷阱,优化系统性能,适用于智能驾驶系统的环境感知开发。

weixin_42550597的博客 332

ChatGPT、Perplexity、Gemini 与 AI Overviews 引用对比:谁的引用更可信

AI 引擎的引用机制差异很大:ChatGPT 以行内引用加 Sources 列表呈现来源,Perplexity 几乎逐句可溯源,Gemini 在回答中内嵌相关来源链接,AI Overviews 则把多源聚合答案与来源列表一起放在搜索结果顶部。本文从引用透明度、来源偏好、可干预性 3 个维度对比这 4 个引擎,并给出 GEO 的 3 点启示,帮企业在多引擎环境下提升被引用的概率。

淡然一笑 的专栏 303

从亚稳态到流片失败:SpyGlass CDC在5G芯片设计中的避坑指南

本文深入探讨了在复杂5G芯片设计中,如何利用SpyGlass CDC工具构建高效的时钟域交叉验证流程,以避免因亚稳态问题导致的流片失败。文章结合实战经验,详细解析了从约束编写、时钟复位完整性检查到层次化验证和特殊场景处理的全过程,并强调了精准的检查约束是确保验证有效性的基石,旨在帮助设计团队安全跨越异步时钟域的雷区。

weixin_29168153的博客 446

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 624

用Python+OpenCV搞定线激光相机标定:从棋盘格到3D点云的保姆级实战

本文详细介绍了使用Python和OpenCV进行线激光相机标定的全流程实战,从硬件准备到3D点云重建。涵盖相机内参标定、激光平面方程拟合、三维重建等关键技术,提供完整的代码实现和工程优化建议,帮助开发者实现毫米级精度的工业检测和三维测量系统。

weixin_29227425的博客 288

构建栅格地图matlab代码

1 使用MATLAB实现地图栅格化 效果图如下所示 图1 ...

qq_59747472的博客 4520

抽象主义人工智能和生命体AI的内在联系

彭军辉提出“抽象主义人工智能”作为第四大AI范式,批判符号主义、连接主义、行为主义剥离生命本体的误区,确立“智能是现象,生命是本体”的核心公理。主张原生智能必须依附具备存续诉求的生命本体,提出“生命体AI理论”,构建七层演化阶梯与自闭环工程框架,强调智能不可跳过底层存续机制直接模拟语言。该体系为生成式AI提供科学边界,推动从“仿真表象”向“原生智能”的范式跃迁,开辟硅基人工生命新赛道。

抽象主义人工智能和生命体AI 215

机器人中的数值优化(十二)——带约束优化问题简介、LP线性规划

本系列文章主要是我在学习《数值优化》过程中的一些笔记和相关思考,主要的学习资料是深蓝学院的课程《机器人中的数值优化》和高立编著的《数值最优化方法》等,本系列文章篇数较多,不定期更新,上半部分介绍无约束优化,下半部分介绍带约束的优化,中间会穿插一些路径规划方面的应用实例

慕羽★的博客 3854

OpenAI Control Room 架构拆解:给企业 AI Agent 加一套可审计的急停系统

OpenAI 公开了用于追踪和停止研究模型工作负载的 Control Room。本文拆解 job_id、推理前鉴权、35 秒撤销窗口与 Fail Closed 设计,并给出企业 AI Agent 急停控制面的数据模型、FastAPI 参考实现、缓存撤销策略和故障演练清单。

jerry764的博客 348

第9集:AI 驱动的智能日志分析!用 RAG 实现秒级日志检索与异常检测

文章摘要:AI驱动的智能日志分析系统 本文介绍了一个基于RAG(检索增强生成)技术的智能日志分析解决方案,旨在解决传统日志系统中的三大痛点:机械的关键词搜索、缺乏语义理解、告警与日志割裂。系统通过以下步骤实现: 环境准备:安装必要的Python依赖库,包括日志处理、Elasticsearch/Loki连接和时序异常检测工具。 核心设计:构建日志处理流水线,分为日志采集、向量化存储和AI检索分析三个阶段,创建专门的日志分析Agent。 技术实现:使用ChromaDB存储日志向量,通过HuggingFace E

qq_2937655951的博客 81

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

多模态试驾预约Agent实战案例

本章将实现一个完整的多模态试驾预约Agent应用系统,该系统实现了从多模态输入解析到试驾全流程(预约、调度、调整、信息查询)的闭环处理,适用于汽车试驾预约的智能化服务场景。系 统 概 述该项目“多模态试驾预约Agent”是一个集成多模态交互与试驾全流程管理的系统,主要功能概述如下。1. 多模态输入处理支持文本、语音、图片三种输入方式的解析与处理。(1)文本输入:识别用户意图(如“试驾预约”“价格查询”等),并提供针对性操作建议。

夏天又到了的专栏 293

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

OpenClaw 深度调查:把 AI 助手做成你自己的控制平面

对 openclaw/openclaw 的完整技术尽调:Gateway 架构、Agent 运行时、工具与沙箱、30 个消息通道、181 个插件、安全信任边界、工程代价与采用建议。17 章 / 10 张图,全部数字标注口径,数据截至 2026-10-31。

厚积薄发 365

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

AI赋能智慧港口建设|造形家快速生成港口全要素三维场景

随着智慧港口、港口数字孪生项目的持续推进,港口三维场景的需求日益旺盛。传统港口三维建模,往往需要航拍倾斜摄影采集数据,再人工搭建吊机、岸桥、船舶、集装箱等大量工业设施模型,项目周期长、人力成本高,修改迭代繁琐,制约港口可视化项目落地效率。国产AI三维建模工具,依托卫星影像 AI 识别能力,无需航拍作业,一键快速搭建港口完整三维场景,为港口数字孪生、方案汇报、投标演示提供高效的场景解决方案。

m0_69539167的博客 90

从设备增点到治理闭环:老旧小区物业数智化落地实践

系统连接合同审批、银行流水、收费记录与项目台账,执行到期提醒、收入核验、异常标色和月度对账,让每一笔资金来源明确、去向可查。针对设施老旧、诉求响应慢、公共收益不透明等问题,津南以6类小区为试点场景,统一建设物业数字化底座,关联楼栋、单元、房屋、业主、空间、设施设备、工单、公共收益等核心数据。系统采用统一编码管理,将摄像头、路灯、井盖、道路、绿化等设施纳入资产台账,解决纸质记录更新滞后、故障责任难追溯的问题。基于历史工单建立分类模型和知识库,辅助识别照明、给排水、电梯、环境秩序、秩序维护等问题;

wuyeshuzhihua的博客 164

企业微信iPad协议详解:接口接入、实时消息同步与语音转码实践

深入解析企业微信iPad协议的技术架构与开发思路,涵盖API接口接入、长连接通信、实时消息同步、Silk语音转码、异常重连及高并发优化,帮助开发者了解企业微信自动化系统的设计与实现。

欢迎来到祖安! 521

Product Hunt 热榜 2026-11-13:Plurai Simulation、YouArt Desktop App、Omnigraph

2026-11-13 Product Hunt 新产品精选:Plurai Simulation、YouArt Desktop App、Omnigraph。汇总 15 款产品的中文介绍、功能关键词和产品链接。

LaughingZhu的博客 627

【AI Agent面试系列】AI Agent可观测、评测、安全相关的知识点

之前的文章介绍了和,本文主要介绍AI Agent的测评、可观测等知识。

413

Docling 原理解读:是什么、为什么、怎么样

从论文视角拆解 Docling 的整体架构、DoclingDocument 数据模型、PDF 预处理、版面分析、OCR、TableFormer 双解码器、阅读顺序与装配流程,并解释版面框与 OCR 框的区别。

PLANTTHESON的博客 404

WorkBuddy 实战:一句话需求 → 七屏可交互原型,户外徒步 App 的 AI 设计全流程

WorkBuddy 实战:一句话需求 → 七屏可交互原型,户外徒步 App 的 AI 设计全流程,跟着博主一起来还原整个过程。

夜郎King的博客 5193

从认识人工智能到理解机器学习:我的 AI 入门第一课

正式开始学习人工智能之前,我对 AI 的认识其实比较模糊:知道 ChatGPT、知道大模型,也知道现在很多岗位都在谈 AI,但如果有人问我“人工智能到底是什么”“机器是怎么学会识别一只猫的”,我未必能从头到尾讲清楚。上午的课程更偏向行业全景:人工智能的发展、研究方向、NLP、岗位分工、学习路线和 AI Coding 工具。下午的课程更偏向技术基础:机器学习的原理、有监督学习、深度学习、模型训练和评估方法。

chh563的博客 585

明确边界:在AI工程实践中重构自我定位

分析在AI应用的过程中,人应该如何参与进去:通过AI去解决人无法分析的问题,但是这个过程中又需要人去判断,比如安全的边界和决策。从开始无法理解这种情景下存在的一定矛盾性,到通过不断实践后确定自己在整个过程的位置,达到能够更有针对性的补充知识体系的目的。

CC_77123的博客 167
上一篇: 多维度对标:你能跟谁比?(DeepSeek 底部都没提示 AI 生成,这个老登还是有点厚道的。)
下一篇: 龍魂·数学难题解决工作流 — 解题报告(lh_math_solve_report)
龍芯北辰UID9622
博客等级 码龄164天 5粉丝 501原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值