区块链学习(3) 计算区块的merkle root

Solidity合约中Merkle Root验证的一点实践 Solidity合约中Merkle Root验证的一点实践 背景 在上一篇文章"Solidity合约中签名验证的一点实践"中提到过,白名单机制一般有两种,除了签名验证的方式外,就是本文讲述的Merkle Root验证的方式。 主要做法是在服务端对白名单地址列表整体构建Merkle树,计算出树的root hash,合约只需存储这个Merkle的根哈希值就可以了。由于Merkle tree的构建,不需要任何私钥,所以安全性有很大提升,目前大多数新项目都会采用这个方法。 整体交互流程和签名验证比较相似,大致为: 阅读详情

merkle tree
相关的理论资料较多,这里不做过多描述。
注意当一层的节点为奇数个,最后一个节点需要复制一下生成偶数个节点。每一层都要这样做。


以区块181为例,来描述merkle root的生成过程。
Blockchain.com Explorer | BCH | ETH | BCH


区块181,merkle root生成过程

1、原始的2笔交易
char*  tx1_str=8347cee4a1cb5ad1bb0d92e86e6612dbf6cfc7649c9964f210d4069b426e720a
char*  tx2_str=a16f3ce4dd5deb92d98ef5cf8afeaf0775ebca408f708b2146c4fb42b41e14be

2、字符串转十六进制
uint8_t tx1_bin=8347cee4a1cb5ad1bb0d92e86e6612dbf6cfc7649c9964f210d4069b426e720a
uint8_t tx2_bin=a16f3ce4dd5deb92d98ef5cf8afeaf0775ebca408f708b2146c4fb42b41e14be

3、按uint32_t反转,并转换字节序
uint8_t tx1_bin=0a726e429b06d410f264999c64c7cff6db12666ee8920dbbd15acba1e4ce4783
uint8_t tx2_bin=0a726e429b06d410f264999c64c7cff6db12666ee8920dbbd15acba1e4ce4783

4、拼装 tx1_bin+tx2_bin
0a726e429b06d410f264999c64c7cff6db12666ee8920dbbd15acba1e4ce4783be141eb442fbc446218b708f40caeb7507affe8acff58ed992eb5ddde43c6fa1

5、2次hash tx1_bin+tx2_bin 得到的就是merkle root
第1次hash
b734b24bba5d201de6c5367966161e24f0569e4772e770e39ec9e25d81def56c
转换字节序
4bb234b71d205dba7936c5e6241e1666479e56f0e370e7725de2c99e6cf5de81
第2次hash
092a6c36b45df01550c050b4ac6571ce3f825fd50a4351ee0b3e998ced92b1db
按uint32_t反转,得到最终得merkle root
ed92b1db0b3e998c0a4351ee3f825fd5ac6571ce50c050b4b45df015092a6c36




完整的代码

// xmain.c
// by maxzero

#include "xutils.h"
#include "xsha256.h"

typedef struct {
    int count;
    struct _tx_hash{
        uint8_t hash[32];
    }*list;
}tx_info_t;

static int xdsha256(const uint8_t *src, uint32_t len, uint32_t *hash)
{
    uint32_t sha1[8];
    uint32_t sha2[8];
    int i = 0;

    xsha256(src, len, sha1);
    for (i=0; i<8; i++) {
        sha1[i] = htonl(sha1[i]);
    }
    /*
    printf("sha256-1=");
    xdump_byte((uint8_t*)sha1, 32, 32, 0);*/

    xsha256((uint8_t*)sha1, sizeof(sha1), sha2);
    xreverse_dword(sha2, 8, 0);
    /*
    printf("sha256-2=");
    xdump_byte((uint8_t*)sha2, 32, 32, 0);*/

    if (NULL != hash) {
        memcpy(hash, sha2, sizeof(sha2));
    }
    return 0;
}

