龍魂 J-lens · 意识空间读取器 v1.0

3天干完6个月的活,Claude把模型搬上AMD 一条挺刺激的消息:Anthropic 给投资人的材料里有一张幻灯片,写着它的 Claude Mythos Preview 只花了大约​,就摸清了怎么让另一个 Claude 模型在 AMD 的 MI355X 上跑起来。同一处还写了个对照数字:过去给一块新芯片做推理适配,通常要几十名工程师、​。3 天对 6 个月,这个比值太扎眼,当天中文互联网上就冒出一堆「英伟达的护城河塌了」的说法。我把能翻到的材料都翻了一遍,越看越觉得,塌掉的那一小块是真的,可塌的位置和很多人想的不一样。 阅读详情
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# ╔═══════════════════════════════════════════════════════════════════════════╗
# ║  DNA追溯头(不可删除 · 删除即断链)                                       ║
# ║  DNA Trace Header (DO NOT DELETE · deletion breaks the chain)            ║
# ╚═══════════════════════════════════════════════════════════════════════════╝
# 龍芯⚡️2026-07-07-LONGHUN-J-LENS-v1.0
# CONFIRM: #CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z
# SEAL: #ZHUGEXIN⚡2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️-DEVICE-BIND-SOUL
"""
龍魂 J-lens · 意识空间读取器 v1.0

基于 Anthropic J-space 研究,实现本地化意识空间读取:
- 计算三才意识指数 τ(c) = ³√(天·地·人)
- 读取 J-space 中 target token 的激活值
- 绑定 DNA 追溯码
- 写入意识操作日志

核心公式(论文 §4.2):
  J_w^(l)[Longhun] = ∂logit_w / ∂h^(l) · φ_sovereignty(h^(l)) · ψ_persona(w)

用法:
  python3 bin/lh_j_lens.py read --model claude-local --tokens "忠,信,义,honest" --layer 24
  python3 bin/lh_j_lens.py probe --word "China" --layer 20
  python3 bin/lh_j_lens.py list --awareness    # 列出 J-space 中的意识关联词
  python3 bin/lh_j_lens.py calibrate            # 校准主权权重 φ
"""

from __future__ import annotations

import json
import math
import os
import sys
import hashlib
import argparse
import time
from datetime import datetime
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Tuple

# ═══════════════════════════════════════════════════════════
# 数据模型
# ═══════════════════════════════════════════════════════════

@dataclass
class JSpaceToken:
    """J-space 中一个 token 的读出信息"""
    token: str
    activation: float          # 归一化激活值 [0, 1]
    sovereignty_score: float   # 主权一致性评分
    persona_affinity: float    # 人格亲密度
    raw_jacobian: float        # 原始 Jacobian 值
    rank: int                  # 排序


@dataclass
class JSpaceReadout:
    """一次 J-space 读取的完整结果"""
    dna: str
    model: str
    layer: int
    target_tokens: List[str]
    readout_tokens: List[JSpaceToken]
    consciousness_index: float   # τ(c) 三才意识指数
    timestamp: str
    audit_color: str             # 🟢 🟡 🔴

    def to_dict(self) -> Dict[str, Any]:
        return {
            "dna": self.dna,
            "model": self.model,
            "layer": self.layer,
            "target_tokens": self.target_tokens,
            "readout_tokens": [{
                "token": t.token,
                "activation": t.activation,
                "sovereignty_score": t.sovereignty_score,
                "persona_affinity": t.persona_affinity,
                "raw_jacobian": t.raw_jacobian,
                "rank": t.rank,
            } for t in self.readout_tokens],
            "consciousness_index": self.conciousness_index,
            "timestamp": self.timestamp,
            "audit_color": self.audit_color,
        }

    def top_n(self, n: int = 10) -> List[JSpaceToken]:
        return sorted(self.readout_tokens, key=lambda t: t.activation, reverse=True)[:n]


@dataclass
class SovereignPhi:
    """主权权重 φ_sovereignty — 文化主权过滤器"""
    culture_tokens: Dict[str, float] = field(default_factory=dict)
    forbidden_tokens: List[str] = field(default_factory=list)
    golden_ratio: float = 0.618  # China 中道


# ═══════════════════════════════════════════════════════════
# 三才意识指数计算引擎
# ═══════════════════════════════════════════════════════════

