Junyan Wu Hexo https://junyanwu.github.io/ All rights reserved 2026, Junyan Wu 但行好事，莫问前程 SIGMA's BLOG 2026-08-18T05:18:12.528Z Junyan Wu 卷积操作

$O$是output_shape，$W$是image，$K$是filter，$P$是padding，$S$是stride

stride = 1

stride = 2

Padding

  • padding的计算公式与conv一样
  • zero padding

有这些情况会使用zero padding

  • 卷积后image尺寸很小，但我们又想使用conv
  • 由于image尺寸跟filter尺寸的原因

pooling

也叫downsampling（下采样）层，最常用的是max-pooling

stride = 2

ReLu

优点：

  • 因为它在准确度不发生明显改变的情况下能把训练速度提高很多
  • 能够减轻vanishing gradient problem
    —指梯度以指数方式在层中消失，导致网络较底层的训练速度非常慢
  • 把negative activation变为0，增加了模型的非线性特征，而且不影响感受域

参见 Geoffrey Hinton（即深度学习之父）的论文：Rectified Linear Units Improve Restricted Boltzmann Machines

Dropout

随机丢弃神经元，简单来说，就是在训练过程中在Dropout层设置一个随机的激活参数集，在forward pass中将这些激活参数集设置为0。

理解了大概，这部分细节需要详细看看

参考资料
https://www.zhihu.com/question/52668301

]]> https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/CNN/ 2017-12-21T03:05:23.000Z 卷积操作
  • $u_i(i \in [6 × 6 × 32])$： 表示PrimaryCaps的某个8D的Capsule
  • $\hat{u}_{j|i}$： 论文中称之为低一层的capsules的“prediction vectors”
  • $b_{ij}$： 初始化为0，更新方法是 $b_{ij} \leftarrow b_{ij} + \hat{u}_{j|i} v_j$。 其中$a_{ij} = \hat{u}_{j|i} v_j$表示$capsule_j$（即$v_j$）跟$capsule_i$的prediction vector（即$\hat{u}_{j|i}$）的agreement（契合度）。值越大，表示两个向量的方向越相似，两个向量所表示的性质越相近。由 $c_{ij}$ 的公式知，$b_{ij}$ 的值越大（意味着两个向量的方向越相似），$c_{ij}$ 的值越大，$capsule_i$ 越倾向于将信息传送给 $capsule_j$ 。
  • $c_{ij}$： 由动态路由算法更新的coupling coefficients，并且 $\sum{i} c\{ij} = 1$（此时$j$为某确定的常数）
  • $s_j$： $capsule_j$ 的所有input之和。
  • $squash()$： 非线性函数，保留了向量的方向，使长的向量越长，短的向量越短，并且长度都压缩在0-1之内
  • $v_j$： 由dynamic routing计算出来的PrimaryCaps的output。在文章中就是指最后的输出DigitCaps，共有10个（因为有10个数字，即10类）Capsule。每个capsule有16维，每一维都代表着数字的某些属性（粗细、倾斜程度等等）。向量的长度代表了当前输入是类 $j$ 的概率。

Dynamic Routing算法流程

整个过程如下所示（图片来自naturomics的ppt）：

Reconstruction

CapsNet使用Reconstruction作为Regularization。其做法是将DigitCaps的十个输出向量$v_j$中长度最长的向量，经过3个FC层（结构如下图所示）重构出原来的图像，通过对比重构的图像和原图像的差异(pixel-wise)，得到reconstruction loss。用来重构的这三个FC层一起称为Decoder。

Total loss

由于有多个类的存在，所以不能用cross entropy，论文中使用了SVM中常用的损失函数Margin loss来代替

Margin loss

  • k： class k，$k\in[1, 10]$
  • $m^+=0.9, m^-=0.1$ （自己设定）

  • $\lambda$ （比例系数，用来调整两者的比重）：

    The λ down-weighting of the loss for absent digit classes stops the initial learning from shrinking the lengths of the activity vectors of all the digit capsules. We use λ = 0.5.

  • 如果输入的数字图像是class k，那么$T_k=1$

  • | 示例 | 输入输出 | $|v_k|$ | $L_k$ |
    | — | ——————————- | ——- | ——- |
    | TT | 输入数字k 预测结果为数字k | 比较大 | 比较小 |
    | TF | 输入数字k 预测结果非数字k | 比较小 | 比较大 |
    | FT | 输入非数字k 预测结果为数字k | 比较大 | 比较大 |
    | FF | 输入非数字k 预测结果非数字k | 比较小 | 比较小 |
  • 可以看出，在假阳性和假阴性的示例中，$L_k$的值比较大。

Reconstruction loss

计算原图像与重构的图像在对应的pixel位置上的值之差，求和得到Reconstruction loss

1
2
3
4
将原图像x(28, 28)reshape成orgin(784)
再将重构的图像decoded(784)
squared = square(decoded - orgin)
reconstruction_loss = mean(squared)

即

最后：


实验

MNIST

l=label, p=prediction, r=reconstruction。下面最右的两列展示了模式是如何在5和3之间纠结的。而其它列表明了模型不仅保留了图片的细节并且平滑了噪声。

Dimension perturbations

改变DigitCaps中的capsule的16维中的一维，这个被改变的capsule所重构出来的图像也会有所变化（比如笔画变得更粗）。这表明了capsule学习到了entity，并且每一维都代表着entity的某个feature，具有很强的解释性。

MultiMNIST

L指的是两个label，R指的是两个用于重构的图像。上面白色的是input image，下面红绿色重叠的是重构的图像。

如下图所示，实验把两个激活程度最高的capsule对应的数字作为识别结果，据此对识别到的图像元素进行了重构。对于左边中识别正确的样本（L指真实标签，R指激活程度最高的两个胶囊对应的标签），可以看到由于不同的capsule各自工作，在一个识别结果中用到的特征并不会影响到另一个识别结果，不受重叠的影响（或者说重叠部分的特征可以复用）。

另一方面，每个capsule还是需要足够多的周边信息支持，而不是一味地认为重叠部分的特征就需要复用。下图中间是选了一个高激活程度的capsule和一个低激活程度capsule的结果（* R表示其中一个数字既不是真实标签也不是识别结果，L仍然为真实标签）。可以看到，在（5，0）图中，关注“7”的capsule并没有找到足够多的“7”的特征，所以激活很弱；（1，8）图中也是因为没有“0”的支持特征，所以重叠的部分也没有在“0”的capsule中用第二次。

最右R:P:(2, 7)指的是预测结果是2,7，然后将代表2和7的capsule重构。


CapsNet与tradictional neuron的对比

（图片来自naturomics）：


总结

为什么要用Routing-by-agreement？

传统的CNN里面，conv后面是max-pooling层，但是max-pooling只保留了唯一一个最活跃的特征，而Routing则有效得多。

Routing-by-agreement有以下几个好处：

  • 由于上一层的capsule会逐渐倾向于将信息传到下一层与它相似的capsule，这样就能够给下一层capsule干净清晰的信号，减少噪声，从而更快地学习到entity
  • 通过追溯当前被激活的capsule的信号传输路径，我们可以操控part-whole中的part，并且清楚知道哪一个part属于哪一个entity（比如说识别一个由三角形和长方形组成的房屋，在$layer l$可能有个capsule是检测三角形，有个capsule检测长方形，则在$layer l+1$有能够得到检测房屋的capsule。此为ppart-whole的关系）。
  • 可以很容易地解析重叠的entity，比如重叠的数字识别。

