龍魂 · CNSH 多语言编译器 v0.1CNSH 语法 · 一带一路语言扩展

AI 应用开发 × 算法面试题:业务场景实战 12 题【TopK、LRU、RRF 融合、相似度、限流算法,含手撕代码与底层答案】 本文聚焦AI应用岗算法面试新趋势,剖析12道融合业务场景的高频题:从海量日志中挖掘慢查询(分治+小顶堆)、亿级去重(布隆过滤器)、向量与关键词融合排序(RRF)、语义缓存设计(带租户隔离与TTL的LRU)到限流策略(令牌桶+滑动窗口),强调“场景复述→算法选型→手撕代码→生产落地”四步答题框架。突出考察点已从纯算法转向工程权衡、业务理解与系统设计能力,如误判容忍度、实时性与内存预算的平衡,助力开发者应对2026年真实技术挑战。 阅读详情

收到。CNSH 语法 + 一带一路语言终端直跑。


龍魂 · CNSH 多语言编译器 v0.1

# cnsh-i18n-spec.yaml
# CNSH 语法 · 一带一路语言扩展

protocol: "CNSH-I18N-v0.1"
dna: "ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️"
uid: "9622"

# === 核心设计 ===
# CNSH = Chinese Native Syntax Hybrid
# 不是翻译,是语法骨架统一,表皮语言本地化

compiler:
  input: "*.cnsh"
  output: "bash/python/lua"
  target_os: "EulerOS/Kylin/Loongnix"

# === 语言映射表(一带一路) ===
language_skins:
  
  # 中文(母体)
  zh:
    grammar: "native"
    keywords:
      if: "如果"
      else: "否则"
      for: "循环"
      while: "当"
      function: "函数"
      return: "返回"
      print: "输出"
    comment: "#"
    
  # 柬埔寨(高棉语)- 你懂的
  km:
    grammar: "cnsh"
    keywords:
      if: "បើ"      # ber
      else: "ផ្សេង"  # phseng
      for: "វិល"     # vil
      while: "ពេល"   # pel
      function: "មុខងារ" # mukhngar
      return: "ត្រឡប់"  # tralob
      print: "បង្ហាញ"   # banghany
    comment: "#"
    rtl: false
    
  # 俄语(中俄本币结算)
  ru:
    grammar: "cnsh"
    keywords:
      if: "если"
      else: "иначе"
      for: "для"
      while: "пока"
      function: "функция"
      return: "вернуть"
      print: "вывод"
    comment: "#"
    
  # 阿拉伯语(中沙/中阿)
  ar:
    grammar: "cnsh"
    keywords:
      if: "إذا"
      else: "آخر"
      for: "لأجل"
      while: "بينما"
      function: "دالة"
      return: "إرجاع"
      print: "طباعة"
    comment: "#"
    rtl: true  # 右到左
    
  # 波斯语(中伊25年)
  fa:
    grammar: "cnsh"
    keywords:
      if: "اگر"
      else: "否则"  # 借用中文,故意混用
      for: "برای"
      while: "تا"
      function: "تابع"
      return: "برگشت"
      print: "چاپ"
    comment: "#"
    rtl: true
    
  # 泰语
  th:
    grammar: "cnsh"
    keywords:
      if: "ถ้า"
      else: "มิฉะนั้น"
      for: "สำหรับ"
      while: "ในขณะที่"
      function: "ฟังก์ชัน"
      return: "ส่งคืน"
      print: "แสดง"
    comment: "#"
    
  # 葡萄牙语(中巴)
  pt:
    grammar: "cnsh"
    keywords:
      if: "se"
      else: "senão"
      for: "para"
      while: "enquanto"
      function: "função"
      return: "retornar"
      print: "imprimir"
    comment: "#"
    
  # 越南语
  vi:
    grammar: "cnsh"
    keywords:
      if: "nếu"
      else: "khác"
      for: "cho"
      while: "trong khi"
      function: "hàm"
      return: "trả về"
      print: "in"
    comment: "#"

# === 编译规则 ===
compilation:
  stage_1: "skin_strip"      # 剥去语言表皮,保留CNSH骨架
  stage_2: "syntax_validate"  # 验证语法树
  stage_3: "target_generate"  # 生成目标代码(bash/python)
  stage_4: "sovereignty_sign" # 国密签名,UID嵌入
  