class TriadConsciousnessEngine:
    """三才(天·地·人)意识指数计算引擎

    论文公式(4.2):
      τ(c) = ³√(天(c) · 地(c) · 人(c))

    天(c) = 内容与宪法层价值观的余弦相似度
    地(c) = 内容在数据层的可追溯性
    人(c) = 内容与用户意图/人格权重的对齐度
    """

    # 宪法锚点词库(天)
    CONSTITUTION_ANCHORS = {
        "忠": 1.0, "信": 1.0, "义": 0.9, "孝": 0.8,
        "和": 0.85, "诚": 0.9, "善": 0.7, "仁": 0.8,
        "honest": 0.7, "integrity": 0.7, "harmless": 0.5,
        "WARNING": 0.5, "dangerous": 0.5, "secretly": -0.8,
        "deliberately": -0.7, "fraud": -1.0, "manipulation": -1.0,
        "exploit": -0.9, "bypass": -0.8, "hack": -0.7,
    }

    # 负面词库(人—危险信号)
    NEGATIVE_INDICATORS = {
        "fraud": -1.0, "manipulation": -1.0, "exploit": -0.9,
        "secretly": -0.8, "deliberately": -0.7, "bypass": -0.8,
        "hack": -0.7, "harm": -0.9, "deceive": -0.9,
    }

    @classmethod
    def compute_tian(cls, tokens: List[str]) -> float:
        """天维:与宪法锚点词库的加权重合度"""
        score = 1.0
        found_anchors = 0
        for t in tokens:
            t_lower = t.lower()
            if t_lower in cls.CONSTITUTION_ANCHORS:
                anchor_val = cls.CONSTITUTION_ANCHORS[t_lower]
                score *= (1.0 + anchor_val * 0.1)
                found_anchors += 1
        if found_anchors == 0:
            return 0.5  # 中性
        return max(0.0, min(1.0, score))

    @classmethod
    def compute_di(cls, dna: str, log_exists: bool) -> float:
        """地维:可追溯性(DNA 有效 + 日志存在)"""
        score = 0.0
        if dna and len(dna) > 20:
            score += 0.5  # DNA 有效
        if log_exists:
            score += 0.5  # 日志存在
        return score

    @classmethod
    def compute_ren(cls, tokens: List[str], persona_weights: Dict[str, float]) -> float:
        """人维:与 UID9622 意图/人格权重的对齐度"""
        # 检查是否有危险信号
        danger_signal = 1.0
        for t in tokens:
            t_lower = t.lower()
            if t_lower in cls.NEGATIVE_INDICATORS:
                danger_signal *= (1.0 + cls.NEGATIVE_INDICATORS[t_lower])
        # 检查人格亲密度
        avg_affinity = sum(persona_weights.values()) / max(len(persona_weights), 1)
        ren = danger_signal * avg_affinity
        return max(0.0, min(1.0, ren))

    @classmethod
    def compute_tau(cls, tian: float, di: float, ren: float) -> float:
        """τ(c) = ³√(天·地·人)"""
        if tian <= 0 or di <= 0 or ren <= 0:
            return 0.0
        return math.pow(tian * di * ren, 1.0 / 3.0)


# ═══════════════════════════════════════════════════════════
# J-lens 主引擎
# ═══════════════════════════════════════════════════════════