the capsules in the first layer try to predict what the second layer capsules will output


代码阅读

代码link

由于代码基本上都是按照文章思路来写的，所以不重复讲，而是介绍主要的结构。

目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
CapsNet-Tensorflow
  - capsLayer.py
      定义了capsLayer的实现方法。
      由于论文中提及的capsLayer有两种:
        PrimaryCaps(without routing)
        DigitCaps(with routing)
      所以该文件里面也包含了这两种Layer的实现方式
      另外，该文件还有:
        routing
        squash

  - capsNet.py
      定义了CapsNet类
      包含：
        build_arch()  # 定义结构
        loss()        # 定义loss

  - config.py
      超参数设定

  - main.py
      程序入口

  - utils.py
      用于读取MNIST的数据

主要代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
class CapsNet(object):
    def __init__(self, is_training=True):
        self.graph = tf.Graph()
        with self.graph.as_default():
            if is_training:  # 如果是在训练过程中
                self.X, self.labels = get_batch_data()  # 获取training data和label
                self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32)  # 对label做onehot

                self.build_arch()  # 搭建CapsNet的结构
                self.loss()        # 定义loss
                self._summary()

                # t_vars = tf.trainable_variables()
                self.global_step = tf.Variable(0, name='global_step', trainable=False)
                self.optimizer = tf.train.AdamOptimizer()  # 使用AdamOptimizer
                self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step)  # var_list=t_vars)
            elif cfg.mask_with_y:  # 如果是已经训练完
                self.X = tf.placeholder(tf.float32,
                                        shape=(cfg.batch_size, 28, 28, 1))
                self.Y = tf.placeholder(tf.float32, shape=(cfg.batch_size, 10, 1))
                self.build_arch()
            else:
                self.X = tf.placeholder(tf.float32,
                                        shape=(cfg.batch_size, 28, 28, 1))
                self.build_arch()

        tf.logging.info('Seting up the main structure')

    def build_arch(self):
        with tf.variable_scope('Conv1_layer'):
            # Conv1, [batch_size, 20, 20, 256]
            conv1 = tf.contrib.layers.conv2d(self.X, num_outputs=256,
                                             kernel_size=9, stride=1,
                                             padding='VALID')
            assert conv1.get_shape() == [cfg.batch_size, 20, 20, 256]

        # Primary Capsules layer, return [batch_size, 1152, 8, 1]
        with tf.variable_scope('PrimaryCaps_layer'):
            primaryCaps = CapsLayer(num_outputs=32, vec_len=8, with_routing=False, layer_type='CONV')
            caps1 = primaryCaps(conv1, kernel_size=9, stride=2)
            assert caps1.get_shape() == [cfg.batch_size, 1152, 8, 1]

        # DigitCaps layer, return [batch_size, 10, 16, 1]
        with tf.variable_scope('DigitCaps_layer'):
            digitCaps = CapsLayer(num_outputs=10, vec_len=16, with_routing=True, layer_type='FC')
            self.caps2 = digitCaps(caps1)

        # Decoder structure in Fig. 2
        # 1. Do masking, how:
        with tf.variable_scope('Masking'):
            # a). calc ||v_c||, then do softmax(||v_c||)
            # [batch_size, 10, 16, 1] => [batch_size, 10, 1, 1]
            self.v_length = tf.sqrt(tf.reduce_sum(tf.square(self.caps2),
                                                  axis=2, keep_dims=True) + epsilon)
            self.softmax_v = tf.nn.softmax(self.v_length, dim=1)
            assert self.softmax_v.get_shape() == [cfg.batch_size, 10, 1, 1]

            # b). pick out the index of max softmax val of the 10 caps
            # [batch_size, 10, 1, 1] => [batch_size] (index)
            self.argmax_idx = tf.to_int32(tf.argmax(self.softmax_v, axis=1))
            assert self.argmax_idx.get_shape() == [cfg.batch_size, 1, 1]
            self.argmax_idx = tf.reshape(self.argmax_idx, shape=(cfg.batch_size, ))

            # Method 1.
            if not cfg.mask_with_y:
                # c). indexing
                # It's not easy to understand the indexing process with argmax_idx
                # as we are 3-dim animal
                masked_v = []
                for batch_size in range(cfg.batch_size):
                    v = self.caps2[batch_size][self.argmax_idx[batch_size], :]
                    masked_v.append(tf.reshape(v, shape=(1, 1, 16, 1)))

                self.masked_v = tf.concat(masked_v, axis=0)
                assert self.masked_v.get_shape() == [cfg.batch_size, 1, 16, 1]
            # Method 2. masking with true label, default mode
            else:
                # self.masked_v = tf.matmul(tf.squeeze(self.caps2), tf.reshape(self.Y, (-1, 10, 1)), transpose_a=True)
                self.masked_v = tf.multiply(tf.squeeze(self.caps2), tf.reshape(self.Y, (-1, 10, 1)))
                self.v_length = tf.sqrt(tf.reduce_sum(tf.square(self.caps2), axis=2, keep_dims=True) + epsilon)

        # 2. Reconstructe the MNIST images with 3 FC layers
        # [batch_size, 1, 16, 1] => [batch_size, 16] => [batch_size, 512]
        with tf.variable_scope('Decoder'):
            vector_j = tf.reshape(self.masked_v, shape=(cfg.batch_size, -1))
            fc1 = tf.contrib.layers.fully_connected(vector_j, num_outputs=512)
            assert fc1.get_shape() == [cfg.batch_size, 512]
            fc2 = tf.contrib.layers.fully_connected(fc1, num_outputs=1024)
            assert fc2.get_shape() == [cfg.batch_size, 1024]
            self.decoded = tf.contrib.layers.fully_connected(fc2, num_outputs=784, activation_fn=tf.sigmoid)

    def loss(self):
        # 1. The margin loss

        # [batch_size, 10, 1, 1]
        # max_l = max(0, m_plus-||v_c||)^2
        max_l = tf.square(tf.maximum(0., cfg.m_plus - self.v_length))
        # max_r = max(0, ||v_c||-m_minus)^2
        max_r = tf.square(tf.maximum(0., self.v_length - cfg.m_minus))
        assert max_l.get_shape() == [cfg.batch_size, 10, 1, 1]

        # reshape: [batch_size, 10, 1, 1] => [batch_size, 10]
        max_l = tf.reshape(max_l, shape=(cfg.batch_size, -1))
        max_r = tf.reshape(max_r, shape=(cfg.batch_size, -1))

        # calc T_c: [batch_size, 10]
        # T_c = Y, is my understanding correct? Try it.
        T_c = self.Y
        # [batch_size, 10], element-wise multiply
        L_c = T_c * max_l + cfg.lambda_val * (1 - T_c) * max_r

        self.margin_loss = tf.reduce_mean(tf.reduce_sum(L_c, axis=1))

        # 2. The reconstruction loss
        orgin = tf.reshape(self.X, shape=(cfg.batch_size, -1))
        squared = tf.square(self.decoded - orgin)
        self.reconstruction_err = tf.reduce_mean(squared)

        # 3. Total loss
        # The paper uses sum of squared error as reconstruction error, but we
        # have used reduce_mean in `# 2 The reconstruction loss` to calculate
        # mean squared error. In order to keep in line with the paper,the
        # regularization scale should be 0.0005*784=0.392
        self.total_loss = self.margin_loss + cfg.regularization_scale * self.reconstruction_err
]]> https://junyanwu.github.io/2017/12/21/deeplearning/paper/Dynamic_Routing_Between_Capsules%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/ 2017-12-21T03:05:23.000Z Intro