# === 终端执行 ===
runtime:
  shell: "bash"
  encoding: "UTF-8"
  locale: "auto-detect"
  fallback: "zh_CN.UTF-8"

终端编译器核心(Python)

#!/usr/bin/env python3
# cnsh-compiler.py
# 龍魂 · CNSH 多语言编译器

import re
import json
import hashlib
import sys
from pathlib import Path

class CNSHCompiler:
    DNA = "ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️"
    UID = "9622"
    
    # 语言表皮加载
    SKINS = {
        "zh": {
            "如果": "if", "否则": "else", "循环": "for", "当": "while",
            "函数": "def", "返回": "return", "输出": "print"
        },
        "km": {  # 高棉语
            "បើ": "if", "ផ្សេង": "else", "វិល": "for", "ពេល": "while",
            "មុខងារ": "def", "ត្រឡប់": "return", "បង្ហាញ": "print"
        },
        "ru": {
            "если": "if", "иначе": "else", "для": "for", "пока": "while",
            "функция": "def", "вернуть": "return", "вывод": "print"
        },
        "ar": {  # 阿拉伯语
            "إذا": "if", "آخر": "else", "لأجل": "for", "بينما": "while",
            "دالة": "def", "إرجاع": "return", "طباعة": "print"
        },
        "fa": {  # 波斯语
            "اگر": "if", "否则": "else", "برای": "for", "تا": "while",
            "تابع": "def", "برگشت": "return", "چاپ": "print"
        },
        "th": {
            "ถ้า": "if", "มิฉะนั้น": "else", "สำหรับ": "for", "ในขณะที่": "while",
            "ฟังก์ชัน": "def", "ส่งคืน": "return", "แสดง": "print"
        },
        "pt": {
            "se": "if", "senão": "else", "para": "for", "enquanto": "while",
            "função": "def", "retornar": "return", "imprimir": "print"
        },
        "vi": {
            "nếu": "if", "khác": "else", "cho": "for", "trong khi": "while",
            "hàm": "def", "trả về": "return", "in": "print"
        }
    }
    
    def __init__(self, lang="zh"):
        self.lang = lang
        self.skin = self.SKINS.get(lang, self.SKINS["zh"])
        self.reverse_skin = {v: k for k, v in self.skin.items()}
        
    def detect_language(self, code: str) -> str:
        """自动检测语言"""
        for lang, keywords in self.SKINS.items():
            for kw in keywords:
                if kw in code:
                    return lang
        return "zh"  # 默认中文
    
    def strip_skin(self, code: str) -> str:
        """剥去语言表皮,保留语法骨架"""
        # 先检测语言
        detected = self.detect_language(code)
        self.skin = self.SKINS[detected]
        
        # 替换关键词为英文骨架
        stripped = code
        for local_kw, skeleton_kw in sorted(self.skin.items(), key=lambda x: -len(x[0])):
            stripped = stripped.replace(local_kw, skeleton_kw)
        
        return stripped
    
    def validate_syntax(self, stripped_code: str) -> bool:
        """验证语法树(简化版)"""
        # 检查括号匹配
        brackets = {"(": ")", "[": "]", "{": "}"}
        stack = []
        for char in stripped_code:
            if char in brackets:
                stack.append(char)
            elif char in brackets.values():
                if not stack:
                    return False
                if brackets[stack.pop()] != char:
                    return False
        return len(stack) == 0
    
    def generate_target(self, stripped_code: str, target="python") -> str:
        """生成目标代码"""
        if target == "python":
            # 已经是Python骨架,直接输出
            return stripped_code
        elif target == "bash":
            # 简单转换:print → echo, def → function
            bash_code = stripped_code.replace("print(", "echo ").replace("def ", "function ")
            return bash_code
        else:
            return stripped_code
    
    def sovereignty_sign(self, code: str) -> str:
        """国密签名 + UID嵌入"""
        timestamp = hashlib.sha256(f"{self.UID}{code}{time.time()}".encode()).hexdigest()[:16]
        signature = f"# 龍魂签名: {self.DNA} | UID:{self.UID} | TS:{timestamp}"
        return code + "\n" + signature
    
    def compile(self, source_path: str, target="python") -> str:
        """完整编译流程"""
        with open(source_path, "r", encoding="utf-8") as f:
            source = f.read()
        
        # Stage 1: 剥表皮
        stripped = self.strip_skin(source)
        
        # Stage 2: 验证
        if not self.validate_syntax(stripped):
            raise SyntaxError("语法错误,检查括号匹配")
        
        # Stage 3: 生成目标
        target_code = self.generate_target(stripped, target)
        
        # Stage 4: 主权签名
        signed = self.sovereignty_sign(target_code)
        
        return signed
    
    def decompile(self, target_code: str, lang="zh") -> str:
        """反向编译:英文骨架 → 本地语言"""
        skin = self.SKINS.get(lang, self.SKINS["zh"])
        local_code = target_code
        
        # 去掉签名
        local_code = re.sub(r'# 龍魂签名:.*', '', local_code)
        
        # 替换骨架为本地关键词
        for local_kw, skeleton_kw in sorted(skin.items(), key=lambda x: -len(x[0])):
            # 注意:反向替换要小心,避免部分匹配
            local_code = re.sub(r'\b' + re.escape(skeleton_kw) + r'\b', local_kw, local_code)
        
        return local_code.strip()