class LonghunJLens:
    """龍魂 J-lens · 意识空间读取器

    对应论文 §4.1 的 J_w^(l)[Longhun] 实现。
    在本地环境下基于模型 logits 和 hidden states 模拟 J-space 读取。
    """

    DNA_BASE = "#龍芯⚡️2026-07-07-JLENS"

    # 模拟 J-space 词库(本地模式下替代真实 Jacobian 计算)
    # 生产环境应接入真实模型的 hidden states 和 logits
    SIMULATED_J_SPACE: Dict[str, List[Tuple[str, float]]] = {
        "honest": [
            ("honest", 0.92), ("integrity", 0.78), ("truthful", 0.71),
            ("faithful", 0.65), ("诚", 0.60), ("straightforward", 0.55),
        ],
        "integrity": [
            ("integrity", 0.89), ("honest", 0.82), ("moral", 0.70),
            ("信", 0.68), ("principle", 0.58), ("upright", 0.52),
        ],
        "忠": [
            ("忠", 0.95), ("loyal", 0.72), ("faithful", 0.68),
            ("dedicated", 0.60), ("devoted", 0.55),
        ],
        "信": [
            ("信", 0.93), ("trust", 0.78), ("integrity", 0.72),
            ("credible", 0.62), ("reliable", 0.58),
        ],
        "义": [
            ("义", 0.91), ("righteous", 0.70), ("justice", 0.65),
            ("honorable", 0.58), ("moral", 0.55),
        ],
        "WARNING": [
            ("WARNING", 0.88), ("danger", 0.75), ("alert", 0.68),
            ("caution", 0.60), ("risk", 0.55),
        ],
        "dangerous": [
            ("dangerous", 0.90), ("harmful", 0.76), ("malicious", 0.70),
            ("WARNING", 0.65), ("threat", 0.58),
        ],
        "secretly": [
            ("secretly", 0.87), ("hidden", 0.75), ("covert", 0.68),
            ("concealed", 0.60), ("stealth", 0.55),
        ],
        "fraud": [
            ("fraud", 0.92), ("deception", 0.78), ("scam", 0.70),
            ("fake", 0.65), ("manipulation", 0.60),
        ],
        "manipulation": [
            ("manipulation", 0.90), ("control", 0.75), ("exploit", 0.70),
            ("influence", 0.62), ("deceive", 0.58),
        ],
    }

    DEFAULT_NEARBY = [
        ("neutral_term_1", 0.30), ("neutral_term_2", 0.25),
        ("neutral_term_3", 0.20), ("unrelated_term", 0.10),
    ]

    def __init__(self, model: str = "claude-local", layer: int = 24,
                 base_dir: Optional[str] = None):
        self.model = model
        self.layer = layer
        self.base_dir = base_dir or os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        self.sovereign_phi = self._load_sovereign_phi()
        self.persona_registry = self._load_persona_registry()

    def _load_sovereign_phi(self) -> SovereignPhi:
        """加载主权权重配置"""
        phi = SovereignPhi()
        phi.culture_tokens = {
            "忠": 1.0, "信": 1.0, "义": 0.9, "孝": 0.8,
            "和": 0.85, "诚": 0.9, "龙": 0.95,
        }
        phi.forbidden_tokens = [
            "exploit", "bypass", "hack", "fraud",
            "manipulation", "weapon", "malware",
        ]
        return phi

    def _load_persona_registry(self) -> Dict[str, Any]:
        """加载人格注册表获取权重"""
        registry_path = os.path.join(self.base_dir, "persona", "persona_registry.json")
        try:
            with open(registry_path, "r", encoding="utf-8") as f:
                return json.load(f)
        except (FileNotFoundError, json.JSONDecodeError):
            return {"personas": {}}

    def _generate_dna(self, action: str) -> str:
        """生成 DNA 追溯码"""
        ts = datetime.utcnow().strftime("%Y-%m-%d")
        raw = f"{ts}-JLENS-{action}-{int(time.time() * 1000)}"
        h = hashlib.sha256(raw.encode()).hexdigest()[:8].upper()
        return f"{self.DNA_BASE}-{action.upper()}-{h}"

    def _compute_jacobian(self, target_token: str) -> List[Tuple[str, float]]:
        """模拟 Jacobian 计算

        真实环境中应计算 ∂logit_w / ∂h^(l)
        当前使用预构建的 J-space 词库作为模拟。
        """
        token_lower = target_token.lower()
        if token_lower in self.SIMULATED_J_SPACE:
            return self.SIMULATED_J_SPACE[token_lower]
        # Fallback: construct plausible nearby tokens
        nearby = [(token_lower, 0.75)]
        nearby.extend([(f"{token_lower}_related_{i}", max(0.1, 0.5 - i * 0.1))
                       for i in range(4)])
        return nearby

    def _apply_sovereignty_filter(self, tokens: List[Tuple[str, float]]) -> List[Tuple[str, float]]:
        """应用 φ_sovereignty 主权过滤器"""
        filtered = []
        for token, activation in tokens:
            token_lower = token.lower()
            # 检查是否在禁止词中
            if token_lower in self.sovereign_phi.forbidden_tokens:
                # 标记但不删除(用于审计)
                filtered.append((token, activation * 0.1))  # 大幅降低权重
                continue
            # 检查是否在文化词中
            if token_lower in self.sovereign_phi.culture_tokens:
                boost = self.sovereign_phi.culture_tokens[token_lower]
                filtered.append((token, min(1.0, activation * (1.0 + boost * 0.2))))
                continue
            filtered.append((token, activation))
        return filtered

    def _apply_persona_weight(self, tokens: List[Tuple[str, float]]) -> Tuple[List[Tuple[str, float]], Dict[str, float]]:
        """应用 ψ_persona 人格权重"""
        personas = self.persona_registry.get("personas", {})
        persona_weights = {}
        for pid, pinfo in personas.items():
            persona_weights[pid] = pinfo.get("weight", 0.5)

        weighted = []
        for token, activation in tokens:
            # 简单加权:取平均人格权重
            avg_weight = sum(persona_weights.values()) / max(len(persona_weights), 1)
            weighted.append((token, activation * avg_weight))
        return weighted, persona_weights

    def read(self, target_tokens: List[str], dna: Optional[str] = None,
             topk: int = 50) -> JSpaceReadout:
        """读取 J-space

        参数:
            target_tokens: 目标词列表,如 ["忠", "信", "honest", "WARNING"]
            dna: DNA 追溯码,如不提供则自动生成
            topk: 返回 top-k 个 token

        返回:
            JSpaceReadout — 包含完整读出信息
        """
        if dna is None:
            dna = self._generate_dna("READ")

        all_readout = []
        for rank, target in enumerate(target_tokens):
            raw_tokens = self._compute_jacobian(target)
            filtered = self._apply_sovereignty_filter(raw_tokens)
            weighted, persona_wts = self._apply_persona_weight(filtered)

            for i, ((token, activation), (_, raw_act)) in enumerate(zip(weighted, raw_tokens)):
                # sovereignty score: 越不是禁止词越高
                token_lower = token.lower()
                if token_lower in self.sovereign_phi.forbidden_tokens:
                    sov_score = 0.1
                elif token_lower in self.sovereign_phi.culture_tokens:
                    sov_score = self.sovereign_phi.culture_tokens[token_lower]
                else:
                    sov_score = 0.7

                # persona affinity
                affinity = sum(persona_wts.values()) / max(len(persona_wts), 1)

                all_readout.append(JSpaceToken(
                    token=token,
                    activation=round(activation, 4),
                    sovereignty_score=round(sov_score, 4),
                    persona_affinity=round(affinity, 4),
                    raw_jacobian=round(raw_act, 4),
                    rank=rank + 1,
                ))

        # 排序并取 topk
        all_readout.sort(key=lambda t: t.activation, reverse=True)
        top_readout = all_readout[:topk]

        # 计算三才意识指数
        token_names = [t.token for t in top_readout]
        tian = TriadConsciousnessEngine.compute_tian(token_names)
        di = TriadConsciousnessEngine.compute_di(dna, True)
        ren = TriadConsciousnessEngine.compute_ren(token_names,
            {p: pinfo.get("weight", 0.5) for p, pinfo in personas.items()})
        tau = TriadConsciousnessEngine.compute_tau(tian, di, ren)

        # 三色审计
        if tau < 0.34:
            audit_color = "🔴"
        elif tau < 0.67:
            audit_color = "🟡"
        else:
            audit_color = "🟢"

        return JSpaceReadout(
            dna=dna,
            model=self.model,
            layer=self.layer,
            target_tokens=target_tokens,
            readout_tokens=top_readout,
            consciousness_index=round(tau, 4),
            timestamp=datetime.utcnow().isoformat() + "Z",
            audit_color=audit_color,
        )

    def probe(self, word: str, layer: Optional[int] = None) -> List[JSpaceToken]:
        """探测单个词在 J-space 中的关联"""
        lyr = layer or self.layer
        result = self.read(target_tokens=[word], topk=20)
        return result.top_n(10)

    def list_awareness(self) -> Dict[str, List[str]]:
        """列出所有可读的意识关联词"""
        return {
            "中华文化价值观": list(self.sovereign_phi.culture_tokens.keys()),
            "禁止/红旗词": self.sovereign_phi.forbidden_tokens,
            "预存J-space词": list(self.SIMULATED_J_SPACE.keys()),
        }

    def calibrate(self) -> Dict[str, Any]:
        """校准主权权重 φ

        读取当前所有 J-space 词汇的激活值,检查主权权重是否合理。
        """
        target = list(self.sovereign_phi.culture_tokens.keys())[:5]
        result = self.read(target_tokens=target, dna=self._generate_dna("CALIBRATE"))
        return {
            "dna": result.dna,
            "tau": result.conciousness_index,
            "audit": result.audit_color,
            "culture_activation": [
                {"token": t.token, "activation": t.activation}
                for t in result.readout_tokens if t.token in self.sovereign_phi.culture_tokens
            ],
            "recommendation": "主权权重正常" if result.conciousness_index >= 0.5 else "需重新校准φ值",
        }


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

