从CTF到实战:Frida Hook无导出SO函数的3种特殊姿势

Frida Hook无导出SO函数的三种特殊姿势 在Android逆向中,Frida作为强大的动态插桩工具,常被用于Hook目标函数。然而,当面对未导出的SO内部函数时,常规的findExportByName往往会失效。动态符号表与静态符号表的差异,导致许多核心算法被隐藏在无导出的裸函数中。通过基地址加偏移、特征码扫描与交叉引用反推三种实战技巧,能够有效定位并Hook这些函数。这些技术不仅适用于CTF逆向挑战,也广泛应用于商业App的加固分析与动态调试,帮助安全研究人员快速定位关键代码。了解动态插桩的原理和价值,掌握无导出函数的定位方法,是深入逆向分析的关 阅读详情

从CTF到实战:无导出SO函数Hook的深度探索与高阶技巧

在移动安全研究的道路上,我们常常会遇到一个令人头疼的难题:那些核心逻辑被精心隐藏在SO库中,且函数名在导出表中消失得无影无踪。传统的符号Hook方法在此刻完全失效,仿佛面对一堵密不透风的墙。无论是CTF赛题中刻意设计的混淆,还是金融、社交类APP为保护核心算法而施加的加固,无导出函数的Hook都构成了逆向工程中一道必须跨越的鸿沟。

这篇文章将带你超越基础的Module.findExportByName,深入探索三种定位并Hook无导出SO函数的特殊方法。我们不会停留在理论层面,而是结合真实的CTF题目和商业APP案例,拆解每一步操作背后的原理与细节。无论你是想在CTF比赛中快速得分的安全爱好者,还是需要分析加固应用的安全研究员,这些技巧都将成为你工具箱中的利器。

1. 理解无导出函数的本质:为何常规方法失效

在开始技术探索之前,我们首先要明白一个基本问题:为什么有些SO函数在导出表中找不到? 这并非魔法,而是开发者有意为之的保护策略。

1.1 无导出函数的实现机制

在C/C++开发中,有几种常见方式可以隐藏函数导出:

使用__attribute__((visibility("hidden")))编译属性

// 这个函数不会出现在导出表中
__attribute__((visibility("hidden"))) 
void secret_algorithm(const char* input, char* output) {
    // 核心加密逻辑
    // ...
}

通过静态链接库内部函数

// 在静态库中编译,外部不可见
static void internal_processing(void* data) {
    // 内部处理逻辑
}

动态注册JNI函数

// Java层声明
public native String nativeCalculate(String input);

// Native层动态注册
static JNINativeMethod methods[] = {
    {"nativeCalculate", "(Ljava/lang/String;)Ljava/lang/String;", (void*)calculate_impl}
};

JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    // 动态注册而非静态导出
    env->RegisterNatives(clazz, methods, sizeof(methods)/sizeof(methods[0]));
    return JNI_VERSION_1_6;
}

注意:动态注册是商业APP中最常见的隐藏手段。函数地址在运行时通过RegisterNatives绑定,IDA的导出表中完全看不到这些函数名,只能看到JNI_OnLoad。

1.2 加固技术的干扰

现代加固方案会进一步加剧这个问题:

加固技术 对SO函数的影响 检测难度
代码混淆 函数逻辑被拆分、插入垃圾指令 ★★★☆☆
控制流平坦化 函数执行流程被重构 ★★★★☆
虚拟化保护 代码被转换为自定义字节码 ★★★★★
完整性校验 Hook检测和反调试 ★★★★☆

面对这些保护,单纯依赖导出表就像在黑夜中寻找没有标记的门。我们需要更聪明的方法。

2. 方法一:字符串引用定位法——最直观的切入点

字符串是代码中难以完全隐藏的线索。即使函数名被抹去,函数内部使用的字符串常量仍然会留在.rodata段中。这为我们提供了第一个突破口。

2.1 原理与实现步骤

字符串定位法的核心思想是:通过函数内部引用的唯一字符串,反向定位到使用该字符串的函数。