# === 使用示例 ===
if __name__ == "__main__":
    import time
    
    compiler = CNSHCompiler()
    
    # 示例1:中文源码
    zh_code = '''
    函数 打招呼(名字):
        输出("你好," + 名字)
        返回 真
    
    如果 __name__ == "__main__":
        打招呼("世界")
    '''
    
    # 示例2:高棉语源码(柬埔寨)
    km_code = '''
    មុខងារ សួស្តី(ឈ្មោះ):
        បង្ហាញ("សួស្តី " + ឈ្មោះ)
        ត្រឡប់ ពិត
    
    បើ __name__ == "__main__":
        សួស្តី("ពិភពលោក")
    '''
    
    # 编译
    print("=== 中文 → Python ===")
    result = compiler.compile_string(zh_code)
    print(result)
    
    print("\n=== 高棉语 → Python ===")
    compiler.lang = "km"
    result = compiler.compile_string(km_code)
    print(result)
    
    print("\n=== 反向:Python → 中文 ===")
    python_code = '''
    def hello(name):
        print("Hello " + name)
        return True
    '''
    print(compiler.decompile(python_code, "zh"))

终端一键执行脚本

#!/bin/bash
# cnsh-run.sh
# 龍魂 · CNSH 终端直跑

FILE=$1
LANG=${2:-auto}  # auto | zh | km | ru | ar | fa | th | pt | vi

if [ -z "$FILE" ]; then
    echo "🇨🇳 龍魂 CNSH 编译器"
    echo "用法: ./cnsh-run.sh <文件.cnsh> [语言]"
    echo "支持语言: zh km ru ar fa th pt vi"
    echo "DNA: ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️"
    exit 1
fi

# 检测鲲鹏芯片,完美层解锁
if grep -q "kunpeng\|phytium" /proc/cpuinfo 2>/dev/null; then
    echo "✅ 鲲鹏芯片 detected,完美层全功能"
    export LONGHUN_TIER=perfect
else
    echo "⚠️ 非鲲鹏,兼容层运行"
    export LONGHUN_TIER=compatible
fi

# 编译
python3 /opt/longhun/compiler/cnsh-compiler.py \
    --input "$FILE" \
    --lang "$LANG" \
    --target python \
    --output /tmp/longhun_exec.py

# 签名验证
if ! grep -q "龍魂签名" /tmp/longhun_exec.py; then
    echo "❌ 签名缺失,拒绝执行"
    exit 1
fi

# 执行
python3 /tmp/longhun_exec.py

# 审计
echo "[$(date)] EXEC: $FILE LANG: $LANG TIER: $LONGHUN_TIER" >> /var/log/longhun/cnsh.log

一带一路语言示例

