java和golang中的unsafe包

Jaspersoft Studio 6.20.0 免注册安装指南(附下载链接) 本文提供了Jaspersoft Studio 6.20.0社区版的免注册安装详细指南。文章介绍了绕过官网注册获取安装包的多种可靠途径,并逐步详解了从启动安装器到首次运行的全过程,帮助用户快速完成安装与基础配置,高效开启报表设计工作。 阅读详情

首先聊聊反射

java和golang都有各自的反射机制,为什么标准库会提供反射机制呢?
反射(reflection)允许程序在运行时(runtime)检查、修改程序(比如对象,struct等)的结构与行为,跳过编译检查,越过访问权限,运行时对象生成,方法调用等。如果没有反射,那么需要完全手动进行硬编码,比如如果没有反射,那么在spring的ioc容器管理实现就需要我们使用new来创建对象,那么也就不叫spring ioc,不会有spring ioc的诞生了。
静态编译(多数静态语言):在编译时确定类型,绑定对象。
动态编译(多数动态语言):运行时确定类型,绑定对象。可以实现动态创建对象和编译,体现出很大的灵活性(特别是在J2EE的开发中它的灵活性就表现的十分明显)。通过反射机制我们可以获得类的各种内容。对于java以及golang这种先编译再运行的语言来说,反射机制可以使代码更加灵活,更加容易实现面向对象。

反射的实现

在java和golang的反射实现中,主要依赖于对象指针(也就是对象的内存地址),以及编译时已链接到对象上的强类型信息。
BTW,在java语言的反射Method.invoke方法调用实现中,默认为委派实现,委派给本地方法来进行方法调用。在调用超过15次之后,委派实现便会将委派对象切换至动态实现(自己动态生成字节码),动态实现和本地实现相比,其运行效率要快上20倍,因为本地实现需要先调c++本地实现,然后c++的返回再用java接收,所以是比较耗时的。另外,生成动态实现的字节码也是比较耗时的,当然生成动态调用的字节码只生成一次,生成后就可以多次调用。

为何需要unsafe

在golang的标准包中,提供了unsafe操作(unsafe.go),通过主要用于对内存指针的操作,普通对象指针通过转化为unsafe.Pointer,而unsafe.Pointer可以转化为uintptr,uintptr支持指针相关的内存操作,通过unsafe包,间接的实现了直接指针内存相关的操作.
而在java的标准包中,并没有提供unsafe包,unsafe包存在于sun.msic下的Unsafe.java类,misc即miscellaneous混杂的意思,因为unsafe会破坏java倡导的内存安全,所以一直没有并入标准包,另外,oracle目前在主导unsafe包的移除和替换工作,java中的unsafe包,同样提供了基于内存地址的相关操作,除了操作GC能回收的堆内存,还能操作GC无法回收的区域–堆外内存,可以直接对内存地址的值进行操作,新建的对象需要自己手动free释放内存,目前的线程挂起和恢复,cas原子操作,类实例化以及基于内存偏移地址的修改,在许多的库中有广泛的使用,比如java中整个并发框架中对线程的挂起操作被封装在 LockSupport类中,LockSupport类中有各种版本pack方法,但最终都调用了Unsafe.park()方法。java的unsafe包主要可以提高程序的运行性能,以及可以减少GC的垃圾回收停顿时间,对一些java应用性能要求较高的应用,提供了除JNI C++调用之外的另一种选择

java unsafe参考示例

  1. 实例化私有类
    正常情况下没法实例化一个私有构造函数的类,但通过反射或unsafe可以做到。区别在于unsafe不会调用构造函数初始化,以及成员变量的初始化,如下:
package com.anteoy.coreJava.unsafe;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/**
 * @auther zhoudazhuang
 * @date 19-3-22 12:51
 * @description
 */