操作流程如下:

  1. 静态分析寻找特征字符串

    • 使用IDA Pro或Ghidra打开目标SO文件
    • 查看Strings窗口,寻找可能的特征字符串
    • 重点关注错误信息、日志标签、算法标识等
  2. 确定字符串在内存中的地址

    // 查找字符串在内存中的位置
    const targetString = "MD5_Transform";
    const stringAddress = Module.findBaseAddress("libtarget.so")
      .add(Module.getExportByName("libtarget.so", "strlen")); // 示例,实际需计算偏移
    
    // 或者直接搜索整个模块
    Memory.scan(Module.findBaseAddress("libtarget.so"), 
                Module.getSize("libtarget.so"),
                targetString, {
      onMatch: function(address, size) {
        console.log(`找到字符串 "${targetString}" 在地址: ${address}`);
      },
      onComplete: function() {
        console.log("扫描完成");
      }
    });
    
  3. 查找引用该字符串的代码位置

    // 查找所有引用该字符串的指令
    function findXrefToString(stringAddr) {
      const results = [];
      const base = Module.findBaseAddress("libtarget.so");
      const size = Module.getSize("libtarget.so");
      
      // 搜索LDR指令(ARM架构)
      // LDR指令模式: xx xx xx xx (32位指令)
      // 我们需要查找加载stringAddr的LDR指令
      const pattern = "?? ?? ?? ??";
      Memory.scan(base, size, pattern, {
        onMatch: function(address, size) {
          // 解析指令,检查是否加载目标地址
          const instruction = Memory.readU32(address);
          // 简化检查:实际需要根据ARM指令编码解析
          // 这里仅示意
          console.log(`潜在引用指令在: ${address}`);
          results.push(address);
        },
        onComplete: function() {
          console.log(`找到 ${results.length} 个潜在引用`);
        }
      });
      return results;
    }
    

2.2 实战案例:CTF中的字符串线索

在某次CTF比赛中,我们遇到一个Android逆向题,关键验证函数被隐藏。通过静态分析,在IDA的Strings窗口发现一个可疑字符串:

"Verification_Failed_Check_Your_Input"

在Hex窗口查看该字符串的引用:

.rodata:0000A124 56 65 72 69 66 69 63 61 74 69 6F 6E 5F 46 61 69 Verification_Fai
.rodata:0000A134 6C 65 64 5F 43 68 65 63 6B 5F 59 6F 75 72 5F 49 led_Check_Your_I
.rodata:0000A144 6E 70 75 74 00                                     nput.

使用IDA的交叉引用功能(快捷键X),发现只有一处代码引用:

.text:00007A84 LDR R1, =(aVerificationFa - 0x7A90)
.text:00007A88 ADD R1, PC, R1      ; "Verification_Failed_Check_Your_Input"

由此我们定位到函数起始于0x7A84附近。通过分析上下文,确认这是验证失败时的提示信息,而验证逻辑就在这个函数中。

Frida Hook脚本实现:

Java.perform(function() {
  const libName = "libchallenge.so";
  const baseAddr = Module.findBaseAddress(libName);
  
  if (!baseAddr) {
    console.error(`模块 ${libName} 未加载`);
    return;
  }
  
  // 通过字符串定位的函数偏移
  const targetOffset = 0x7A84;
  const targetAddr = baseAddr.add(targetOffset);
  
  console.log(`目标函数地址: ${targetAddr}`);
  
  Interceptor.attach(targetAddr, {
    onEnter: function(args) {
      console.log(`[+] 进入验证函数`);
      // 打印第一个参数(假设是输入字符串)
      const inputPtr = args[0];
      if (!inputPtr.isNull()) {
        const input = inputPtr.readUtf8String();
        console.log(`输入: ${input}`);
      }
      
      // ARM架构下,R0是第一个参数,R1是第二个
      // 这里我们也可以直接读取寄存器
      console.log(`R0 (arg1): ${this.context.r0}`);
      console.log(`R1 (arg2): ${this.context.r1}`);
    },
    
    onLeave: function(retval) {
      console.log(`[+] 函数返回: ${retval}`);
      // 通常验证函数返回布尔值或状态码
      const success = retval.toInt32() !== 0;
      console.log(`验证结果: ${success ? "成功" : "失败"}`);
    }
  });
});

2.3 优缺点分析

优点:

  • 直观易懂,不需要深入理解算法逻辑
  • 字符串在.rodata段,不会被代码混淆影响
  • 适用于有明确错误提示或日志输出的函数

局限性:

  • 如果函数内部没有字符串引用,此方法失效
  • 字符串可能被加密或混淆
  • 多个函数可能引用同一个字符串,需要进一步筛选

3. 方法二:调用栈回溯法——动态追踪执行路径