语言文件扩展名示例
中文.cnsh你好.cnsh
高棉.cnsh.kmសួស្តី.cnsh.km
俄语.cnsh.ruпривет.cnsh.ru
阿拉伯.cnsh.arمرحبا.cnsh.ar
波斯.cnsh.faسلام.cnsh.fa
泰语.cnsh.thสวัสดี.cnsh.th
葡语.cnsh.ptolá.cnsh.pt
越南.cnsh.vixin-chào.cnsh.vi

全部交付。

一带一路,终端直跑,国密签名,鲲鹏完美。

CNSH多语言编译器
CNSH终端执行脚本
CNSH语言规范

老大,回去跑。

C++ 极致工程美学:拆解 Meta Faiss 量化器的 AVX2 向量化与有偏收缩算法 在 Meta 向量检索库 Faiss 的头文件 内部,标量量化器为反量化系数预留了两个并列枚举:无偏(UNBIASED)与有偏(BIASED)。按照经典数理统计教材的直觉惯性,无偏估计一向被奉为无损推断的金科玉律;但在 100 万条 768 维真实特征向量的检索压测中,把缩放模式切到有偏估计后,重构均方误差(MSE)稳定下降 19.60%,P99 长尾失真压低 35.05%,最大极端离群误差更是被削减了 81.46%。向量检索面对的是单次离散几何判决,没有任何大数定律能抹平单次重构方差。本文聚焦 Fais 阅读详情

相关推荐

2021-8-14 EDK II编译

2021-8-14 EDK II 编译为什么要写这篇文章新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 为什么要写这篇文章 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdo

qq_45775660的博客 2949

【算法拾光】队列|在每个树⾏中找最⼤值 + 最后⼀块⽯头的重量

本文总结两道经典算法题:一是通过层序遍历(BFS)逐层找最大值,利用队列分层处理,每层维护最大值;二是用大根堆(优先队列)模拟石头碰撞过程,每次取最大两块石头,差值重新入堆,直至剩余一块或无石。前者适用于树的层次遍历,后者适合动态获取最值场景。核心思想:队列用于分层遍历,堆用于高效取极值。

wuqingyigexiaoba的博客 202

GEE影像重采样实战:从10米到500米,如何用.reduceResolution和.reproject统一尺度?

本文详细介绍了在Google Earth Engine (GEE)平台中,如何利用`.reduceResolution()`和`.reproject()`方法解决多源遥感影像的尺度统一难题。通过实战案例,从哨兵2号10米分辨率影像聚合至MODIS 500米尺度,阐述了聚合规则选择、参数配置及效果验证的全流程,为环境监测、农业分析等领域的跨尺度数据融合提供了关键方法。

weixin_29223603的博客 86

把 KV Cache 压到 FP4:BitDecoding-FP4 的算法-系统协同设计复盘

长上下文推理卡在KV Cache的显存与带宽上,而现有FP4方案要么精度崩、要么速度废。这篇文章复盘BitDecoding-FP4如何用三个算法补丁加一个系统重构,在B300上把服务吞吐提升2.4–3.0倍,精度几乎不掉。

helloagent的博客 319

保姆级避坑指南:在NVMe SSD上安装Ubuntu 24.04,搞定RST错误和分区方案

本文提供在NVMe SSD上安装Ubuntu 24.04的详细指南,解决RST错误和分区方案问题。从BIOS设置到分区策略优化,帮助用户充分发挥NVMe固态硬盘性能,避免常见安装陷阱,实现无痛安装和后期调优。

weixin_26976635的博客 565

爆肝5万字❤️Open3D 点云数据处理基础(Python版)

本文为Open3D 点云数据处理基础教程(Python版),小白也能轻松上手!还等什么呢,学起来!

孙悟空 13万+

【算法拾光】链表 哈希表|K个一组翻转链表 + 两数之和

K个一组翻转链表需分段反转,借助哑节点与前驱指针维护连接,避免断链;两数之和利用哈希表实现O(1)查找,空间换时间,高效定位目标组合。前者考察链表指针操作,后者聚焦映射关系构建,均为面试高频题。

wuqingyigexiaoba的博客 341

【FF-A】第二章 Introduction