public class Uncover {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        Field f = null;
        f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);
        System.out.println(unsafe);
        test2(unsafe);


    }

    static void test1(Unsafe unsafe) throws IllegalAccessException, InstantiationException {
        A o1 = new A(); // constructor
        System.out.println(o1.a()); // prints 1

        A o2 = A.class.newInstance(); // reflection
        System.out.println(o2.a()); // prints 1

        // 不会赋值 不会初始化不会构造函数
        A o3 = (A) unsafe.allocateInstance(A.class); // unsafe
        System.out.println(o3.a());// prints 0
    }

    static void test2(Unsafe unsafe) throws NoSuchFieldException {
        Guard guard = new Guard();
        guard.giveAccess();   // false, no access

        // bypass
        Field f = guard.getClass().getDeclaredField("ACCESS_ALLOWED");
        //过内存偏移地址修改变量值
        unsafe.putInt(guard, unsafe.objectFieldOffset(f), 42); // memory corruption
        guard.giveAccess(); // true, access granted
    }
}

class A {
    private long a = 10; // not initialized value

    public A() {
    System.out.println("init");
        this.a = 1; // initialization
    }

    public long a() { return this.a; }
}


class Guard {
    private int ACCESS_ALLOWED = 1;

    public boolean giveAccess() {
    System.out.println(42 == ACCESS_ALLOWED);
        return 42 == ACCESS_ALLOWED;
    }
}

  1. cas原子级操作&&通过内存偏移地址修改变量值
    注意代码中的对应的内存偏移地址,需要根据打印出的地址自己调整,因为可能因为操作系统不一致,导致内存地址的偏移量不相同
package com.anteoy.coreJava.unsafe;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/**
 * @auther zhoudazhuang
 * @date 19-3-22 17:05
 * @description
 */
public class UnsafePlayer {

    public static void main(String[] args) throws Exception {
        //通过反射实例化Unsafe
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);

        //实例化Player
        Player player = (Player) unsafe.allocateInstance(Player.class);
        player.setAge(18);
        player.setName("li lei");
        for(Field field:Player.class.getDeclaredFields()){
            System.out.println(field.getName()+":对应的内存偏移地址"+unsafe.objectFieldOffset(field));
        }
        System.out.println("-------------------");

        int ageOffset= 12;
        //修改内存偏移地址为12的值(age),返回true,说明通过内存偏移地址修改age的值成功
        System.out.println(unsafe.compareAndSwapInt(player, ageOffset, 18, 20));
        System.out.println("age修改后的值:"+player.getAge());
        System.out.println("-------------------");

        //修改内存偏移地址为12的值,但是修改后不保证立马能被其他的线程看到。
        unsafe.putOrderedInt(player, 12, 33);
        System.out.println("age修改后的值:"+player.getAge());
        System.out.println("-------------------");

        //修改内存偏移地址为12的值,volatile修饰,修改能立马对其他线程可见
        unsafe.putObjectVolatile(player, 12, "han mei");
        System.out.println("name修改后的值:"+unsafe.getObjectVolatile(player, 12));
    }
}

class Player{

    private int age;

    private String name;

    private Player(){}

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}
  1. 阻塞和恢复
package com.anteoy.coreJava.unsafe;

/**
 * @auther zhoudazhuang
 * @date 19-3-22 17:24
 * @description
 */
import java.util.concurrent.locks.LockSupport;

public class Lock {

    public static void main(String[] args) throws InterruptedException {

        ThreadPark threadPark = new ThreadPark();
        threadPark.start();
        ThreadUnPark threadUnPark = new ThreadUnPark(threadPark);
        threadUnPark.start();
        //等待threadUnPark执行成功
        threadUnPark.join();
        System.out.println("运行成功....");
    }


    static  class ThreadPark extends Thread{

        public void run(){
            System.out.println(Thread.currentThread() +"我将被阻塞在这了60s....");
            //阻塞60s,单位纳秒  1s = 1000000000
            LockSupport.parkNanos(1000000000l*60);

            System.out.println(Thread.currentThread() +"我被恢复正常了....");
        }
    }

    static  class ThreadUnPark extends Thread{

        public Thread thread = null;

        public ThreadUnPark(Thread thread){
            this.thread = thread;
        }
        public void run(){

            System.out.println("提前恢复阻塞线程ThreadPark");
            //恢复阻塞线程
            LockSupport.unpark(thread);

        }
    }
}