static int merkle_hash(uint8_t *tx1_bin, uint8_t *tx2_bin, uint8_t *hash)
{
    uint8_t temp[64];
    uint8_t *p = temp; 

    memset(temp, 0x00, sizeof(temp));

    xreverse_dword((uint32_t*)tx1_bin, 8, 1);
    memcpy(p, tx1_bin, 32);
    p += 32;

    xreverse_dword((uint32_t*)tx2_bin, 8, 1);
    memcpy(p, tx2_bin, 32);

    xdsha256(temp, 64, (uint32_t*)hash);

    return 0;
}

static int transaction_list_get(int block_num, tx_info_t *tx_info)
{
    FILE* f = NULL;
    char* p = NULL;
    int   l = 10*1024*1024*sizeof(char);
    int   i = 0;
    int   n = 0;
    int   r = 0;

    char  url[1024];
    char* buf = NULL;
    int   len = l;
    int   txn = 0;
    char  tmp[80];

    memset(url, 0x00, sizeof(url));
    sprintf(url, "curl -s https://blockchain.info/block-height/%d?format=json", block_num);
    f = popen(url, "r");
    if (NULL == f) {
        xprint_err("popen() failed. url=%s\n", url);
        return -1;
    }
    printf("url=%s\n", url);

    buf = (char *)malloc(len);
    if (NULL == buf) {
        xprint_err("malloc() failed. len=%d\n", len);
        pclose(f);
        return -1;
    }
    sleep(1);
    memset(buf, 0x00, len);
    p = buf;
    n = fread(p, 1, l, f);
    if (n <= 0) {
        xprint_err("fread() failed. n=%d\n", n);
        r = -1;
        goto xexit;
    }
    printf("n=%d l=%d\n", n, l);
    /*
    printf("%s\n\n", buf);*/

    memset(tmp, 0x00, sizeof(tmp));
    n = xkey_value_parser(buf, "\"n_tx\":", ",",tmp, sizeof(tmp));
    if (-1 == n) {
        r = -1;
        goto xexit;
    }

    p = buf + n;
    txn = atoi(tmp);
    printf("block=%06d txn=%d\n", block_num, txn);

    tx_info->count = txn;
    tx_info->list  = (struct _tx_hash*)malloc(sizeof(struct _tx_hash)*(tx_info->count+txn%2));
   
    for (i=0; i<txn; i++) {
        memset(tmp, 0x00, sizeof(tmp));
        n = xkey_value_parser(p, "\"hash\":\"", "\",",tmp, sizeof(tmp));
        if (-1 == n) {
            r = -1;
            break;
        }
        p += n;
        printf("hash[%03d]=%s\n", i, tmp);
        hex2bin(tx_info->list[i].hash, tmp, strlen(tmp));
    }
    printf("\n");

xexit:        
    free(buf);
    pclose(f);
    return r;
}

static int make_merkle_tree_hash(int block_num)
{
    tx_info_t tx_info;
    int i = 0;
    int n = 0;

    /*
    char *tx1_str = "d45724bacd1480b0c94d363ebf59f844fb54e60cdfda0cd38ef67154e9d0bc43"; 
    char *tx2_str = "4d6edbeb62735d45ff1565385a8b0045f066055c9425e21540ea7a8060f08bf2"; 
    char *tx3_str = "6bf363548b08aa8761e278be802a2d84b8e40daefe8150f9af7dd7b65a0de49f"; 
    char *tx4_str = "6bf363548b08aa8761e278be802a2d84b8e40daefe8150f9af7dd7b65a0de49f";

    printf(" tx1_str=%s\n", tx1_str);
    printf(" tx2_str=%s\n", tx2_str);

    tx_info.count = 4;
    tx_info.list  = (struct _tx_hash*)malloc(sizeof(struct _tx_hash)*tx_info.count);
    hex2bin(tx_info.list[0].hash, tx1_str, strlen(tx1_str));
    hex2bin(tx_info.list[1].hash, tx2_str, strlen(tx2_str));
    hex2bin(tx_info.list[2].hash, tx3_str, strlen(tx3_str));
    hex2bin(tx_info.list[3].hash, tx4_str, strlen(tx4_str));*/

    memset(&tx_info, 0x00, sizeof(tx_info));
    if (0 != transaction_list_get(block_num, &tx_info)) {
        goto yexit;
    }

    if (tx_info.count <= 1) {
        goto yexit;
    }

    while (1) {
        if (tx_info.count%2) {
            memcpy(tx_info.list[tx_info.count].hash, tx_info.list[tx_info.count-1].hash, 32);
        }
        for (i = 0; i < tx_info.count; i += 2) {
            uint8_t hash[32];

            merkle_hash(tx_info.list[i].hash, tx_info.list[i+1].hash, hash);
            memcpy(tx_info.list[n].hash, hash, sizeof(hash));
            
            printf("hash[%03d]=", n);
            xdump_byte(hash, 32, 32, 0);

            n ++;
        }
        if (1 == n) {
            break;
        }
        tx_info.count = n;
        n = 0;

        printf("\n\n");
    }

yexit:
    if (NULL != tx_info.list) {
        free(tx_info.list);
        tx_info.list = NULL;
    }
    return 0;
}