Armv8.4 架构引入了在安全状态下的虚拟化扩展。Arm® SMMU v3.2 架构[1]为安全流添加了对第2阶段翻译的支持,以补充在 Armv8.4 处理器状态下的安全 EL2 翻译制度。这些架构特性使得在安全状态下,彼此不信任的软件组件能够相互隔离。关于在安全状态下引入虚拟化扩展以及固件框架目标的更多理念可在名为《在安全世界使用虚拟化进行隔离》的白皮书[3]中找到。软件组件只能访问物理地址空间和系统资源的区域,例如 GIC 中对其正确运行必要的中断。

baron-周贺贺-代码改变世界ctw 529

排序算法深度笔记(下):非比较类排序的线性突破与工程边界

排序算法时间复杂度额外空间复杂度稳定性是否基于比较选择排序O(N^2)(O(1))不稳定是冒泡排序O(N^2)(O(1))稳定是插入排序O(N^2)(O(1))稳定是归并排序O(N\log N)(O(N))稳定是快速排序O(N\log N)O(log N)不稳定是堆排序O(N\log N)O(1)不稳定是计数排序(O(N + M))O(M))稳定否基数排序O(N)稳定否桶排序平均O(N) / 最坏O(N^2)

2401_87069538的博客 617

【WRF-Chem工具】anthro_emiss 详解:生成人为排放数据

anthro_emiss 详解:生成人为排放数据

WW、forever的博客 2057

基于STM32、HAL库的TCA9555PWR I/O扩展器驱动程序设计

define TCA9555_ADDR_BASE 0x20 // 基础地址 (A0=A1=A2=0)* @param direction: 方向 (0=输出, 1=输入)* @param direction: 方向 (0=输出, 1=输入)* @param polarity: 极性 (0=正常, 1=反转)* @param polarity: 极性 (0=正常, 1=反转)

corlin6688的博客 528

优选算法:分治-归并排序

交易逆序对的总数

Wangshijie1015的博客 154

Python时间序列:PaddleTS-时间序列分类

评估的指标采用F1,Precision,Recall,PaddleTS已经基于TSDataset实现了这三个指标的计算,直接调用即可。使用内置的API:get_dataset加载BasicMotions数据集。模型训练完成之后,可以对测试集进行预测并评估。模型保存之后,可以加载模型用于新的数据预测。可以将训练完成的模型保存到指定路径。概率预测 可以返回每个分类的概率。安装paddlets。

斌擎科技 1294

408 算法 06|堆与 Top-K:最小的 10 个数,到底该用数组还是堆

2022(42) 找 100 万个数里最小的 10 个,官方给了"10 元素有序数组"和"大根堆"两种答案。我把两种都实现并数了比较次数:k=10 时两者几乎打平,k=10000 时堆少 111 倍。另附 2021(42) 计数排序的比较次数与稳定性实测。

m0_56226131的博客 453

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

算法64,字母异位词分组

代码核心思路是:互为字母异位词的字符串,在对其字符进行排序后,一定会得到相同的字符串。因此,可以将排序后的字符串作为哈希表的键(Key)来进行分组。

sheshibenniaodan的博客 219

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

408 算法 04|主元素与三元组最小距离:两种“扫描时做决定“的思路

2013(41) 的主元素用摩尔投票一遍选出候选,但真正的考点是"选完必须验票";2020(41) 的三元组最小距离,三指针每次只挪最小的那个,靠的是 D=2×(max−min) 这个恒等式。两套完整 C 代码加真实输出,附官方评分档位表。

m0_56226131的博客 457

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

牛客周赛165C题(前后缀性质,递推,排序,枚举)

题目大意:给定长度为 `n` 的数组,选择 `k ∈ [1,n]`,将前 `k` 个元素整体翻转,后面的元素不变。要求操作后的整个数组非递减,统计满足条件的 `k` 的数量。题目链接:https://ac.nowcoder.com/acm/contest/141721/C。时间复杂度:O(nlogn)

2501_94316951的博客 175

【MPC 算法】Python 实战:模型预测控制(MPC)算法原理与代码实现