当字符串线索不可得时,我们可以换个思路:从已知的入口点出发,追踪执行路径,找到目标函数。这种方法特别适用于动态注册的JNI函数。

3.1 动态注册JNI的Hook策略

大多数Android应用使用RegisterNatives动态注册JNI函数。虽然这些函数不在导出表中,但注册过程本身是可以Hook的。

Hook RegisterNatives的基本原理:

// 查找libart.so中的RegisterNatives函数
function hookRegisterNatives() {
  // 不同Android版本可能在不同模块中
  const modules = ['libart.so', 'libartd.so', 'libnativehelper.so'];
  let registerNativesAddr = null;
  
  for (const moduleName of modules) {
    const symbols = Module.enumerateSymbolsSync(moduleName);
    for (const symbol of symbols) {
      if (symbol.name.indexOf('RegisterNatives') !== -1 && 
          symbol.name.indexOf('CheckJNI') === -1) {
        console.log(`找到RegisterNatives: ${symbol.name} @ ${symbol.address}`);
        registerNativesAddr = symbol.address;
        break;
      }
    }
    if (registerNativesAddr) break;
  }
  
  if (!registerNativesAddr) {
    console.error("未找到RegisterNatives函数");
    return;
  }
  
  Interceptor.attach(registerNativesAddr, {
    onEnter: function(args) {
      // JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods
      const env = args[0];
      const javaClass = args[1];
      const methodsPtr = args[2];
      const methodCount = args[3].toInt32();
      
      console.log(`\n[RegisterNatives] 注册 ${methodCount} 个方法`);
      
      // 获取Java类名
      const className = getClassName(env, javaClass);
      console.log(`类名: ${className}`);
      
      // 遍历所有注册的方法
      for (let i = 0; i < methodCount; i++) {
        const methodEntry = methodsPtr.add(i * Process.pointerSize * 3);
        const namePtr = Memory.readPointer(methodEntry);
        const sigPtr = Memory.readPointer(methodEntry.add(Process.pointerSize));
        const fnPtr = Memory.readPointer(methodEntry.add(Process.pointerSize * 2));
        
        const name = Memory.readCString(namePtr);
        const signature = Memory.readCString(sigPtr);
        
        console.log(`  [${i}] ${name}${signature} -> ${fnPtr}`);
        
        // 记录函数地址供后续Hook使用
        registerMethodHook(className, name, signature, fnPtr);
      }
    }
  });
}

3.2 自动化Hook所有动态注册函数

手动记录每个函数地址很繁琐,我们可以编写自动化脚本:

#!/usr/bin/env python3
# auto_hook_jni.py - 自动Hook所有动态注册的JNI函数

import frida
import re
import json
from datetime import datetime

class JNIHookAutomator:
    def __init__(self, package_name):
        self.package_name = package_name
        self.device = frida.get_usb_device()
        self.session = None
        self.hooked_methods = []
        
    def on_message(self, message, data):
        """处理Frida消息"""
        if message['type'] == 'send':
            payload = message['payload']
            if payload.get('type') == 'jni_registration':
                self.process_jni_registration(payload['data'])
            elif payload.get('type') == 'jni_call':
                self.log_jni_call(payload['data'])
    
    def process_jni_registration(self, registration_data):
        """处理JNI注册信息"""
        class_name = registration_data['class']
        method_name = registration_data['method']
        signature = registration_data['signature']
        address = registration_data['address']
        module = registration_data.get('module', 'unknown')
        offset = registration_data.get('offset', '0x0')
        
        print(f"[+] 发现JNI注册: {class_name}.{method_name}{signature}")
        print(f"    地址: {address}, 模块: {module}, 偏移: {offset}")
        
        # 生成Hook脚本
        hook_script = self.generate_hook_script(
            class_name, method_name, signature, address, module, offset
        )
        
        # 注入Hook脚本
        self.inject_hook_script(hook_script)
        
        # 保存记录
        self.hooked_methods.append({
            'class': class_name,
            'method': method_name,
            'signature': signature,
            'address': address,
            'module': module,
            'offset': offset,
            'timestamp': datetime.now().isoformat()
        })
    
    def generate_hook_script(self, class_name, method_name, signature, address, module, offset):
        """为特定JNI方法生成Hook脚本"""
        # 解析方法签名,确定参数类型
        param_types = self.parse_jni_signature(signature)
        
        script = f"""
        Java.perform(function() {
  
  {
            const targetAddr = ptr("{address}");
            
            console.log(`[+] Hook JNI方法: {class_name}.{method_name}`);
            console.log(`    签名: {signature}`);
            console.log(`    地址: ${
  
  {targetAddr}}`);
            
            Interceptor.attach(targetAddr, {
  
  {
                onEnter: function(args) {
  
  {
                    this.callId = Date.now() + Math.random();
                    this.methodName = "{class_name}.{method_name}";
                    this.startTime = Date.now();
                    
                    console.log(`[Call ${
  
  {this.callId}}] 进入 ${
  
  {this.methodName}}`);
                    console.log(`    模块: {module}, 偏移: {offset}`);
                    
                    // 打印参数(JNIEnv*和jobject/jclass之后开始)
                    let argIndex = 2; // 跳过JNIEnv*和jobject/jclass
        """
        
        # 根据参数类型生成打印代码
        for i, param_type in enumerate