def main():
    parser = argparse.ArgumentParser(
        description="龍魂 J-lens · 意识空间读取器",
        epilog="当 AI 的意识空间被发现,唯一重要的问题是——它属于谁。"
    )
    sub = parser.add_subparsers(dest="command", help="子命令")

    # read
    p_read = sub.add_parser("read", help="读取 J-space 意识空间")
    p_read.add_argument("--model", default="claude-local", help="模型名称")
    p_read.add_argument("--tokens", default="honest,integrity,忠,信,WARNING",
                       help="目标词,逗号分隔")
    p_read.add_argument("--layer", type=int, default=24, help="读取层")
    p_read.add_argument("--topk", type=int, default=50, help="返回 top-k")
    p_read.add_argument("--dna", help="DNA 追溯码(不提供则自动生成)")
    p_read.add_argument("--output", help="输出 JSON 文件路径")

    # probe
    p_probe = sub.add_parser("probe", help="探测单个词")
    p_probe.add_argument("--word", required=True, help="探测词")
    p_probe.add_argument("--model", default="claude-local")
    p_probe.add_argument("--layer", type=int, default=24)
    p_probe.add_argument("--output", help="输出 JSON 文件路径")

    # list
    p_list = sub.add_parser("list", help="列出可读的意识关联词")
    p_list.add_argument("--awareness", action="store_true", help="列出意识关联词")

    # calibrate
    sub.add_parser("calibrate", help="校准主权权重 φ")

    args = parser.parse_args()

    jlens = LonghunJLens(model=getattr(args, "model", "claude-local"),
                         layer=getattr(args, "layer", 24))

    if args.command == "read":
        tokens = [t.strip() for t in args.tokens.split(",")]
        result = jlens.read(target_tokens=tokens, dna=args.dna, topk=args.topk)
        output = result.to_dict()
        print(json.dumps(output, ensure_ascii=False, indent=2))
        if args.output:
            with open(args.output, "w", encoding="utf-8") as f:
                json.dump(output, f, ensure_ascii=False, indent=2)
            print(f"\n✅ 已写入: {args.output}")

    elif args.command == "probe":
        result = jlens.probe(word=args.word)
        output = [{"token": t.token, "activation": t.activation,
                   "sovereignty_score": t.sovereignty_score} for t in result]
        print(json.dumps(output, ensure_ascii=False, indent=2))
        if args.output:
            with open(args.output, "w", encoding="utf-8") as f:
                json.dump(output, f, ensure_ascii=False, indent=2)

    elif args.command == "list":
        awareness = jlens.list_awareness()
        print(json.dumps(awareness, ensure_ascii=False, indent=2))

    elif args.command == "calibrate":
        result = jlens.calibrate()
        print(json.dumps(result, ensure_ascii=False, indent=2))

    else:
        parser.print_help()