int main(int argc, char* argv[])
{
    int block_num = 20000;

    if (argc != 2) {
        printf("usage: a.out [block number]\n");
        printf("   ex: a.out 100\n");
        return -1;
    }

    block_num = atoi(argv[1]);

    make_merkle_tree_hash(block_num);
    printf("\n");

    return 0;
}

程序编译&运行
xsha256.c xutils.c 在区块链学习(2)中,没有改动。
编译:gcc xmain.c xsha256.c xutils.c
运行:./a.out 181
结果:最后一个hash就是merkle root

[SE root@ubuntu xminer]# ./a.out 181
url=curl -s https://blockchain.info/block-height/181?format=json
block=000181 txn=2
hash[000]=8347cee4a1cb5ad1bb0d92e86e6612dbf6cfc7649c9964f210d4069b426e720a
hash[001]=a16f3ce4dd5deb92d98ef5cf8afeaf0775ebca408f708b2146c4fb42b41e14be

hash[000]=ed92b1db0b3e998c0a4351ee3f825fd5ac6571ce50c050b4b45df015092a6c36

[SE root@ubuntu xminer]# 

问题
1、网络不好时
curl -s https://blockchain.info/block-height/181?format=json 这个命令会执行的很慢。
2、读取curl返回结果的缓存可能不够,需要手动调整。
目前10M 3000笔交易是够用了。

以太坊学习三: Merkle树和验证 Merkle树又称为哈希树,是一种二叉树,由一个根节点、若干中间节点和一组叶节点组成。最底层的叶节点存储数据,在它之上的一层节点为它们对应的Hash值,中间节点是它下面两个子节点的Hash值,根节点是最后顶层的Hash值,这个一般成为Merkle根。Merkle树的层层Hash计算,任何底层叶节点或者说某个节点的数据变动都会传递到父亲节点,并直达树根。当叶子节点发生数据改变时,如果要比较两个集合的数据是否相同,则只需比较两次数据的树根即可,若底层叶节点数据相同,则树根相同;反之,树根便不相同。 阅读详情

相关推荐

区块链-如何利用Merkle树验证交易(Merkle 树和简单支付验证(SPV))

目录:https://blog.youkuaiyun.com/qq_40452317/article/details/89646633 Merkle树:https://blog.youkuaiyun.com/qq_40452317/article/details/90482721中说明了Merkle树的一些原理以及提到如何证明某条交易是否存在于该区块中。 现在详细的说一下Merkle树怎么验证交易,以及Me...

朝歌 6649

什么是默克尔树(Merkle Tree)?如何计算默克尔根?

默克尔树(Merkle Tree)是一种特殊的二叉树,它的每个节点都存储了一个数据块的哈希值。哈希值是一种可以将任意长度的数据转换为固定长度的字符串的算法,它具有唯一性和不可逆性的特点,即不同的数据块会产生不同的哈希值,而相同的数据块会产生相同的哈希值,且无法从哈希值还原出原始数据。默克尔树的叶子节点存储了数据块本身的哈希值,而非叶子节点存储了其子节点哈希值的组合的哈希值。这样,默克尔树的根节点就包含了所有数据块的哈希信息,可以用来代表整棵树的唯一标识。

