Glorot初始化theano

在Theano中，Glorot初始化可以通过以下方式实现：

import numpy as np
import theano.tensor as T

def init_weights_Glorot(shape):
    # Glorot initialization
    fan_in = shape[0]
    fan_out = shape[1]
    s = np.sqrt(2.0/(fan_in + fan_out))
    return np.random.normal(loc=0.0, scale=s, size=shape).astype(np.float32)

# 使用示例
input_shape = (100, 200)
output_shape = (200, 300)
W = theano.shared(init_weights_Glorot(input_shape))
U = theano.shared(init_weights_Glorot(output_shape))

在Glorot初始化中，权重的标准差$s$由输入层的神经元数和输出层神经元数的平均值决定。然后，权重初始化为从均值为0和标准差为$s$的正态分布中随机采样得出的值。以上代码中的init_weights_Glorot函数实现了这个过程，返回指定形状的Glorot初始化权重。

在使用时，可以通过调用init_weights_Glorot来初始化权重，然后使用Theano的shared函数将其转换为共享变量，以便在模型中进行训练。

相关问题

使用theano的Glorot初始化搭建3DResNet网络

首先，要使用Theano框架构建3D ResNet网络，需要导入以下库：

import theano
import theano.tensor as T
import numpy as np

接下来，我们需要定义一些辅助函数来构建ResNet网络。首先，定义一个函数，用于构建卷积层：

def conv3d(input, filters, filter_size, stride=(1, 1, 1), pad='valid', name=None):
    if pad == 'valid':
        pad = (0, 0, 0)
    elif pad == 'same':
        pad = ((filter_size[0]-1)//2, (filter_size[1]-1)//2, (filter_size[2]-1)//2)
    W = theano.shared(
        np.random.uniform(low=-np.sqrt(6./(np.prod(filters)+filters[-1])), high=np.sqrt(6./(np.prod(filters)+filters[-1])), size=(filters[0], filters[1], filters[2], input.shape[1], filters[3])),
        name=name+'_W', borrow=True)
    b = theano.shared(np.zeros((filters[3],), dtype=theano.config.floatX), name=name+'_b', borrow=True)
    conv_out = T.nnet.conv3d(input, W, border_mode=pad, subsample=stride)
    return T.nnet.relu(conv_out + b.dimshuffle('x', 0, 'x', 'x', 'x'))

这个函数将会返回一个卷积层的输出，其中包含了ReLU激活函数。我们需要传入输入数据、卷积核的大小、stride、padding信息以及卷积层的名称。

接下来，我们需要定义一个函数，用于构建ResNet网络的残差块：

def residual_block(input, filters, stride=(1, 1, 1), name=None):
    conv1 = conv3d(input, filters, (1, 1, 1), stride=stride, pad='same', name=name+'_conv1')
    conv2 = conv3d(conv1, filters, (3, 3, 3), stride=(1, 1, 1), pad='same', name=name+'_conv2')
    conv3 = conv3d(conv2, filters*4, (1, 1, 1), stride=(1, 1, 1), pad='same', name=name+'_conv3')
    if stride == (1, 1, 1):
        shortcut = input
    else:
        shortcut = conv3d(input, filters*4, (1, 1, 1), stride=stride, pad='same', name=name+'_shortcut')
    return T.nnet.relu(conv3 + shortcut)

这个函数将会返回一个残差块的输出，其中包含了ReLU激活函数。我们需要传入输入数据、卷积核的大小、stride以及残差块的名称。

接下来，我们可以开始构建3D ResNet网络。我们需要定义一个函数，用于构建3D ResNet网络：

def build_3dresnet(input_shape, num_filters, num_blocks, num_classes):
    input = T.tensor5('input')
    conv1 = conv3d(input, (3, 3, 3, input_shape[0], num_filters), (7, 7, 7), stride=(2, 2, 2), pad='same', name='conv1')
    pool1 = T.signal.pool.pool_3d(conv1, (3, 3, 3), ignore_border=True, st=stride, padding=(1, 1, 1), mode='max')
    res = pool1
    filters = num_filters
    for i in range(num_blocks):
        res = residual_block(res, filters, stride=(1, 1, 1), name='res'+str(i+1)+'_a')
        for j in range(1, 3):
            res = residual_block(res, filters, name='res'+str(i+1)+'_b'+str(j))
        filters *= 2
    pool2 = T.signal.pool.pool_3d(res, (res.shape[2], res.shape[3], res.shape[4]), ignore_border=True, st=(1, 1, 1), padding=(0, 0, 0), mode='max')
    flatten = T.flatten(pool2, outdim=2)
    fc = T.nnet.softmax(T.dot(flatten, np.random.uniform(low=-np.sqrt(6./(flatten.shape[1]+num_classes)), high=np.sqrt(6./(flatten.shape[1]+num_classes)), size=(flatten.shape[1], num_classes))))
    return theano.function(inputs=[input], outputs=fc)

这个函数将会返回一个Theano函数，用于计算模型的输出。我们需要传入输入的shape、卷积层的数量、残差块的数量以及分类的数量。

最后，我们可以使用以下代码来构建模型并进行训练：

input_shape = (3, 16, 112, 112)
num_filters = 64
num_blocks = [3, 4, 6, 3]
num_classes = 101

model = build_3dresnet(input_shape, num_filters, num_blocks, num_classes)

# 进行训练和测试

theano初始化VGG网络的参数

要初始化VGG网络的参数，可以按照以下步骤：

1. 导入必要的库和模块：

   import numpy as np
   import theano
   import theano.tensor as T
   import lasagne

2. 定义VGG网络的结构，可以参考如下代码：

   def build_model(input_var=None):
       network = lasagne.layers.InputLayer(shape=(None, 3, 224, 224), input_var=input_var)
       network = lasagne.layers.Conv2DLayer(network, num_filters=64, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=64, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2), stride=2)
       network = lasagne.layers.Conv2DLayer(network, num_filters=128, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=128, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2), stride=2)
       network = lasagne.layers.Conv2DLayer(network, num_filters=256, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=256, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=256, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2), stride=2)
       network = lasagne.layers.Conv2DLayer(network, num_filters=512, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=512, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=512, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2), stride=2)
       network = lasagne.layers.Conv2DLayer(network, num_filters=512, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=512, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.Conv2DLayer(network, num_filters=512, filter_size=(3, 3), stride=1, pad=1, nonlinearity=lasagne.nonlinearities.rectify, W=lasagne.init.GlorotUniform())
       network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2), stride=2)
       return network