golang unsafe参考示例

  1. 通过指针修改结构体字段
package main

import (
	"fmt"
	"unsafe"
)

func main() {
	s := struct {
		a byte
		b byte
		c byte
		d int64
	}{0, 0, 0, 0}

	// 将结构体指针转换为通用指针
	p := unsafe.Pointer(&s)
	// 保存结构体的地址备用(偏移量为 0)
	up0 := uintptr(p)
	// 将通用指针转换为 byte 型指针
	pb := (*byte)(p)
	// 给转换后的指针赋值
	*pb = 10
	// 结构体内容跟着改变
	fmt.Println(s)

	// 偏移到第 2 个字段
	up := up0 + unsafe.Offsetof(s.b)
	// 将偏移后的地址转换为通用指针
	p = unsafe.Pointer(up)
	// 将通用指针转换为 byte 型指针
	pb = (*byte)(p)
	// 给转换后的指针赋值
	*pb = 20
	// 结构体内容跟着改变
	fmt.Println(s)

	// 偏移到第 3 个字段
	up = up0 + unsafe.Offsetof(s.c)
	// 将偏移后的地址转换为通用指针
	p = unsafe.Pointer(up)
	// 将通用指针转换为 byte 型指针
	pb = (*byte)(p)
	// 给转换后的指针赋值
	*pb = 30
	// 结构体内容跟着改变
	fmt.Println(s)

	// 偏移到第 4 个字段
	up = up0 + unsafe.Offsetof(s.d)
	// 将偏移后的地址转换为通用指针
	p = unsafe.Pointer(up)
	// 将通用指针转换为 int64 型指针
	pi := (*int64)(p)
	// 给转换后的指针赋值
	*pi = 40
	// 结构体内容跟着改变
	fmt.Println(s)
}

  1. 修改私有字段
package main

import (
	"fmt"
	"reflect"
	"strings"
	"unsafe"
)

func main() {
	// 创建一个 strings 包中的 Reader 对象
	// 它有三个私有字段:s string、i int64、prevRune int
	sr := strings.NewReader("abcdef")
	// 此时 sr 中的成员是无法修改的
	fmt.Println(sr)
	// readbyte一次 其中的偏移字段i就会+1 从0开始
	b, err := sr.ReadByte()
	fmt.Printf("%c, %v\n", b, err)
	// 但是我们可以通过 unsafe 来进行修改
	// 先将其转换为通用指针
	p := unsafe.Pointer(sr)
	// 获取结构体地址
	up0 := uintptr(p)
	// 确定要修改的字段(这里不能用 unsafe.Offsetof 获取偏移量,因为是私有字段)
	if sf, ok := reflect.TypeOf(*sr).FieldByName("i"); ok {
		// 偏移到指定字段的地址
		up := up0 + sf.Offset
		// 转换为通用指针
		p = unsafe.Pointer(up)
		// 转换为相应类型的指针
		pi := (*int64)(p)
		fmt.Println(*pi)
		// 对指针所指向的内容进行修改
		*pi = 4 // 修改索引 修改索引字段i
	}
	// 看看修改结果
	fmt.Println(sr)
	// 看看读出的是什么
	b, err = sr.ReadByte()
	fmt.Printf("%c, %v\n", b, err)
}
  1. 类型转换和修改
package main

import (
	"fmt"
	"strings"
	"unsafe"
)

// 定义一个和 strings 包中的 Reader 相同的本地结构体
type Reader struct {
	s        string
	i        int64
	prevRune int
}

func main() {
	// 创建一个 strings 包中的 Reader 对象
	sr := strings.NewReader("abcdef")
	// 此时 sr 中的成员是无法修改的
	fmt.Println(sr)
	// 我们可以通过 unsafe 来进行修改
	// 先将其转换为通用指针
	p := unsafe.Pointer(sr)
	// 再转换为本地 Reader 结构体
	pR := (*Reader)(p)
	// 这样就可以自由修改 sr 中的私有成员了
	(*pR).i = 3 // 修改索引
	// 看看修改结果
	fmt.Println(sr)
	// 看看读出的是什么
	b, err := sr.ReadByte()
	fmt.Printf("%c, %v\n", b, err)
}