通过一道CTF题目来认识一下Frida 此外,Frida还提供了多种工具,如frida-apk、frida-compile和frida-ps。因为要拿flag的话,需要进行爆破,从题目提示得知,5位数字,然后经过eeee处理后等于bytes§就是对应的flag了;登录到执行环境下,也就是手机查看环境,下载对应的版本和环境的frida-server,并移动到手机上执行;当然frida支持多种方式调用,上面是js脚本,可以直接用frida命令的方式调用;有了关键字,反编译app后搜索一下,就在main中,可以清晰的看到入口处理逻辑; 阅读详情

相关推荐

从CTF到实战:Frida Hook So层函数在移动安全测试中的真实应用与避坑指南

本文深入探讨了Frida Hook技术在移动安全测试中So层函数的实战应用与避坑指南。通过对抗加固混淆、无符号函数定位等核心问题的解决方案,帮助安全工程师高效完成安卓应用的So层动态分析,提升移动安全测试的效率和准确性。

weixin_30680385的博客 406

CTF逆向工程实战:从知识体系到AK通关的完整路径

逆向工程作为软件安全领域的核心技术,其本质是通过分析二进制程序的行为与结构,理解其内部逻辑与算法实现。这一过程依赖于对计算机系统底层原理的深刻理解,包括指令集架构、可执行文件格式和编译原理等基础知识。掌握逆向技术不仅能够提升软件分析能力,在网络安全、漏洞挖掘、恶意代码分析等领域也具有重要价值。在实际应用中,逆向工程常涉及加密算法识别、代码混淆对抗等复杂场景,需要结合静态分析与动态调试工具链进行系统化分析。本文以CTF竞赛中的逆向AK(All Kill)为切入点,系统梳理了从基础理论到实战解题的完整知识体系,

weixin_34221073的博客 5548

移动应用逆向实战:从陌陌X-SIGN签名到mzip解密的完整分析

在移动应用安全领域,签名算法与数据加密是保障通信安全的核心技术。其原理通常基于哈希函数(如MD5、SHA系列)或对称加密算法,通过将请求参数、时间戳、密钥等要素按特定规则组合运算,生成唯一签名值,用于服务端验证请求的合法性与完整性。这项技术的价值在于防止数据篡改、重放攻击,是金融、社交等高安全要求应用的标配。在Android应用逆向工程中,分析签名逻辑是理解应用安全体系的关键步骤,涉及静态分析、动态调试、算法还原等综合技能。本文以社交应用陌陌的X-SIGN签名和mzip数据格式为具体案例,详细拆解了从网络抓

weixin_30596165的博客 583

安卓逆向frida之so层hook分析关键函数定位探究

【代码】安卓逆向frida之so层hook分析关键函数定位探究。

云霄IT的博客 3959

树莓派CSI/DSI二合一接口深度玩法:同时驱动MIPI摄像头和屏幕的配置秘籍

本文详细解析了树莓派5上CSI/DSI二合一接口的深度玩法,提供了同时驱动MIPI摄像头和屏幕的完整配置秘籍。从硬件连接到软件设置,包括config.txt的优化配置,帮助用户充分利用树莓派5的双多功能接口,实现高效的双设备工作模式。

weixin_30687051的博客 580

《uni-app 长列表优化:虚拟列表(vue-virtual-scroller)解决 1000+ 数据渲染卡顿》(附虚拟列表封装与多端适配)