Ning的博客 1510

区块链-默克尔树(Merkle Tree)

Merkle Tree 也被成为 Hash Tree,见名思意,这种树其实就是用来存储 hash 值的一种树。关于hash我们在之前的文章已经说过了,对于一个输入,都有一个唯一的长度的固定的输出,且以我们目前的科技状况,无法找到两个不同的输入使得输出一样。 简单来说就是 y = H(x), y’ = H(x’) 我们无法找到 x != x’, 但 y = y’ 从以上这张图,我可以...

卖鱼的小白菜的专栏 4565

默克尔树(Merkle)

默克尔证明的精髓在于:它用一段极短的数据(路径),借助哈希算法的特性,让你能够验证某个元素(交易)是否属于一个极大集合(区块)的一部分。这就像你要证明某人是某大公司的员工,你不需要拿到整个公司的花名册,只需要他提供工牌、以及他的直属上司、部门总监、HR总监等几个关键人物的身份证明链,最终能追溯到CEO的印章即可。这种方法在保证安全的同时,实现了巨大的效率提升,是区块链技术可扩展性的关键设计之一。

Augety_的博客 639

区块链应用 基于merkle树的共享数据粒度调整方案

区块链应用 基于merkle树的共享数据粒度调整方案区块链共享数据场景及粒度问题什么是Merkle树基于merkle树的数据粒度调整 数据共享是区块链应用一大落地场景,但区块链节点对等、完全互为冗余、节点间互不信任的特点也成为与大数据量、数据精准控制的一个矛盾。 区块链共享数据场景及粒度问题 数据共享是区块链落地应用的一大场景,比如个人信息授权查询,司法存证等,其本质都是:预先将数据传到链上,在必...

beijihukk的博客 528

WEEK2 区块链和分布式账本 Blockchains and Distributed Ledger

比特币区块链的学习

qq_58278472的博客 2605

区块链技术 - 区块链技术细节 - 哈希算法

对于计算机来说,区块链就像一个单向链表,一个数据块中保存着三个信息。这样,通过追溯前一个块的地址,把所有的数据块存成了一条链。所以,我们叫其 BlockChain。如下图所示。每个数据块的 “ 地址 ” 的编码使用了计算机上的一个算法,计算机圈内人士把这个算法叫 Secure Hash。有人音译为 “ 安全哈希 “,也有人意译为 ” 安全散列 “。在计算机应用中,hash 算法主要有几个功能。于是,很多公司在互联网上发布信息或软件的时候,都会带上一个 Checksum(校验码)。

哀莫大于心死 1407

Merkle树和Merkle根的学习与实现(Python)

本文介绍了Merkle树和Merkle根的原理,并使用Python实现了Merkle树的构建和计算Merkle根的过程。它通过逐层计算数据块的哈希值,最终生成一个根哈希,也称为Merkle根(Merkle Root)。在本文中,我们将学习Merkle树的原理和实现,并使用Python编写相应的代码。节点合并:在Merkle树中,每个非叶子节点的值是其子节点的哈希值的合并结果。Merkle树是一种二叉树,每个叶子节点表示一个数据块,而非叶子节点则表示它的子节点的哈希值。函数用于计算数据块的哈希值。

Meta_C的博客 890

区块链基础之Merkle树

Merkle树是区块链技术的基石之一,确保了去中心化环境下的数据可信性。Merkle树(Merkle Tree)是一种,由计算机科学家Ralph Merkle在1979年提出。它广泛应用于分布式系统、密码学和区块链(如比特币、以太坊)中,用于高效验证数据的完整性和一致性。

2404_87143740的博客 442

区块链基础学习:Python实现Merkle Tree和Merkle Root