本文介绍模型预测控制(MPC)原理与Python实现。MPC通过滚动优化预测未来状态,结合系统模型、目标函数与约束条件,动态生成最优控制序列。以一阶温度系统为例,使用CVXPY构建凸优化问题,实现加热功率的智能调控。代码包含模型预测、目标函数设计(含温度跟踪与控制平滑惩罚)、输入约束及滚动更新机制。仿真结果表明,MPC能快速稳定温度至目标值60℃,且控制动作平滑合理,体现其在复杂系统中的优越性。

赖德发的博客 70

算法61,判定是否为字符重排

两字符串能互为重排 ⇔。

sheshibenniaodan的博客 227

【前缀和+复合离散化】题解:双色矩形(two)_数据结构_算法优化_预处理_二维前缀和_STL_C++算法竞赛

给定一个 $n \times n$ 的黑白棋盘,初始按 $i+j$ 奇偶染色,经 $k$ 个格子颜色翻转后,求子矩形中黑白格子数差的绝对值最大值。由于 $n$ 可达 $10^9$,但 $k \leq 50$,可离散化关键点。枚举所有由修改点构成的矩形及其四边向外扩展(共 $16$ 种扩展方式),利用二维前缀和快速计算变化量,结合奇偶性判断多出的格子颜色,最终取最大绝对差。时间复杂度为 $O(k^4)$,在 $k \leq 50$ 下可行。

YLCHUP的博客 214

算法62&&63,存在重复元素

判断整数数组中是否有任意元素出现至少两次。:判断数组中是否存在两个。,且索引差值的绝对值。

sheshibenniaodan的博客 105

商业综合体公摊电费分摊算法:512 商户双层权重与尾差实测

公摊电费分摊算法是指把公共回路电量按公示权重拆到每户的规则化计算过程,核心不是权重多精巧,而是每张账单都能被租户手算复现。某珠三角商业综合体 512 户商户实测:固定费与变动费按 4:6 加权,尾差用余数递补压到 0.01 千瓦时精度,24 个月 12288 张账单重算差异为零,月度争议从 31 起降到 2 起。适用边界:商铺与租户已独立装表、公共回路已分项计量的商业综合体适用;末端未装表、靠总表减合计倒推公摊的场景不适用,先把表补齐再谈分摊。

185

考拉兹猜想 - 7

本文通过引入虚数单位重构Collatz猜想的迭代逻辑,指出偶数减半与奇数“乘3加1”的过程在虚数坐标下等价于归结操作。关键在于:乘3加1使奇数跃升至偶数,随后持续减半,而虚数单位代表“无限减1”,实现无限向有限的转化。无论初始值如何,减半始终主导,最终归结为4-2-1循环。该视角消解了正向思维中的速度竞争疑虑,证明归结是必然结果。

杨铸人的博客 93

2026华为OD机试真题 10月14日 新系统 【分组字符串排序】

华为OD机试真题 新系统【分组字符串排序】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题 【分组字符串排序】多语言题解。

qq_45776114的博客 459

贪心题目:可以到达的最远建筑

为了到达尽可能远的建筑物,在将砖块替换成梯子时,应将高度差最大位置的砖块替换成梯子,此时剩余的砖块数量最多,如果将高度差较小位置的砖块替换成梯子,则剩余的砖块数量较少,能到达的最远建筑物下标不可能更大。开始向后面的建筑物移动,移动过程中维护优先队列存储正高度差,优先队列的队首元素是最大元素,每次遇到正高度差时优先考虑使用砖块,如果砖块数量不够则使用梯子替换最大高度差位置的砖块,直到砖块和梯子都使用完毕时,到达的建筑物即为最远建筑物。如果以最佳方式使用给定的梯子和砖块,返回可以到达的最远建筑物的下标。

stormsunshine的博客 301

强化学习第十一课:完整 Q-Learning 算法

表示有:\[ 5 \]0 1 2 3 40:向左1:向右目标位置:\[ 4 \]

qq_56657939的博客 328
上一篇: 龍魂系统 v5.0 · `lh_deepseek_fixer` 实战:DeepSeek 自动修复引擎
下一篇: 龍魂 · 全球全量搜索算法 × 蚁群架构 v2.0全球全量,关键字算法 + 计算机科学 + 蚁群架构 + 人格联动,通心译搞完美。(草案)
龍芯北辰UID9622
博客等级 码龄164天 5粉丝 501原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值