这里定义了一个包含13个卷积层和5个最大池化层的VGG网络，每个卷积层都使用了GlorotUniform初始化方法。

3. 加载预训练的权重文件：

   def load_weights():
       # Load the pre-trained weights
       url = 'https://s3.amazonaws.com/lasagne/recipes/pretrained/imagenet/vgg19_normalized.pkl'
       filename = 'vgg19_normalized.pkl'
       if not os.path.exists(filename):
           urllib.urlretrieve(url, filename)
       with open(filename, 'rb') as f:
           model = pickle.load(f)
       return model['param values']

这里使用了pickle库来加载预训练的权重文件，并返回其中的参数值。

4. 初始化参数：

   input_var = T.tensor4('inputs')
   target_var = T.ivector('targets')
   network = build_model(input_var)
   weights = load_weights()
   lasagne.layers.set_all_param_values(network, weights)

这里首先定义了输入和目标变量，然后调用了前面定义的build_model函数来构建VGG网络，接着调用load_weights函数加载预训练的权重文件，并使用lasagne.layers.set_all_param_values函数将参数值设置到网络中。

5. 编译模型：

   prediction = lasagne.layers.get_output(network)
   loss = lasagne.objectives.categorical_crossentropy(prediction, target_var)
   loss = loss.mean()
   params = lasagne.layers.get_all_params(network, trainable=True)
   updates = lasagne.updates.momentum(loss, params, learning_rate=0.01, momentum=0.9)
   train_fn = theano.function([input_var, target_var], loss, updates=updates)

这里首先定义了预测值和损失函数，然后使用lasagne.layers.get_all_params函数获取所有可训练的参数，接着使用lasagne.updates.momentum函数定义更新规则，最后使用theano.function函数编译模型。

现在，我们就完成了VGG网络参数的初始化。