本文记录了阅读论文

Dynamic Routing Between Capsules论文阅读 2026-08-18T05:18:12.527Z Junyan Wu Intro

若发现存在错误，欢迎指正。

GCN，是基于Spectral Graph Theory所研究出来的一种方法，它主要的好处是利用了SGT里面一些已有的结论和方法，来得到图的性质。GCRN是一个将GCN和RNN结合起来使用的模型，能处理具有空间和时序的数据。

源代码的目录结构：

1
2
3
4
5
6
7
8
9
10
11
gconvRNN
  - datasets
    - ptb.char.test.txt
    - ptb.char.train.txt
    - ptb.char.valid.txt
  - gcrn_main.py  # 整个程序的入口
  - config.py  # 用于配置超参数
  - graph.py  # 与图相关的操作，比如laplacian矩阵
  - model.py  # 模型的定义
  - trainer.py  # 定义了训练过程
  - utils.py  # 数据预处理、工具

在源码中，GCRN用于预测单词字符序列

本文从三个方面讲解GCRN源码的处理思路

  • 数据预处理
  • GCRN实现思路
  • 开始训练
  • 代码附录

数据预处理：

train\valid\test 数据集的格式都是一样的：

a e r b a n k n o t e b e r l i t z c a l l o w a y c e n t r u s t c l u e t t f r o m s t e i n g i t a n o g u t e r m a n h y d r o - q u e b e c i p o k i a m e m o t e c m l x n a h b p u n t s r a k e r e g a t t a r u b e n s s i m s n a c k - f o o d s s a n g y o n g s w a p o w a c h t e r
p i e r r e < u n k > N y e a r s o l d w i l l j o i n t h e b o a r d a s a n o n e x e c u t i v e d i r e c t o r n o v . N
m r . < u n k > i s c h a i r m a n o f < u n k > n . v . t h e d u t c h p u b l i s h i n g _ g r o u p

  • UNK - “unknown token” - is used to replace the rare words that did not fit in your vocabulary. So your sentence My name is guotong1998 will be translated into My name is _unk_

1. 将句子按字典映射成数字序列

1
2
3
for every sentences:
  在句子后面加“|”（人为地添加句子的结束标识符）
  将句子里面的*每个字符*映射成该字符在字典中*对应的数字*

例如：

p i e r r e < u n k > N y e a r s o l d w i l l j o i n t h e b o a r d a s a n o n e x e c u t i v e d i r e c t o r n o v . N |

[24, 10, 1, 2, 2, 1, 3, 27, 15, 5, 6, 28, 3, 29, 3, 14, 1, 0, 2, 16, 3, 7, 9, 21, 3, 13, 10, 9, 9, 3, 30, 7, 10, 5, 3, 8, 20, 1, 3, 4, 7, 0, 2, 21, 3, 0, 16, 3, 0, 3, 5, 7, 5, 1, 25, 1, 12, 15, 8, 10, 31, 1, 3, 21, 10, 2, 1, 12, 8, 7, 2, 3, 5, 7, 31, 32, 3, 29, 26]

2. 构造邻接矩阵

得到邻接矩阵的值：

GCRN实现思路：

GCRN = GCN + RNN。

公式：

但是 代码中的实现方式稍有不同

GCN ：

每次得到的 $T_k(x)$ 都与x做concat，最后得到的x与W相乘

LSTM ：

开始训练

数据预处理 -> model定义 -> train

输出ouput的shape为(batch_size, num_node, num_unit) —— (20, 50, 50)。由于设置了有50个LSTM units，所以这里需要使所有units的输出做线性变换，使其变为一个值：

  • prediction = output * W -b，这里的prediction的shape为(20, 50, 1)

那么，所有时刻的输出的shape为(50, 20, 50, 1)

代码

GCN实现方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
def cheby_conv(x, L, lmax, feat_out, K, W):
    '''
    x : [batch_size, N_node, feat_in] - input of each time step
    nSample : number of samples = batch_size
    nNode : number of node in graph
    feat_in : number of input feature
    feat_out : number of output feature
    L : laplacian
    lmax : ?
    K : size of kernel(number of cheby coefficients)
    W : cheby_conv weight [K * feat_in, feat_out]
    '''
    nSample, nNode, feat_in = x.get_shape()
    nSample, nNode, feat_in = int(nSample), int(nNode), int(feat_in)
    L = graph.rescale_L(L, lmax) #What is this operation?? --> rescale Laplacian
    L = L.tocoo()

    indices = np.column_stack((L.row, L.col))
    L = tf.SparseTensor(indices, L.data, L.shape)
    L = tf.sparse_reorder(L)

    x0 = tf.transpose(x, perm=[1, 2, 0]) #change it to [nNode, feat_in, nSample]
    x0 = tf.reshape(x0, [nNode, feat_in*nSample])
    x = tf.expand_dims(x0, 0) # make it [1, nNode, feat_in*nSample]

    def concat(x, x_):
        x_ = tf.expand_dims(x_, 0)
        return tf.concat([x, x_], axis=0)

    if K > 1:
        x1 = tf.sparse_tensor_dense_matmul(L, x0)
        x = concat(x, x1)

    for k in range(2, K):
        x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0
        x = concat(x, x2)
        x0, x1 = x1, x2

    x = tf.reshape(x, [K, nNode, feat_in, nSample])
    x = tf.transpose(x, perm=[3,1,2,0])
    x = tf.reshape(x, [nSample*nNode, feat_in*K])

    x = tf.matmul(x, W) #No Bias term?? -> Yes
    out = tf.reshape(x, [nSample, nNode, feat_out])
    return out