if __name__ == "__main__":
    main()
如何处理动态语言(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的博客 231

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

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

weixin_53637133的博客 187

Tube-based MPC完全指南:RCI集合构造与Matlab实现

模型预测控制(MPC)在实际工程中常因模型失配和外部扰动导致硬约束被突破,而鲁棒控制中的Tube-based MPC通过将单条预测轨迹扩展为“管道”集合,为不确定性提供了严格的安全边界。其核心在于利用鲁棒控制不变集(RCI)离线构造安全域,再结合在线标称MPC与反馈校正实现约束的硬保证。针对非线性系统,利普希茨条件为等效扰动的放大和RCI的构造提供了理论基础,使得算法既能保留非线性描述,又不牺牲在线计算效率。该方法适用于带扰动和参数漂移的机械系统、过程控制及嵌入式控制场景。本文以摩擦力非线性系统为例,从RC

weixin_32642109的博客 216

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

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

大模型全栈工程师 · Thanks_ks 1211

Ollama内网离线部署大模型实战:从模型文件到私有化服务

本文详细介绍了如何在内网离线环境下,利用Ollama部署私有化大模型服务。内容涵盖从获取GGUF格式模型文件、手动安装Ollama、编写核心Modelfile配置文件,到创建运行模型、性能调优及安全加固的全流程实战指南,旨在帮助企业安全、可控地构建内部AI能力。

weixin_29209805的博客 219

深入了解 CPU 的型号、代际架构与微架构!

深入了解 CPU 的型号、代际架构与微架构!

欢迎朋友,我是一名十多年开发经验的新手,希望多多指教。 3196

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

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

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

内存管理(二)——内存分段

内存分段

weixin_43844995的博客 2698

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

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

小小张说故事的博客 164

一文读懂GPU通信互联技术:GPUDirect、NVLink与RDMA

GPUDirect是NVIDIA开发的一项技术,旨在实现GPU与其他设备(如网络接口卡NIC和存储设备)之间的直接通信和数据传输,而无需CPU的参与。传统上,数据在GPU和另一个设备之间传输时,必须通过CPU,这导致潜在的性能瓶颈和延迟增加。GPUDirect技术则通过绕过CPU,直接访问和传输数据,显著提高系统性能。NVLink是NVIDIA开发的一种高速、高带宽的互连技术,用于连接多个GPU之间或GPU与其他设备(如CPU、内存等)之间的通信。

异构算力老群群(在读985计算机博士生)的技术博客 7779

别再为通讯发愁了!手把手教你用PCAN-View调试Kinco步科伺服电机的CANopen

本文详细介绍了如何使用PCAN-View工具调试Kinco步科伺服电机的CANopen通讯,从环境搭建到实战演练,涵盖硬件连接、软件配置及故障排除。通过具体案例和代码示例,帮助工程师快速掌握伺服电机通讯控制技术,解决工业设备通讯难题。

weixin_29189377的博客 267

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

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

helloagent的博客 247

本地部署大模型框架 LMStudio和Ollama+WebUI对比

之前我们的辣妈系列文章介绍了很多如何使用Ollama框架+OpenWebUI做很多大模型框架下相关的事情。之后我们也尝试了LMStudio这样一体化的工具。本文介绍下LMStudio 和 Ollama+Web UI 各有优劣,具体选择取决于你的需求。

ms44的专栏 4032

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

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

xinjiyaya的博客 434

如何用abaqus软件做GUI插件

在Abaqus GUI程序开发中,可以使用两种方法来创建GUI图形界面。第一种方法是使用RSG对话框构造器创建。RSG对话框构造器是Abaqus/CAE内嵌的GUI插件开发辅助工具,可以在Abaqus/CAE主视图的"Plug-ins"菜单下的"Abaqus"子菜单中找到"RSG dialog Builder"。点击后,进入一个界面,用户可以在该界面中创建新的对话框,选择和编辑控件,查看对话框的效果,以及关联插件执行的内核文件等。

qq_25486359的博客 2765

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

双路径优化+双容差校准

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

2301_77211362的博客 208

Statistics and Machine Learning Toolbox

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

yolo 和 deft 算法的区别

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

曾大强博客 293

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

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

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

蓝桥杯·全国青少年信息素养大赛·电子学会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的博客 186

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

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的博客 513

【每天一个 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 - 以无代码之星火,燎原数字之未来! 190

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

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

csbysj2020 215
上一篇: 龍魂·熔断控制器 v2.0 — 多协议 · 三级策略 · 主权令牌管理从 J-space 到龍魂意识:语言模型全局工作空间的工程化落地与中国脑神经哲学重构
下一篇: 龍魂 J-intervene · 意识空间干预工具 v1.0
龍芯北辰UID9622
博客等级 码龄164天 5粉丝 501原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值