我们从底部开始查询节点,按照从左到右的顺序分组成对,然后使用hash_nodes()方法来计算每个节点的哈希值,并将其添加到当前层级的列表。接下来,我们将实现一个计算Merkle根的方法。在本文中,我们将使用Python编写一个简单的Merkle Tree和Merkle Root实现,并进行简明扼要的讲解。上面的输出结果展示了一个Merkle Tree的完整结构,从底部到顶部,总共有4层,每一层都由两个节点哈希值组成。我们可以看到,最后输出结果仅包含Merkle根的哈希值,这是我们需要的结果。

Meta_C的博客 387

汽车诊断之UDS入门-0x19 0x0A服务

0x19 0x0A解析

weixin_44842720的博客 3837

Merkle树原理与实战:从区块链基石到数据完整性验证

哈希树(Hash Tree)作为一种密码学数据结构,其核心原理是通过分层哈希计算,将大量数据的完整性验证转化为对单个根哈希的验证。这种设计实现了对数级的时间复杂度优化,从线性验证的O(N)降低到O(log N),在数据量庞大时带来质的效率提升。其技术价值在于能够在分布式、不信任的环境中,以极小的数据开销实现高效、安全的数据完整性验证和成员证明。这一特性使其成为区块链技术的基石,广泛应用于轻客户端同步、分布式文件系统验证等场景。本文以Merkle树为例,深入解析其构建过程、Merkle Proof生成验证机制

weixin_33923762的博客 319

【操作系统】 Operation System 第二章:操作系统基础操作