LSTM实现方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
def __call__(self, inputs, state, scope=None):
    with tf.variable_scope(scope or type(self).__name__):
        if self._state_is_tuple:
            c, h = state
        else:
            c, h = tf.split(value=state, num_or_size_splits=2, axis=1)
        laplacian = self._laplacian
        lmax = self._lmax
        K = self._K
        feat_in = self._feat_in

        #The inputs : [batch_size, nNode, feat_in, nTime?] size tensor
        if feat_in is None:
            #Take out the shape of input
            batch_size, nNode, feat_in = inputs.get_shape()
            print("hey!")

        feat_out = self._num_units

        if K is None:
            K = 2

        scope = tf.get_variable_scope()
        with tf.variable_scope(scope) as scope:
            try:
                #Need four diff Wconv weight + for Hidden weight
                Wzxt = tf.get_variable("Wzxt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wixt = tf.get_variable("Wixt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wfxt = tf.get_variable("Wfxt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Woxt = tf.get_variable("Woxt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))

                Wzht = tf.get_variable("Wzht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wiht = tf.get_variable("Wiht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wfht = tf.get_variable("Wfht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Woht = tf.get_variable("Woht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
            except ValueError:
                scope.reuse_variables()
                Wzxt = tf.get_variable("Wzxt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wixt = tf.get_variable("Wixt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wfxt = tf.get_variable("Wfxt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Woxt = tf.get_variable("Woxt", [K*feat_in, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))

                Wzht = tf.get_variable("Wzht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wiht = tf.get_variable("Wiht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Wfht = tf.get_variable("Wfht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))
                Woht = tf.get_variable("Woht", [K*feat_out, feat_out], dtype=tf.float32,
                                       initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1))


            bzt = tf.get_variable("bzt", [feat_out])
            bit = tf.get_variable("bit", [feat_out])
            bft = tf.get_variable("bft", [feat_out])
            bot = tf.get_variable("bot", [feat_out])

            # gconv Calculation
            zxt = cheby_conv(inputs, laplacian, lmax, feat_out, K, Wzxt)
            zht = cheby_conv(h, laplacian, lmax, feat_out, K, Wzht)
            zt  = zxt + zht + bzt
            zt  = tf.tanh(zt)

            ixt = cheby_conv(inputs, laplacian, lmax, feat_out, K, Wixt)
            iht = cheby_conv(h, laplacian, lmax, feat_out, K, Wiht)
            it  = ixt + iht + bit
            it  = tf.sigmoid(it)

            fxt = cheby_conv(inputs, laplacian, lmax, feat_out, K, Wfxt)
            fht = cheby_conv(h, laplacian, lmax, feat_out, K, Wfht)
            ft  = fxt + fht + bft
            ft  = tf.sigmoid(ft)

            oxt = cheby_conv(inputs, laplacian, lmax, feat_out, K, Woxt)
            oht = cheby_conv(h, laplacian, lmax, feat_out, K, Woht)
            ot  = oxt + oht + bot
            ot  = tf.sigmoid(ot)

            # c
            new_c = ft*c + it*zt

            # h
            new_h = ot*tf.tanh(new_c)

            if self._state_is_tuple:
                new_state = LSTMStateTuple(new_c, new_h)
            else:
                new_state = tf.concat([new_c, new_h], 1)
            return new_h, new_state

其他变量

变量shapemeaning
rnn_input(20, 50, 1, 50)(batch_size, num_node, feat_in, num_time_steps)
rnn_input_seq(20, 50, 1) * 50(batch_size, num_node, feat_in) * num_time_steps
rnn_output(20, 50)(batch_size, num_time_steps)
rnn_output_seq(20) * 50(batch_size) * num_time_steps
num_hidden50隐藏层单元
x_batches(5017, 20, 50)[-1, batch_size, seq_length]
y_batches(5017, 20, 50)[-1, batch_size, seq_length]
outputs(50, 20, 50, 50)(50个时刻50个输出, batch_size, num_node, num_unit)
output(20, 50, 50)outputs的单个时刻输出(batch_size, num_node, num_unit)

Laplacian matrix

Properties

对一个无向图$G$和他的laplacian matrix $L$，有特征值$\lambda_0 \leq \lambda_1 \leq \lambda_2 …$：

  • L是对称的
  • L是半正定的（即所有$\lambda_i > 0$），这可以在关联矩阵部分验证，也同样可以从Laplacian是对称并且对角占优(diagonally dominant)得出
  • L是M-matrix（它的非对角线上的项是负的，但它的特征值的实部为负）
  • 行或列相加结果为0
  • L的最小非零特征值称为谱间隙（spectral gap）
  • 图中连通分量的个数是拉普拉斯算子的零空间维数和0特征值的代数多重性
  • 拉普拉斯矩阵是奇异的

问题

  1. 代码实现里面的公式跟论文是否真的不一样
  2. x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0 起到一个什么作用

后记

补充一下，后来跟实验室的小伙伴谈论过后对GCN有了比较深刻的认识。上面问题中的第二点，其实跟GCN的K的大小有关。K=1，表示包含了该节点一条的信息。至于为什么会这样，这是因为在计算过程中与由adj mnatrix得来的Laplacian相乘，每乘一次，就会多包含一跳的节点信息。

]]> https://junyanwu.github.io/2017/12/21/deeplearning/paper/GCRN/ 2017-12-21T03:05:23.000Z Intro

在统计学里面，Huber loss是一个在robust regression里面用的loss func。它对离群点没平方差那么敏感。

定义

其中，$|a| = \delta, a = y-f(x)$。$\delta$是参数，$f(x)$是模型的预测值，$y$是真实值。

可以看到，当$a < \delta$时，L是二次的；否则，则是线性的。

]]> https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/Huber_loss/ 2017-12-21T03:05:23.000Z
  • wikipedia

    • 在统计学里面，Huber loss是一个在]]>

    Huber loss 2026-08-18T05:18:12.527Z Junyan Wu Why RNN

    某些任务是需要NN具有记忆的，比如

    • 我 来了 台北
    • 我 离开了 台北

    要确定我要离开还是来了台北，需要知道前一个单词是什么。这就需要网络具有记忆，于是就提出了RNN。

    Why RNN’s error surface so rough

    这是长距离传输引起的。假设有一个RNN，它的 memory 等于上一个时刻的 memory * w。除了第一个时刻 input = 1 之外，其他所有时刻 input = 0。那么在经过1001个时刻的传输后：

    可以看到，w发生微小的变化会引起蝴蝶效应。这是长距离传输里面存在的问题，也是 error surface 抖动如此大的原因所在。

    当然，这是李宏毅视频里面说的，我的问题是，这明显是一个单调函数，如何会引起剧烈抖动？

    可能跟 training 过程中参数的微小变化有关。但是参数存在以下变动情况：

    • 参数经常有微小变化。这个应该不会形成蝴蝶效应吧？
    • 参数单调增减一段时间又单调减增。不明。
    • 参数总体是单调的。这种情况应该是逐渐变化的，不会出现剧烈抖动吧？
    • 参数经常剧烈变化，即 Gradient 值突然很大。根据前面视频的内容，RNN应该就是这种情况。只是如果是这种情况，他举上面那个长距离传输例子既不是都不相关了吗？

    后来我通过编程发现，result *= w这种运算一开始 result(t)-result(t-1)只有0.几，但是到后面就有100+。

    所以，这确实是原因所在，训练越到后面，Gradient 的值变化越来越大，error surface 的动荡越频繁越明显。所以作者想了下面的解决办法。

    how to solve

    由于RNN的 error surface 太陡峭，所以训练的时候有个技巧，就是当 Gradient 超过某个 threshold 的时候就不要让它超过那个 threshold 。比如说超过了15，就让它 = 15。这样，参数的变化就会相对不会起飞太严重。

    RNN的training trick

    Identity matrix + ReLU

    对于一般的RNN来说，可以用单位矩阵+ReLU来初始化RNN，会有很好的效果

    LSTM

    具体实现用到的技巧

    假设它的三个 GATE 的输入都是线性的，例如对 input-gate 来说，y = a1x1+a2x2+a3x3+a4b。它可以通过令 a4 = -10 来使 input-gate 有一定的阈值。

    LSTM trick

    GRU

    如果发现LSTM过拟合很严重，可以试试这个。

    Gradient vanished

    提到上面的问题顺便提下 Gradient vanished

    是 sigmoid 导致的。因为 sigmoid 的值在 [0, 1] 之间，所以在很深的网络里面会使每次的值越来越小，从而出现 vanished。

    其实，Rough 和 Vanished 本质上都是长距离传输导致的问题。
    ]]>     https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/RNN/ 2017-12-21T03:05:23.000Z Why RNN

    某些任务是需要NN具有记忆的，比如

    • 我 来了 台北
    • 我]]>
    关于RNN的一些问题 2026-08-18T05:18:12.527Z     Junyan Wu view the blog here

    R-squared是描述所训练出来的线性模型和数据的契合程度。

    定义

    R-squared = Explained variation / Total variation

    R-squared是在0-100%之间的百分数

    • 0%表示model不能解释均值附近的数据的变化
    • 100%表示model解释了均值附近所有数据

    通常来说，R-squared的值越高，model与数据的契合度越好（不绝对）。

    ]]>     https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/R_squared/ 2017-12-21T03:05:23.000Z view the blog 2 Fast Approximate Convolutions On Graphs
    • 介绍基于图的神经网络模型 $f(X, A)$ 的理论基础
    • $\tilde{A} = A + I_N$：加了自连接的无向图的邻接矩阵
    • $\tilde{D} = \sum_{j} \tilde{A}_{ij}$：度矩阵
    • $W^{l}$：可训练的权重矩阵
    • $\sigma(\cdot)$：激活函数，如ReLU
    • $H^{(l)} \in R^{N * D}$：matrix of activations in the $l^{th}$ layer; $H^{(0)} = X$

    对于这个propagation rule，论文中提供了一个解释：Weisfeiler-Lehman algorithm，附录里面有解释，下面是原论文

    Boris Weisfeiler and A. A. Lehmann. A reduction of a graph to a canonical form and an algebraarising during this reduction.Nauchno-Technicheskaya Informatsia, 2(9):12–16, 1968.


    2.1 Spectral Graph Convolutions

    Spectral conv on graph定义为信号 $x \in R^{N}$ (每个节点都是一个标量)与filter $g_{\theta} = diag(\theta)$ (在Fourier domain中由 $\theta \in R^{N}$ 参数化的filter)：

    • U：normalized graph Laplacian L 的特征向量矩阵
    • L ：$L = I_N - D^{-\frac{1}{2}} A D^{-\frac{1}{2}} = U \Lambda U^T$

    注：

    这里就有很多问题了。

    1. 首先，上文说 $g_{\theta}$ 是频域中的filter，一个频域的函数与时域的x做卷积？我查的资料没这个说法。
    2. 文中说U是L的特征向量矩阵，是由L得到的（具体看上面L的解释），那么可不可以说，U跟 $g_{\theta}$ 是没有运算关系的？
    3. 文中说$U^T x$是对x的傅里叶变化。所以Laplacian的特征向量矩阵还能做傅里叶变换？是有种变换叫拉普拉斯变换，但是不清楚与拉普拉斯矩阵的联系。

    先把这些问题放一边，按照论文的解释， $g_{\theta}$ 是一个在Fourier domain的对角矩阵，而L的 $\Lambda$ 是它的一个特例。当L化成$U \Lambda U^T$的时候，由于L是时域的，所以$U^T$ 相当于是将其转为频域，$U$ 相当于将其转回时域。由于矩阵乘法满足结合律，所以论文说$U^T x$表示x的傅里叶变换，而$g_{\theta}$ 看作 $g_{\theta}( \Lambda )$。

    (3)式的计算复杂度是 $O(N^2)$ ，太昂贵了，特别是在节点很多的时候计算L的特征值特征向量。下面这篇论文建议用 Chebyshev polynomials 来近似计算 $g_{\theta}( \Lambda )$ ：

    David K. Hammond, Pierre Vandergheynst, and R ́emi Gribonval. Wavelets on graphs via spectralgraph theory.Applied and Computational Harmonic Analysis, 30(2):129–150, 2011.

    那么

    • $\tilde{ \Lambda } = \frac{2}{\lambda_{max}} \Lambda - I_N$，$\lambda_{max}$ 表示L最大的特征值

    • $\theta^{‘} \in R^K$ 是vector of Chebyshev coefficients

    • $T_k(x) = 2 x T_{k-1} - T_{k-2}$，$T_0(x) = 1$，$T_1(x) = x$

    回到(3)式

    • $\tilde{L} = \frac{2}{\lambda_{max}} L - I_N$

    需要注意的事，现在的（5）式是Laplacian的K阶多项式，是K-localized的了。K指的是K steps away from the central node($K^{th}$-order neighborhood)

    (5)式的计算复杂度是$O(|\varepsilon|)$ (linear in the number of edges)

    总结：

    2.1 讲的主要是

    • Spectral conv on graph的定义
    • 如何利用Chebyshev polynomials近似计算(3)式


    2.2 Layer-wise Linear model

    将(5)式叠加，并且“each layer followed by a point-wise non-linearity”， 就形成了基于图卷积的神经网络。现在令K=1，那么函数就变成了关于L的线性函数，即“a linear function on the graph Laplacian spectrum”。

    论文上直观地认为，不去明确限定Chebyshev polynomials的参数可以缓和对图上局部邻居结构的过拟合，这种图有着非常广的节点度分布。(这里省略了一部分内容)

    在这种线性GCN下，近似 $\lambda_{max} \approx 2$，因为我们期望神经网络参数可以在训练中适应这种标量变化。在这种近似下，(5)式变为：

    • filter的参数 $\theta_{0}^{‘}$ 和 $\theta_{1}^{‘}$ 可以在整个graph中共享

    filter以这种形式应用相当于对某个节点的$k^{th}$-order neighborhood做了高效的卷积(k是filtering operation的数量，或者是神经网络模型conv层的数量)

    在实践中，限制参数 的数量可以解决过拟合，并且最小化operation的数量，所以再如下进行简化：

    • $\theta = \theta_{0}^{‘} = - \theta_{1}^{‘}$

    问题是，重复这个operator会导致数值不稳定和梯度爆炸/消失，因此再用一个renormalization trick：$I_N + D^{-\frac{1}{2}} A D^{-\frac{1}{2}} \to \tilde{D}^{-\frac{1}{2}} \tilde{A} \tilde{D}^{-\frac{1}{2}}$，即令$\tilde{A} = A + I_N$，$\tilde{D}_{ii} = \sum_j \tilde{A}_{ij}$

    之前说X是N×1的，我们可以一般化，使$X \in \mathbb{R}^{N \times C}$，C是input channels。于是(7)式化为：

    • $\Theta \in \mathbb{R}^{C \times F}$：filter的参数矩阵
    • $Z \in \mathbb{R}^{N \times F}$：X卷积后的信号矩阵
    • 复杂度：$O(| \varepsilon | FC)$，因为$\tilde{A} X$可以实现为sparse matrix与dense matrix的product。


    3 Semi-Supervised Node Classification

    3.1 Example

    这里，定义两层GCN做图的半监督节点分类，先计算$\hat{A} = \tilde{D}^{-\frac{1}{2}} \tilde{A} \tilde{D}^{-\frac{1}{2}}$，然后有

    • $softmax(x_i) = \frac{1}{sum} exp(x_i)，sum = \sum_i exp(x_i)$。注，softmax是row-wise的

    • $W^{0}，W^{(1)}$ 是通过gradient descent训练得到的，这里用的是batch gradient descent，每次training迭代用的都是整个数据集(需要将dataset放在内存)。

    • Stochasticity in the training process is introduced viadropout (Srivastava et al., 2014). We leave memory-efficient extensions with mini-batch stochasticgradient descent for future work.

    Loss function

    采用cross-entropy

    • $y_L$：有label的节点集


    3.2 Implementation

    在实践中，用Tensorflow来高效地使用GPU计算(Mart ́ın Abadi et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015.)，(9)式使用sparse-dense matrix multiplications，复杂度$O(| \varepsilon | CHF)$


    7 Discussion

    7.1 Semi-Supervised Model

    我们的方法好！很好！非常好！

    基于graph-Laplacian regularization的方法很大可能会因为它的假设——边只编码节点的相似性。另一方面，基于Skip-gram的方法会因为它们是基于难以优化的“multi-step pipeline”而受限。

    我们的renormalized propagation model(8式)效果很好！

    7.2 Limitations And Future work

    • 对内存要求比较高
    • 我们的框架并不天然地支持有向图和边的特征
    • 我们假设self-connection与edges to neighboring nodes的重要性是一样的。对于某些数据集， 会更好。其中 $\lambda$ 可以学习得到。
    ]]> https://junyanwu.github.io/2017/12/21/deeplearning/paper/Semi_Supervised_Classification_With_Graph_Conv_Networks/ 2017-12-21T03:05:23.000Z Sparse matrix

    稀疏矩阵指的是矩阵里面的元素大多都是0值。

    与 sparse 相对的，就是 dense, which most elements of the matrix are nonzero

    矩阵的稀疏性 = zero-valued elements / total number of elements

    Sparse Representation

    Q：稀疏表达有什么好处？

    稀疏表达的意义在于降维，但是我还是不知道这个怎么搞得

    Q：稀疏表达 sparse representation 与 降维 dimensionality reduction 本质区别在哪？

    降维是将原 space 里的数据在某一个 subspace 里面表达，而稀疏表达是在 a union subspace 里面表达。

    举个例子

    (x, y, z)的空间中，(x, y)就是其中一个 subspace 。而 a union subspace 就包含了多个 subspace ，比如[(x, y), (y, z), (z, x)]就是 a union subspace。

    Q：如何求得数据的稀疏矩阵？

    to be continue

    Storing a sparse matrix

    Compressed sparse row(CSR, CRS pr Yale format)

    ```python# dataA = data = (5, 8, 3, 6)# indptr的第一个元素为0，数值表示共有多少非零元素IA = indptr = (0, 0, 2, 3, 4)# 每个data的indexJA = indices = (0, 1, 2, 1)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <script type="math/tex; mode=display">
    MatrixB =
    \begin{pmatrix}
      10 & 20 & 0 & 0 & 0 & 0 \\
      0 & 30 & 0 & 40 & 0 & 0 \\
      0 & 0 & 50 & 60 & 70 & 0 \\
      0 & 0 & 0 & 0 & 0 & 80 \\
    \end{pmatrix}</script>```python
    A = data = (10, 20, 30, 40, 50, 60, 70, 80)
    IA = indptr = (0, 2, 4, 7, 8)
    JA = indices = (0, 1, 1, 3, 2, 3, 4, 5)

    List of list(LIL)

    LIL stores one list per row, with each entry containing the column index and the value. Typically, these entries are kept sorted by column index for faster lookup. This is another format good for incremental matrix construction.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    MatrixA:

    (1, 0) 5
    (1, 1) 8
    (2, 2) 3
    (1, 1) 6

    MatrixB:

    (0, 0) 10
    (0, 1) 20
    (1, 1) 30
    (1, 3) 40
    (2, 2) 50
    (2, 3) 60
    (2, 4) 70
    (3, 5) 80

    例子：这里




    参考:
    https://www.zhihu.com/question/26602796/answer/33431062
    https://www.zhihu.com/question/24124122/answer/50403932
    https://en.wikipedia.org/wiki/Sparse_matrix

    ]]> https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/Sparse_matrix/ 2017-12-21T03:05:23.000Z Sparse matrix

    稀疏矩阵指的是矩阵里面的元素大多都是]]>

    Sparse matrix 2026-08-18T05:18:12.527Z Junyan Wu 　结构

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    def get_unet():
        concat_axis = 3
        inputs = Input((IW, IH, 3))
        conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)
        conv1 = Convolution2D(32, (3, 3), activation='relu', padding='same')(conv1)
        pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
        print('conv1', conv1.shape)
        print('pool1', pool1.shape)

        conv2 = Convolution2D(64, (3, 3), activation='relu', padding='same')(pool1)
        conv2 = Convolution2D(64, (3, 3), activation='relu', padding='same')(conv2)
        pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
        print('conv2', conv2.shape)
        print('pool2', pool2.shape)

        conv3 = Convolution2D(128, (3, 3), activation='relu', padding='same')(pool2)
        print('conv3', conv3.shape)
        conv3 = Convolution2D(128, (3, 3), activation='relu', padding='same')(conv3)
        pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
        print('conv3', conv3.shape)
        print('pool3', pool3.shape)

        conv4 = Convolution2D(256, (3, 3), activation='relu', padding='same')(pool3)
        conv4 = Convolution2D(256, (3, 3), activation='relu', padding='same')(conv4)
        pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
        print('conv4', conv4.shape)
        print('pool4', pool4.shape)

        conv5 = Convolution2D(512, (3, 3), activation='relu', padding='same')(pool4)
        conv5 = Convolution2D(512, (3, 3), activation='relu', padding='same')(conv5)
        print('conv5', conv5.shape)

        USampling6 = UpSampling2D(size=(2, 2))(conv5)
        print('USampling6', USampling6.shape)
        up6 = concatenate([USampling6, conv4], axis=concat_axis)
        conv6 = Convolution2D(256, (3, 3), activation='relu', padding='same')(up6)
        conv6 = Convolution2D(256, (3, 3), activation='relu', padding='same')(conv6)
        print('conv6', conv6.shape)

        USampling7 = UpSampling2D(size=(2, 2))(conv6)
        print('USampling7', USampling7.shape)
        up7 = concatenate([USampling7, conv3], axis=concat_axis)
        conv7 = Convolution2D(128, (3, 3), activation='relu', padding='same')(up7)
        conv7 = Convolution2D(128, (3, 3), activation='relu', padding='same')(conv7)
        print('conv7', conv7.shape)

        USampling8 = UpSampling2D(size=(2, 2))(conv7)
        print('USampling8', USampling8.shape)
        up8 = concatenate([USampling8, conv2], axis=concat_axis)
        conv8 = Convolution2D(64, (3, 3), activation='relu', padding='same')(up8)
        conv8 = Convolution2D(64, (3, 3), activation='relu', padding='same')(conv8)
        print('conv8', conv8.shape)

        USampling9 = UpSampling2D(size=(2, 2))(conv8)
        print('USampling9', USampling9.shape)
        up9 = concatenate([USampling9, conv1], axis=concat_axis)
        conv9 = Convolution2D(32, (3, 3), activation='relu', padding='same')(up9)
        conv9 = Convolution2D(32, (3, 3), activation='relu', padding='same')(conv9)
        print('conv9', conv9.shape)

        conv10 = Convolution2D(N_Cls, (1, 1), activation='sigmoid')(conv9)

        model = Model(input=inputs, output=conv10)
        model.compile(optimizer=Adam(), loss='binary_crossentropy', metrics=[jaccard_coef, jaccard_coef_int, 'accuracy'])
        return model

    注意

    • UNet的结构对输入数据的尺寸是有要求的，我也没搞清楚FCN宣称的对输入图片大小没要求，必须使其在conv、pooling后的W和H都能被2整除，否则后面USampling会出现尺寸不一致的问题。
    • 关于label，必须是(IW, IH, 1)这种格式，不然出错。另外，如果是多类识别，需要用keras.preprocessing.tocate???事先处理，转换成类别vector，或者你的label本来就是1,2,3标记好了的也可以不用转。
    ]]>     https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/UNet/ 2017-12-21T03:05:23.000Z 　结构

     UNet结构及代码 2026-08-18T05:18:12.528Z     Junyan Wu Xavier

    • 此方法用于初始化参数

    • 初始化方法：

      定义参数所在层的input_shape = n，output_shape = m，那么参数将以均匀分布的方式在以下在 $[-\sqrt{\frac{6}{m+n}}, \sqrt{\frac{6}{m+n}}]$ 的范围内进行初始化

    ]]> https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/Xarvier/ 2017-12-21T03:05:23.000Z Xavier

    • 此方法用于初始化参数

    • 初始化方法：

      定义参]]>

    Xavier初始化方法 2026-08-18T05:18:12.526Z Junyan Wu
  • 原文链接

    • 代码解读

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    import theano
    from theano import tensor as T
    from theano.tensor.nnet import conv2d
    import numpy

    rng = numpy.random.RandomState(23455)

    # instantiate 4D tensor for input
    input = T.tensor4(name='input')

    # initialize shared variable for weights.
    w_shp = (2, 3, 9, 9)
    w_bound = numpy.sqrt(3 * 9 * 9)
    W = theano.shared( numpy.asarray(
                rng.uniform(
                    low=-1.0 / w_bound,
                    high=1.0 / w_bound,
                    size=w_shp),
                dtype=input.dtype), name ='W')
    '''
    用uniform初始化
    不知为何定义shape为(2, 3, 9, 9)
    '''


    # initialize shared variable for bias (1D tensor) with random values
    # IMPORTANT: biases are usually initialized to zero. However in this
    # particular application, we simply apply the convolutional layer to
    # an image without learning the parameters. We therefore initialize
    # them to random values to "simulate" learning.
    b_shp = (2,)
    b = theano.shared(numpy.asarray(
                rng.uniform(low=-.5, high=.5, size=b_shp),
                dtype=input.dtype), name ='b')

    # build symbolic expression that computes the convolution of input with filters in w
    conv_out = conv2d(input, W)

    # build symbolic expression to add bias and apply activation function, i.e. produce neural net layer output
    output = T.nnet.sigmoid(conv_out + b.dimshuffle('x', 0, 'x', 'x'))

    # create theano function to compute filtered images
    f = theano.function([input], output)





    import numpy
    import pylab
    from PIL import Image

    # open random image of dimensions 639x516
    '''
    这里要加'rb'，不然报Unicode错，字符不能以utf-8编码，16，32都不行
    '''
    img = Image.open(open('doc/images/3wolfmoon.jpg', 'rb'))
    # dimensions are (height, width, channel)
    img = numpy.asarray(img, dtype='float64') / 256.

    # put image in 4D tensor of shape (1, 3, height, width)
    '''
    这里img.shape = (639, 516, 3)
    img.transpose(2, 0, 1).shape = (3, 639, 516)
    img_.shape = (1, 3, 639, 516)
    reshape将数组变成
    0：1
      0：3
        0：639
          0：516
    这个样子
    初步估计，首先3是图像的RGB，后面的是尺寸。为方便处理，转换成3在前面。
    然后由于input定义为4D的所以要做这个处理。对input的4D分别是：
    > mini-batch size, number of input feature maps, image height, image width
    '''
    img_ = img.transpose(2, 0, 1).reshape(1, 3, 639, 516)
    filtered_img = f(img_)
    '''
    filtered_img.shape(1, 2, 631,508)
    不理解为何处理后变为2
    更新：是由W,b的shape决定的，当改为3，输出也是3
    改为3后如图三所示
    '''
    # plot original image and first and second components of output
    pylab.subplot(1, 3, 1); pylab.axis('off'); pylab.imshow(img)
    '''
    这句的作用是将处理后的结果以灰图显示，若不加如图二
    '''
    pylab.gray();
    # recall that the convOp output (filtered image) is actually a "minibatch",
    # of size 1 here, so we take index 0 in the first dimension:
    pylab.subplot(1, 3, 2); pylab.axis('off'); pylab.imshow(filtered_img[0, 0, :, :])
    pylab.subplot(1, 3, 3); pylab.axis('off'); pylab.imshow(filtered_img[0, 1, :, :])
    pylab.show()

    网站原图

    no_gray

    shape改为3

    ]]>     https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/conv/ 2017-12-21T03:05:23.000Z
  • 原文链接

    • 本代码还有点小问题没解决，应该直接运行会报错，不过不影响理解，时间关系不过于纠结

    This tutorial introduces the LeNet5 neural network architecture
    using Theano. LeNet5 is a convolutional neural network, good for
    classifying images. This tutorial shows how to build the architecture,
    and comes with all the hyper-parameters you need to reproduce the
    paper’s MNIST results.

    This implementation simplifies the model in the following ways:

    • LeNetConvPool doesn’t implement location-specific gain and bias parameters
    • LeNetConvPool doesn’t implement pooling by average, it implements pooling
      by max.
    • Digit classification is implemented with a logistic regression rather than
      an RBF network
    • LeNet5 was not fully-connected convolutions at second layer

    References:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    from __future__ import print_function

    import os
    import sys
    import timeit

    import numpy

    import theano
    import theano.tensor as T
    from theano.tensor.signal import pool
    from theano.tensor.nnet import conv2d

    from code.logistic_sgd import LogisticRegression, load_data
    from code.mlp import HiddenLayer


    class LeNetConvPoolLayer(object):
        def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):
            assert image_shape[1] == filter_shape[1]
            self.input = input

            fan_in = numpy.prod(filter_shape[1:])
            fan_out = (filter_shape[0] * numpy.prod(filter_shape[2:]) //
                       numpy.prod(poolsize))

            # Xarvier初始化方法
            W_bound = numpy.sqrt(6. / (fan_in + fan_out))
            # 均匀分布
            self.W = theano.shared(
                numpy.asarray(
                    rng.uniform(low=-W_bound, high=W_bound, size=filter_shape),
                    dtype=theano.config.floatX
                ),
                borrow=True
            )

            b_values = numpy.zeros((filter_shape[0],), dtype=theano.config.floatX)
            # 一个filter一个b
            self.b = theano.shared(value=b_values, borrow=True)

            conv_out = conv2d(
                input=input,
                filters=self.W,
                filter_shape=filter_shape,
                input_shape=image_shape
            )

            pooled_out = pool.pool_2d(
                input=conv_out,
                ds=poolsize,
                ignore_border=True
            )

            # add the bias term. Since the bias is a vector (1D array), we first
            # reshape it to a tensor of shape (1, n_filters, 1, 1). Each bias will
            # thus be broadcasted across mini-batches and feature map
            # width & height
            self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))

            # store parameters of this layer
            self.params = [self.W, self.b]

            # keep track of model input
            self.input = input


    def evaluate_lenet5(learning_rate=0.1, n_epochs=200,
                        dataset='mnist.pkl.gz',
                        nkerns=[20, 50], batch_size=500):
        rng = numpy.random.RandomState(23455)
        datasets = load_data(dataset)

        train_set_x, train_set_y = datasets[0]
        valid_set_x, valid_set_y = datasets[1]
        test_set_x, test_set_y = datasets[2]
        print('train:', train_set_x.shape, train_set_y.shape)
        print('valid:', valid_set_x.shape, valid_set_y.shape)
        print('test:', test_set_x.shape, test_set_y.shape)

        n_train_batches = train_set_x.get_value(borrow=True).shape[0]
        n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
        n_test_batches = test_set_x.get_value(borrow=True).shape[0]
        # // 除取整，返回商的整数部分
        # 求有几个batch
        n_train_batches //= batch_size
        n_valid_batches //= batch_size
        n_test_batches //= batch_size

        # lscalar是一种TensorType，意思是long scalar，
        # 他们的不同之处是是dtype、ndim、brodcastable
        # http://deeplearning.net/software/theano/library/tensor/basic.html
        index = T.lscalar()

        x = T.matrix('x')
        y = T.ivector('y')

        print('... building the model')

        layer0_input = x.reshape((batch_size, 1, 28, 28))
        layer0 = LeNetConvPoolLayer(
            rng,
            input=layer0_input,
            image_shape=(batch_size, 1, 28, 28),
            filter_shape=(nkerns[0], 1, 5, 5),
            poolsize=(2, 2)
        )

        layer1 = LeNetConvPoolLayer(
            rng,
            # 注意这里，直接就填layer0.output，不用自己算了
            input=layer0.output,
            # 上一层有nkerns[0]个filter
            # 一个image和n个filter得到n张feature map
            # 就相当于一个image被处理出了n个channel
            image_shape=(batch_size, nkerns[0], 12, 12),
            filter_shape=(nkerns[1], nkerns[0], 5, 5),
            poolsize=(2, 2)
        )

        # 被flatten成2D的
        layer2_input = layer1.output.flatten(2)
        layer2 = HiddenLayer(
            rng,
            input=layer2_input,
            n_in=nkerns[1] * 4 * 4,
            n_out=500,
            activation=T.tanh
        )

        layer3 = LogisticRegression(input=layer2_input, n_in=500, n_out=10)

        cost = layer3.negative_log_likelihood(y)

        test_model = theano.function(
            [index],
            layer3.errors(y),
            givens={
                x: test_set_x[index * batch_size: (index + 1) * batch_size],
                y: test_set_y[index * batch_size: (index + 1) * batch_size]
            }
        )

        validate_model = theano.function(
            [index],
            layer3.errors(y),
            givens={
                x: valid_set_x[index * batch_size: (index + 1) * batch_size],
                y: valid_set_y[index * batch_size: (index + 1) * batch_size]
            }
        )

        params = layer3.params + layer2.params + layer1.params + layer0.params
        grads = T.grad(cost, params)

        # 首先grads是已定义的求导运算，在运行时grads包含所有layer所有参数的导数
        # updates的每一个elem都是(param_i, 已使用GD更新的param_i)
        updates = [
            (param_i, param_i - learning_rate * grad_i)
            for param_i, grad_i in zip(params, grads)
        ]

        # 它是一条数据一条数据地训练的...
        train_model = theano.function(
            [index],
            cost,
            updates=updates,
            givens={
                x: train_set_x[index * batch_size: (index + 1) * batch_size],
                y: train_set_y[index * batch_size: (index + 1) * batch_size]
            }
        )

        print('... training')
        patience = 10000
        patience_increase = 2
        improvement_threshold = 0.995
        validation_frequency = min(n_train_batches, patience // 2)

        # inf = infinite 无穷大
        best_validation_loss = numpy.inf
        best_iter = 0
        test_score = 0.
        start_time = timeit.default_timer

        epoch = 0
        done_looping = False
        # 设置训练的终止条件
        while (epoch < n_epochs) and (not done_looping):
            epoch = epoch + 1
            # 每个batch一次
            for minibatch_index in range(n_train_batches):
                # iter是目前遍历到第几组数据
                iter = (epoch - 1) * n_train_batches + minibatch_index

                if iter % 100 == 0:
                    print('training @ iter = ', iter)
                # minibatch_index是训练到目前batch中的第几个
                # train_model输出的是cost
                cost_ij = train_model(minibatch_index)
                # 如果一个epoch完了
                if (iter + 1) % validation_frequency == 0:

                    # compute zero-one loss on validation set
                    # 将每个batch的val_loss加起来求mean
                    validation_losses = [validate_model(i) for i
                                         in range(n_valid_batches)]
                    this_validation_loss = numpy.mean(validation_losses)
                    print('epoch %i, minibatch %i/%i, validation error %f %%' %
                          (epoch, minibatch_index + 1, n_train_batches,
                           this_validation_loss * 100.))

                    # if we got the best validation score until now
                    if this_validation_loss < best_validation_loss:

                        # improve patience if loss improvement is good enough
                        if this_validation_loss < best_validation_loss * \
                                improvement_threshold:
                            # 如果val_loss还有提高的话，就把patience设大一些
                            patience = max(patience, iter * patience_increase)

                        # save best validation score and iteration number
                        best_validation_loss = this_validation_loss
                        best_iter = iter

                        # test it on the test set
                        test_losses = [
                            test_model(i)
                            for i in range(n_test_batches)
                        ]
                        test_score = numpy.mean(test_losses)
                        print(('     epoch %i, minibatch %i/%i, test error of '
                               'best model %f %%') %
                              (epoch, minibatch_index + 1, n_train_batches,
                               test_score * 100.))

                if patience <= iter:
                    done_looping = True
                    break

        end_time = timeit.default_timer()
        print('Optimization complete.')
        print('Best validation score of %f %% obtained at iteration %i, '
              'with test performance %f %%' %
              (best_validation_loss * 100., best_iter + 1, test_score * 100.))
        print(('The code for file ' +
               os.path.split(__file__)[1] +
               ' ran for %.2fm' % ((end_time - start_time) / 60.)), file=sys.stderr)


    if __name__ == '__main__':
        evaluate_lenet5()


    def experiment(state, channel):
        evaluate_lenet5(state.learning_rate, dataset=state.dataset)
    ]]> https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/convolutional_mlp/ 2017-12-21T03:05:23.000Z

    本代码还有点小问题没解决，应该直接运行会报错，不过不影响理解，时间关系不过于纠结

    This tutorial introduces the LeNet5 neural network architectur]]>

    LeNet代码走读 2026-08-18T05:18:12.528Z Junyan Wu 实质

    经过一番推算，其tc前后的shape的计算方式是conv求输出size的逆运算

    从1式

    到2式

    　注意

    • 2式中，S和K值相同，而2*2的kernal size，K=2，这点和conv不一样。
    • 有一个巨坑！若keras中的conv的padding=’same’，函数会填充使得输入输出尺寸相同！

    结合UNet

    UNet的结构对输入数据的尺寸是有要求的，必须使其在conv、pooling后的W和H都能被2整除，否则后面USampling会出现尺寸不一致的问题。

    ]]> https://junyanwu.github.io/2017/12/21/deeplearning/%E7%A6%BB%E6%95%A3%E7%9A%84%E7%AC%94%E8%AE%B0/transposed_convolution/ 2017-12-21T03:05:23.000Z 实质

    经过一番推算，其tc前后的shape的计算方式是conv求输出size的逆运算

    从1式