参考以及示例参考

  1. https://my.oschina.net/HJCui/blog/1817978
  2. https://www.jianshu.com/p/c394436ec9e5?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation
  3. https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html
  4. https://juejin.im/post/5a75a4fb5188257a82110544
  5. https://leokongwq.github.io/2016/12/31/java-magic-unsafe.html
嵌入式系统开发笔记96:将STM32CubeIDE设置为中文 本文介绍将STM32CubeIDE设置为中文的方法。 阅读详情

相关推荐

WSOLA原理及matlab仿真

WSOLA原理 对于 OLA 算法来说,常常无法保持原信号中的周期性结构,在帧裁剪的过程中,不能保证每一个帧都能覆盖完整周期并保证其相位对齐,会产生相位跳跃失真。 为保证**基频不变**,就要使用 WSOLA 算法。 WSOLA 并不直接在 Ha 处找一帧进行直接拼接,而是在一个区间内寻找与理想帧最接近的一帧进行叠加。 ![在这里插入图片描述](https://img-blog.csdnimg.cn/8a234f4fde104fc69a9f3ddb7bcf3014.png?x-oss-process=ima

ManiacLook的博客 3219

golang中的unsafe包详解

从golang的定义来看,unsafe 是类型安全的操作。顾名思义,它应该非常谨慎地使用; unsafe可能很危险,但也可能非常有用。例如,当使用系统调用和Go结构必须具有与C结构相同的内存布局时,您可能别无选择,只能使用unsafe。关于指针操作,在unsafe包官方定义里有四个描述: 任何类型的指针都可以被转化为Pointer Pointer可以被转化为任何类型的指针 uintptr可以被转化为Pointer Pointer可以被转化为uintptr 额外在加上一个规则:指向不同类型数据的指针,

雪锋的笔记 3186

Unity2019编译器下使用Ump无错误,打包exe不播放 或 将exe文件在其他电脑下运行不播放

一、unity编译器下使用UMP可以播放视频,打包后查看debug 出现错误 UnloadTime: 1.070900 ms Fallback handler could not load library F:/PCTest/AccessControlSysteam/jfmx_Data/Mono/libdl Fallback handler could not load library F:/PCTest/AccessControlSysteam/jfmx_Data/Mono/libdl.dll Fa.

qq_42345116的博客 4702

Golang 中的 unsafe 包详解

Golang 中的 unsafe 包用于在运行时进行低级别的操作。这些操作通常是不安全的,因为可以打破 Golang 的类型安全性和内存安全性,使用 unsafe 包的程序可能会影响可移植性和兼容性。接下来看下 unsafe 包中的类型和函数。

路多辛的所思所想 1962

卡尔曼滤波与目标追踪

卡尔曼滤波与目标追踪为什么要学卡尔曼滤波?卡尔曼滤波是什么?一些概率论的知识基础卡尔曼滤波完整推导状态估计计算卡尔曼增益预测和更新 卡尔曼滤波部分我打算分三节(三次博客的内容): 卡尔曼滤波与行人状态估计 扩展卡尔曼滤波(EKF)与传感器融合 过程模型,无损卡尔曼滤波(UKF)与车辆状态轨迹 为什么要学卡尔曼滤波? 卡尔曼滤波以及其扩展算法能够应用于目标状态估计,如果这个目标是行人,那么就是行人状态估计(或者说行人追踪),如果这个目标是自身,那么就是车辆自身的追踪(结合一些地图的先验,GPS等数据的话就

qq_43232556的博客 4176

树莓派34/100 - Pico读取MPU6050加速度和陀螺仪传感器数据

树莓派Pico连接MPU-6050模块(三轴陀螺仪+三轴加速度),读取运动姿态数据。

申龙斌的程序人生 5093

GoLang之unsafe如何显神通

GoLang之unsafe如何显神通

weixin_52690231的博客 708

Carla运行显示The following component(s) are required to run this program:DirectX Runtime |nvapi64.dll没有被

Carla运行显示The following component(s) are required to run this p 参考: 【1】EPIC 启动游戏提示The following component(s) are required to run this program:... - 『悬赏问答区』 - 吾爱破解 - LCG - LSG |安卓破解|病毒分析|www.52pojie.cnhttps://www.52pojie.cn/thread-1485651-1-1.html ...

anananajiushiwo的博客 5万+

深度解密Go语言之unsafe

上一篇文章我们详细分析了 map 的底层实现,如果你也跟着阅读了源码,那一定对 unsafe.Pointer 不陌生,map 对 key 进行定位的时候,大量使用。 unsafe.Pointer 位于 unsafe 包,这篇文章,我们来深入研究 unsafe 包。先说明一下,本文没有之前那么长了,你可以比较轻松地读完,这样的时候不是太多。 上次发布文章的时候,包括代码超过 5w 字,后台编辑器的体...

weixin_34320159的博客 497

极智AI | 谈谈为什么卷积加速更喜欢 NHWC Layout

本文主要讨论一下为什么卷积加速更加喜欢 NHWC 的数据排布。

极智视界 2972

MTEX包在Matlab中实现从EBSD数据生成Abaqus网格与晶粒取向:一种对用户材料旋转矩阵分量实践的全面指南

此教程提供了一种使用MTEX Matlab包处理EBSD数据的方法,并生成Abaqus输入文件,这对于进行多晶体有限元分析具有极大的帮助。但值得注意的是,这只是一个基本的例子,实际应用中可能需要根据您的实际需求进行调整。MTEX包还提供了许多其他的功能,可以进行更复杂的分析和处理,我非常推荐您去探索。希望这篇文章能对您有所帮助,如果您有任何疑问或建议,欢迎留言交流。在接下来的文章中,我将会介绍更多关于MTEX的高级功能,敬请期待。– (完)–

qq_38334677的博客 4439

Go 之unsafe包

一、unsafe包配合uintptr可以绕过go的安全检查,对内存进行操作二、两个类型。

qq_44810543的博客 429

Python爬虫:抓取专利数据并分析专利趋势

本文展示了如何使用 Python 爬虫技术抓取中国专利数据,并对数据进行了清洗、分析和趋势预测。通过分析专利数据,企业和科研机构可以了解行业的技术发展趋势,进行技术创新战略规划。未来,我们可以进一步扩展爬虫的功能,抓取更多专利数据,增加多维度的数据分析,如技术领域、地域分布等。同时,可以尝试使用深度学习模型(如 LSTM)进行时间序列预测,以获得更准确的专利趋势预测。

2201_76125261的博客 1787

对比一下Java和go的unsafe包

设计目的:Java 的 Unsafe 主要是为了提供高性能和低级别的内存操作,而 Go 的 unsafe 则更多地是为了提供与 C 语言交互和底层内存操作的能力。使用场景:Java 的 Unsafe 更多地被用于高性能库和框架中,而 Go 的 unsafe 则更多地被用于实现底层数据结构和与 C 语言的交互。因为 sun.misc.Unsafe 是非标准的内部 API,所以它的使用是不被官方推荐的,并且在不同版本的 JDK 中可能存在差异。包路径:unsafe(这是 Go 标准库的一部分)。

冯宝宝 458

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

深度学习工具包 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")

不懂汇编,也能看懂的 Go interface 原理分析,java面试刷题软件

我们总是喜欢瞻仰大厂的大神们,但实际上大神也不过凡人,与菜鸟程序员相比,也就多花了几分心思,如果你再不努力,差距也只会越来越大。实际上,作为程序员,丰富自己的知识储备,提升自己的知识深度和广度是很有必要的。我们总是喜欢瞻仰大厂的大神们,但实际上大神也不过凡人,与菜鸟程序员相比,也就多花了几分心思,如果你再不努力,差距也只会越来越大。实际上,作为程序员,丰富自己的知识储备,提升自己的知识深度和广度是很有必要的。

2301_77118221的博客 928

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

go标准库 和Java JDK源码

go 官方标准库 官方自带的标准库,主要关注net、context、sync、unsafe 等 生态扩展主要是 gin sqlx 、 gorm grpc JDK源码 Java 主要是rt.jar包中的类,也就是runtime.jar 主要包含lang、util、io等 生态扩展 主要是SSSM、TNDS一共八个框架 SSSM 为spring、springboot、springmvc、mybatis; TNDS 为Tomcat、Netty、Dubbo、Shiro/SpringSecurity .

tanqingdexiaoniu的博客 2806

不懂汇编,也能看懂的 Go interface 原理分析,字节跳动java面试题数据结构与算法

针对最近很多人都在面试,我这边也整理了相当多的面试专题资料,也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题(都整理成文档,小部分截图)最新整理电子书可以添加V:vip1024b 备注Java获取(资料价值较高,非无偿)**[外链图片转存中…(img-QFpgt26U-1711602715682)]针对最近很多人都在面试,我这边也整理了相当多的面试专题资料,也有其他大厂的面经。希望可以帮助到大家。

m0_61067876的博客 301

不懂汇编,也能看懂的 Go interface 原理分析(2)

面试是跳槽涨薪最直接有效的方式,马上金九银十来了,各位做好面试造飞机,工作拧螺丝的准备了吗?掌握了这些知识点,面试时在候选人中又可以夺目不少,暴击9999点。机会都是留给有准备的人,只有充足的准备,才可能让自己可以在候选人中脱颖而出。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!” />面试是跳槽涨薪最直接有效的方式,马上金九银十来了,各位做好面试造飞机,工作拧螺丝的准备了吗?掌握了这些知识点,面试时在候选人中又可以夺目不少,暴击9999点。

2401_84009773的博客 1022

标准库unsafe:带你突破golang中的类型限制

本文主要介绍了unsafe包的检查功能。

华为云官方博客 1596

java unsafe 寄存器_golang中的内存对齐和unsafe初探

unsafe 包简单说明unsafe,顾名思义,是不安全的,Go定义这个包名也是这个意思,让我们尽可能的不要使用它,如果你使用它,看到了这个名字,也会想到尽可能的不要使用它,或者更小心的使用它。使用unsafe包的同时也放弃了Go语言保证与未来版本的兼容性的承诺,因为它必然会有意无意中使用很多非公开的实现细节,而这些实现的细节在未来的Go语言中很可能会被改变。unsafe包被广泛地用于比较低级的包...

weixin_39688636的博客 181

go 如何将int设成nil_深度解密Go语言之unsafe

更好的阅读效果:https://www.cnblogs.com/qcrao-2018/p/10964692.html上一篇文章我们详细分析了 map 的底层实现,如果你也跟着阅读了源码,那一定对 unsafe.Pointer 不陌生,map 对 key 进行定位的时候,大量使用。unsafe.Pointer 位于 unsafe 包,这篇文章,我们来深入研究 unsafe 包。先说明一下,本文没有之...

weixin_36391252的博客 914

GoLang之Go指针和unsafe.Pointer有什么区别

GoLang之Go指针和unsafe.Pointer有什么区别

weixin_52690231的博客 190

Golang标准库揭秘系列 | unsafe

剖析Golang标准库unsafe包的功能,解惑源码阅读时unsafe.Pointer、uintptr、unsafe.Sizeof的含义和由来,了解内存对齐是怎么回事,感受内存空洞的产生

大摩羯先生 912

26 (转)深度解密Go语言之unsafe

(转)深度解密Go语言之unsafe 本文转载自:https://www.cnblogs.com/qcrao-2018/p/10964692.html 文章目录(转)深度解密Go语言之unsafe1、指针类型2、什么是 unsafe3、为什么有 unsafe4、unsafe 实现原理5、unsafe 如何使用5.1 获取 slice 长度5.2 获取 map 长度5.3 map 源码中的应用5.4...

小人物、平凡,世界很大我只想在家 259
上一篇: 浅析字节存储序列的大小端存储方式
下一篇: Java String源码笔记
anteoy
博客等级 码龄10年 24粉丝 83原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值