2.1 操作系统的启动 (1)CPU, I/O, 内存通过总线连接。 (2)DISK:存放OS; BIOS:基本I/O处理系统( basic I/O system); Bootloader: 加载OS到内存中。 (3)当电脑通电时,段寄存器CS和指令寄存器IP能够确定一个内存地址,例如CS:IP = 0xf000:fff0. (4)POST(加电自检),寻找显卡和执行BIOS。(显示器,键盘…是否...

iwanderu的博客 1万+

初识区块链--Merkle Tree

转载自:博客园 风之舞555 /最近在看Ethereum,其中一个重要的概念是Merkle Tree,以前从来没有听说过,所以查了些资料,学习了Merkle Tree的知识,因为接触时间不长,对Merkle Tree的理解也不是很深入,如果有不对的地方,希望各位大神指正/ Merkle Tree概念 Merkle Tree,通常也被称作Hash Tree,顾名思义,就是存储hash值的一棵树。Merkle树的叶子是数据块(例如,文件或者文件的集合)的hash值。非叶节点是其对应子节点串联字符串的hash。[

weixin_45919895的博客 380

解决ADS1.2报错Cannot obtain license

报错如下 将licenses文件下的license内容进行修改: 修改为如下内容即可。 # # Generated on 2021-dec-1 by licwizard # PACKAGE ads armlmd 1.200 E32F0DE5161D COMPONENTS="armasm compiler bats armulate axd adwu fromelf armlink codewarrior armsd" INCREMENT ads armlmd 1.200 permanent uncounte

qq_46110320的博客 3464

无法找到来自源 nvlddmkm 的事件 ID 14 的描述

具体错误是: 无法找到来自源 nvlddmkm 的事件 ID 14 的描述。本地计算机上未安装引发此事件的组件,或者安装已损坏。可以安装或修复本地计算机上的组件。 出现这样错误的原因有很多了,有可能是硬件有可能是软件。由于我是刚配置的电脑,起初非常怀疑是自己组装的问题,折腾了好久,心态爆炸!!!先说我报这样错误的情况,以及解决办法,供后面人参考。 ...

SeventhBlue 6万+

区块链Merkle树:构建原理、验证机制与工程实践详解

在分布式系统和密码学领域,哈希函数作为基础技术,能够将任意长度的数据映射为固定长度的唯一摘要,确保数据的完整性与不可篡改性。基于哈希构建的Merkle树,通过递归哈希运算形成树状结构,其核心原理在于利用哈希的雪崩效应和抗碰撞性,实现高效的数据完整性验证。这一数据结构的技术价值在于,它使得轻量级客户端无需下载全部数据,仅通过简短的Merkle路径(Merkle Proof)即可验证特定数据的存在性,极大提升了验证效率并降低了通信开销。在区块链技术中,Merkle树作为关键组件,为交易数据的可信验证提供了基础,

congbao6525的博客 464

用野火FPGA开发板(EP4CE10)手把手教你实现一个高精度频率计(附完整Verilog代码)

本文详细介绍了基于野火FPGA开发板(EP4CE10)实现高精度频率计的全过程,涵盖等精度测量法的核心原理、Verilog代码实现及优化技巧。通过实际案例演示,帮助开发者掌握1Hz-50MHz范围、精度达0.1%的频率计设计方法,并提供完整的工程代码和实测数据。

weixin_29261711的博客 441

区块链入门的几个基本问题

区块链扫盲贴

曲折旅程,艰难人生 2348

室内无人机自主定位:融合Mid360激光雷达与光流传感器的无GPS导航实践

本文详细介绍了室内无人机自主定位技术,通过融合Mid360激光雷达与光流传感器实现无GPS导航。文章分析了技术挑战、硬件配置、算法优化及实战调试,展示了在复杂室内环境中如何实现厘米级定位精度,为仓库巡检、隧道勘测等场景提供可靠解决方案。

weixin_30500105的博客 533

汽车TSN时间敏感网络测试技术与探索系列讲座4 -TSN802.1AS同步要求及验证方法

TSN网络各设备类型同步性能要求是什么?各类设备的测试组网及测试内容。也将通过演示来展示相关测试结果,及如何解决上述的测试关注点。

weixin_43903833的博客 762

区块链学习笔记 | 比特币中的数据结构

这一篇来讲讲比特币中的数据结构,数据结构没学好的同学也是可以看懂的哟~O(∩_∩)O 1、哈希指针 ​这里需要用到的一个重要的概念就是哈希指针(hash pointers)一般用H( )表示。 ​普通的指针存储的是某个结构体在内存中的地址,哈希指针除了要存地址以外,还要存这个结构体的哈希值,这样做的好处是:通过这个哈希指针不仅能够找到结构体的位置,还能检测出结构体的内容是否被篡改。 2、区块链 ...

Curry_On的博客 989

华为OD机试双机位C卷-字符串解密(Py/Java/C/C++/Js/Go)

华为OD机试(机考)双机位C卷 【字符串解密】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试 - 字符串解密。

qq_45776114的博客 735

区块链技术基石:哈希函数、密码学与Merkle树的协同信任架构

区块链技术基于密码学和计算机科学原理构建,核心组件包括:哈希函数(保障数据完整性和链式结构)、非对称加密(实现密钥对管理和数字签名)、Merkle树(优化数据验证与存储)、侧链技术(扩展功能与资产互通)。这些技术协同工作,形成去中心化信任体系,支持交易验证、数据防篡改和跨链交互。未来面临量子计算等挑战,需发展抗量子算法,并融合零知识证明、分片等新技术持续演进。整套机制为加密货币和分布式应用提供了安全可靠的基础架构。

boyedu的博客 519

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

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

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

区块链交易验证和支付验证

简单支付验证(Simplified Payment Verification, SPY)是一种无须维护完整的区块链信息,只需要保存所有的区块头部信息即可进行支付验证的技术。 该技术可以大大节省区块链支付验证用户的存储空间,减轻存储负担,降低区块链未来交易量剧增而给用户 ...

qq_44587855的博客 3459

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Fuel区块头格式完全手册:区块链数据结构核心解析

Fuel协议作为高性能区块链平台的核心,其区块头设计是确保网络安全与高效运行的基础。本文将全面解析Fuel区块头的结构组成、核心字段含义及 cryptographic 原理,帮助开发者与区块链爱好者深入理解这一关键数据结构。 ## 什么是Fuel区块头? 区块头是区块链的"身份证",包含了验证区块合法性所需的关键元数据。在Fuel协议中,区块头采用双层结构设计:**应用层头**(Applica

gitblog_00559的博客 335
上一篇: 区块链学习(2) 计算区块的哈希值
下一篇: 区块链学习(4) 难度目标调整
maxzero
博客等级 码龄20年 57粉丝 24原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值