本文详细介绍了虚拟列表技术在前端长列表渲染中的优化方案。针对传统v-for渲染导致的性能问题(内存占用高、渲染阻塞、滚动卡顿),提出基于vue-virtual-scroller的虚拟列表解决方案,通过可视区域渲染和DOM复用实现性能突破。文章包含核心原理、组件封装、多端适配及性能对比,并给出常见问题的解决方法。实践表明,该方案可将1000条数据的首次渲染时间从3800ms降至420ms,滚动FPS提升至55帧,显著改善用户体验。

qq_59041750的博客 2111

《UVM实战》学习笔记——第三章UVM基础

uvm基础,常见的派生类,config db机制,打印信息等

qq_42135020的博客 5180

URP Shader编程之自定义后处理单pass渲染(URP 14.x)

❌ 不要在里拿✅ 只在里拿RendererFeature 生命周期RTHandle 设计Blitter 的真实语义Shader 输入来源。

qq1342753906的博客 612

微信小程序URL Link全解析:从生成原理到实战应用(附Java代码)

本文深入解析微信小程序URL Link的生成原理与实战应用。URL Link是微信官方提供的智能路由协议,通过中间页实现外部链接安全跳转至小程序指定页面。文章详细阐述了其权限模型、环境版本差异及跳转机制,并提供了包含令牌管理、异常处理和性能优化的健壮Java实现方案,助力开发者构建高可用的链接生成服务。

weixin_29327525的博客 1232

物理信息神经网络(PINN)文献综述 —— 原理、严格推导与优化训练策略

本章系统阐述物理信息神经网络的理论基础、主要算法改进与训练策略。内容涵盖:PINN 的数学表述与残差构造;损失与梯度的逐步推导;训练困难(梯度消失/爆炸、损失幅度不平衡、频谱偏差、采样效率低等)的定量分析;四类核心解决方案(动态损失加权、梯度归一化与预条件化、自适应采样、分阶段/分域训练)的详细推导与实现要点;以及若干关键算法的伪代码与收敛性形式结论。所有涉及推导的步骤均按顺序展开,给出必要的数学依据与结论性陈述,可直接作为教学或参考章节使用。

u012133341的博客 425

CUDA&PCL 点云体素下采样

CUDA&PCL 点云体素下采样

dayuhaitang1的博客 1272

TSP:车为什么能和云端交互?

TSP:车为什么能和云端交互?

天赐好车的博客 425

全球国家地区城市数据

MySQL全球国家地区城市数据报。。。。。。。。。。。。

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

深度学习工具包 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&#39;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(&#39;DeepLearnToolbox&#39;));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(&#39;state&#39;,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&#39;); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand(&#39;state&#39;,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 = &#39;sigm&#39;;%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, &#39;Too big error&#39;);```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(&#39;state&#39;,0)sae = saesetup([784 100]);sae.ae{1}.activation_function = &#39;sigm&#39;;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)&#39;)% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;;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, &#39;Too big error&#39;);```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x&#39;,28,28,60000))/255;test_x = double(reshape(test_x&#39;,28,28,10000))/255;train_y = double(train_y&#39;);test_y = double(test_y&#39;);%% 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&#39;ll get around 1.2% errorrand(&#39;state&#39;,0)cnn.layers = { struct(&#39;type&#39;, &#39;i&#39;) %input layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 6, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %sub sampling layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 12, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 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, &#39;Too big error&#39;);```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(&#39;state&#39;,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, &#39;Too big error&#39;);%% ex2 neural net with L2 weight decayrand(&#39;state&#39;,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, &#39;Too big error&#39;);%% ex3 neural net with dropoutrand(&#39;state&#39;,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, &#39;Too big error&#39;);%% ex4 neural net with sigmoid activation functionrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;; % 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, &#39;Too big error&#39;);%% ex5 plotting functionalityrand(&#39;state&#39;,0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = &#39;softmax&#39;; % 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, &#39;Too big error&#39;);%% 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(&#39;state&#39;,0)nn = nnsetup([784 20 10]); nn.output = &#39;softmax&#39;; % 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, &#39;Too big error&#39;);```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

上一篇: Jmeter性能上不去?Windows系统级TCP连接优化全攻略(含JVM配置)
下一篇: UE5避坑指南:C++创建Actor时容易忽略的5个组件设置细节
jenkins8butler
博客等级 码龄4年 60粉丝 1465原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址