云端FFF
云端FFF

Pytorch入门（3）—— 构造网络模型

  • 参考：动手学深度学习
  • 注意：由于本文是jupyter文档转换来的，代码不一定可以直接运行，有些注释是jupyter给出的交互结果，而非运行结果!!

文章目录

  • 1. 模型构造
    • 1.1 继承 `Module` 类来构造模型
    • 1.2 `Module` 的子类
      • 1.2.1 `Sequential` 类
      • 1.2.2 `ModuleList` 类
      • 1.2.3 `ModuleDict` 类
    • 1.3 构造复杂模型
  • 2. 模型参数的访问、初始化和共享
    • 2.1 访问模型参数
    • 2.2 初始化模型参数
      • 2.2.1 使用 pytorch 自带的初始化方法
      • 2.2.2 自定义初始化方法
    • 2.3 共享模型参数
  • 3. 自定义层
    • 3.1 不含模型参数的自定义层
    • 3.2 含模型参数的自定义层

1. 模型构造

  • pytorch 没有特别明显地区别 Layer 和 Module 的区别，不管是自定义层、自定义块还是自定义模型，都通过 nn.Module 类实现，它是所有神经网络模块的基类
  • 构造模型时一般有两种选择
    1. 对于简单的模型，直接使用 pytorch 提供的 nn.Module 子类进行构造，比如 Sequential、ModuleList 和 ModuleDict 等等
    2. 对于复杂模型，自己继承 nn.Module，再重新实现构造函数 __init__（定义需要学习的层） 和 forward 方法（定义网络结构），pytorch 会通过自动求梯度功能自动生成反向传播所需的 backward 函数

1.1 继承 Module 类来构造模型

  • 这里构造一个用于 Fashion-MNIST 分类的，含单隐藏层的多层感知机，它的输入尺寸为图像尺寸 28 ∗ 28 = 784 28*28=784 28∗28=784，类别总数为 10，有两个全连接层

    1. 隐藏层，输出大小为256（即隐藏单元个数是256）
    2. 输出层，输出大小为10（即输出层单元个数是10）
    import torch
from torch import nn

class MLP(nn.Module):
    # 声明带有模型参数的层，这里声明了两个全连接层
    def __init__(self, **kwargs):
        super(MLP, self).__init__(**kwargs)
        
        self.hidden = nn.Linear(784, 256) # 隐藏层
        self.act = nn.ReLU()              # 激活函数层
        self.output = nn.Linear(256, 10)  # 输出层

    # 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出
    def forward(self, x):
        x = self.hidden(x)
        x = self.act(x)    # 可以换成 torch.nn.functional.relu(x)
        x = self.output(x)
        return x

    实例化 MLP 类得到模型变量 net，直接 net(X) 就会调用 MLP 继承自 Module 类的 __call__ 函数，这个函数将调用 MLP 类定义的 forward 函数来完成前向计算

    X = torch.rand(2, 784)
net = MLP()
print(net)
net(X)

    MLP(
  (hidden): Linear(in_features=784, out_features=256, bias=True)
  (act): ReLU()
  (output): Linear(in_features=256, out_features=10, bias=True)
)
tensor([[-0.1948, -0.1288,  0.2227,  0.0308,  0.1528, -0.1716,  0.1353, -0.1180,
          0.0011,  0.0678],
        [-0.1717,  0.0203,  0.2850,  0.0811,  0.1573, -0.1836,  0.1892, -0.0589,
         -0.0782,  0.0492]], grad_fn=)

  • 重写 __init__ 和 forward 函数的一些技巧

    1. __init__ 传入 **kwargs 参数用来初始化父类 nn.Module，这样在构造实例时还可以指定其他函数参数
    2. 有可学习参数的层（如全连接层、卷积层等）通常放在 __init__
    3. 没有可学习参数的层（如激活函数、dropout、BatchNormanation层）可以放在 __init__ 中，也可以在 forward 方法里用 nn.functional 代替

1.2 Module 的子类

1.2.1 Sequential 类

  • Sequential 接收一个 “子模块的有序字典（OrderedDict）”或者“一系列子模块”作为参数来逐一添加 Module 的实例，得到模型的 forward 方法将这些实例按添加的顺序逐一计算，适用于模型的前向计算为简单串联各个层的计算的情况

  • Sequential 中的每个层都是 Module 实例，可以用类似列表的 [] 索引其中的某层，然后也可以类似上面访问其中参数

    net = nn.Sequential(
        nn.Linear(784, 256),
        nn.ReLU(),
        nn.Linear(256, 10), 
        )
print(net)
print(net(X))
print(net[0](X))

    Sequential(
  (0): Linear(in_features=784, out_features=256, bias=True)
  (1): ReLU()
  (2): Linear(in_features=256, out_features=10, bias=True)
)
tensor([[ 0.0496,  0.2121,  0.1022, -0.0463,  0.0296, -0.0083, -0.2182,  0.0396,
         -0.2485,  0.0137],
        [ 0.0525,  0.1603,  0.1662, -0.0540, -0.0024,  0.0356, -0.2116,  0.0876,
         -0.1516,  0.0286]], grad_fn=)
tensor([[-8.9254e-01, -1.7184e-01,  1.4419e-01,  1.8471e-01,  4.9481e-01,
     -2.2077e-01,  2.9778e-01, -2.6250e-01,  8.2950e-02,  1.9320e-01,
      2.0345e-01, -3.2230e-01,  3.6647e-01, -4.5688e-01, -2.6230e-01,
     -3.6204e-01, -5.2217e-01, -3.0493e-01, -2.5337e-01,  2.0549e-01,
      2.0917e-01,  4.2038e-01, -2.3459e-01, -2.9938e-01, -1.3072e-01,
      ...

  • 下面利用 1.1 节继承 Module 的方法手动模拟 Sequential 类

    from collections import OrderedDict

class MySequential(nn.Module):
    def __init__(self, *args):
        super(MySequential, self).__init__()
        # 如果传入的是一个OrderedDict
        if len(args) == 1 and isinstance(args[0], OrderedDict): 
            for key, module in args[0].items():
                self.add_module(key, module)  # add_module 方法会将 module 添加进 self._modules (一个OrderedDict)
        # 传入的是一些 Module
        else:  
            for idx, module in enumerate(args):
                self.add_module(str(idx), module)
                
    def forward(self, input):
        # self._modules 返回一个 OrderedDict，保证会按照成员添加时的顺序遍历成员
        for module in self._modules.values():
            input = module(input)
        return input

net = MySequential(
        nn.Linear(784, 256),
        nn.ReLU(),
        nn.Linear(256, 10), 
        )
print(net)      # 观察网络结构
print(net(X))   # 做一次前向传播

    MySequential(
  (0): Linear(in_features=784, out_features=256, bias=True)
  (1): ReLU()
  (2): Linear(in_features=256, out_features=10, bias=True)
)
tensor([[ 0.1127, -0.1448,  0.0931, -0.0545, -0.1346, -0.0632, -0.1710,  0.0960,
          0.0854,  0.0366],
        [ 0.1646, -0.1410,  0.0664, -0.1529, -0.1392, -0.0145, -0.2894,  0.0927,
          0.1357,  0.0438]], grad_fn=)

1.2.2 ModuleList 类

  • ModuleList 接收一个子模块的列表作为输入，可以类似 python List 那样进行 append 和 extend 操作，它的出现主要是为了让网络定义 forward 时更加灵活，见下面官网的例子

    class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])

    def forward(self, x):
        # ModuleList can act as an iterable, or be indexed using ints
        for i, l in enumerate(self.linears):
            x = self.linears[i // 2](x) + l(x)
        return x

  • ModuleList 的特点有

    1. 仅仅是一个储存各种模块的列表，这些模块之间没有联系也没有顺序（所以不用保证相邻层的输入输出维度匹配），这和 Sequential 类不同
    2. 没有实现 forward 功能，需要自己实现（直接执行会报 NotImplementedError）
      net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])  # 输入为模块列表
net.append(nn.Linear(256, 10))  # 类似List的append操作
print(net[-1])                  # 类似List的索引访问

print(net)
# net(torch.zeros(1, 784))      # 没有实现 forward，做 forward 时报 NotImplementedError

      Linear(in_features=256, out_features=10, bias=True)
ModuleList(
  (0): Linear(in_features=784, out_features=256, bias=True)
  (1): ReLU()
  (2): Linear(in_features=256, out_features=10, bias=True)
)
    3. 不同于Python 内置 list，加入到 ModuleList 里面的所有模块的参数会被自动添加到整个网络中
      class Module_ModuleList(nn.Module):
    def __init__(self):
        super(Module_ModuleList, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10)])

class Module_List(nn.Module):
    def __init__(self):
        super(Module_List, self).__init__()
        self.linears = [nn.Linear(10, 10)]

net1 = Module_ModuleList()
net2 = Module_List()

# 加入到 ModuleList 里面的所有模块的参数被添加到 Module 实例中了
print("net1:")
for p in net1.parameters():
    print(p.size())

# 加入 python list 中的模块的参数没有添加到 Module 实例中
print("net2:")
for p in net2.parameters():
    print(p)

      net1:
torch.Size([10, 10])
torch.Size([10])
net2:

      Note：对得到的 Module 类实例调用 .parameters() 方法，这会返回一个生成器，可以按顺序查看网络的参数（同一层先返回 weight 再返回 bias）。详见下面 2.1 节

1.2.3 ModuleDict 类

  • ModuleDict 也是为了让网络定义 forward 时更加灵活而出现的，它接受一个子模块的字典作为输入，可以类似 python Dict 那样进行添加访问操作
  • ModuleDict 的特点有

    1. ModuleDict 实例也是仅仅存放了一个模块的字典，这些模块之间没有联系也没有顺序

    2. 不会自动生成 forward 方法，需要自己定义（直接执行会报 NotImplementedError）

      net = nn.ModuleDict({
    'linear': nn.Linear(784, 256),
    'act': nn.ReLU(),
})

net['output'] = nn.Linear(256, 10) # 类似 python Dict 进行添加
print(net['linear'])               # 类型 python Dict 进行访问
print(net.output)                  # 另一种访问 key 'output' 的方法

print(net)
# net(torch.zeros(1, 784)) # 报NotImplementedError

      Linear(in_features=784, out_features=256, bias=True)
Linear(in_features=256, out_features=10, bias=True)
ModuleDict(
  (linear): Linear(in_features=784, out_features=256, bias=True)
  (act): ReLU()
  (output): Linear(in_features=256, out_features=10, bias=True)
)

    3. 加入到 ModuleDict 里面的所有模块的参数会被自动添加到整个网络中，python 内置的 Dict 不会

1.3 构造复杂模型

  • 本节通过继承 Module 类构造一个复杂网络 FancyMLP。其中

    1. 通过 requires_grad=False 创建训练中不被迭代的参数（i.e. 常数参数）
    2. 使用 Tensor 的函数和 Python 控制流多次调用相同的层
    class FancyMLP(nn.Module):
    def __init__(self, **kwargs):
        super(FancyMLP, self).__init__(**kwargs)

        self.rand_weight = torch.rand((20, 20), requires_grad=False) # 不可训练参数（常数参数）
        self.linear = nn.Linear(20, 20)                              # 这个线性层参数会被训练

    def forward(self, x):
        x = self.linear(x)
        
        # 使用创建的常数参数，以及 nn.functional.relu 和 mm 函数
        x = torch.mm(x, self.rand_weight.data) + 1   # +1 用广播作用到每个元素上
        x = nn.functional.relu(x)

        # 复用全连接层。等价于两个全连接层共享参数
        x = self.linear(x)
        
        # 控制流，这里先用 .norm 得到向量的模，再用 .item 来返回标量进行比较
        while x.norm().item() > 1:
            x /= 2
        if x.norm().item() < 0.8:
            x *= 10
        return x.sum()

# 打印网络结构，做一次前向传播
X = torch.rand(2, 20)
net = FancyMLP()
print(net)
net(X)

    FancyMLP(
  (linear): Linear(in_features=20, out_features=20, bias=True)
)
tensor(-0.0572, grad_fn=)

  • 这里定义的 FancyMLP 作为 Module 的子类，可以进一步和 Sequential 等嵌套使用

    class NestMLP(nn.Module):
    def __init__(self, **kwargs):
        super(NestMLP, self).__init__(**kwargs)
        self.net = nn.Sequential(nn.Linear(40, 30), nn.ReLU()) 

    def forward(self, x):
        return self.net(x) # 在自定义 Module 中嵌套使用 Sequential

net = nn.Sequential(NestMLP(), nn.Linear(30, 20), FancyMLP()) # 在 Sequential 中嵌套使用自定义 Module

X = torch.rand(2, 40)
print(net)
net(X)

    Sequential(
  (0): NestMLP(
    (net): Sequential(
      (0): Linear(in_features=40, out_features=30, bias=True)
      (1): ReLU()
    )
  )
  (1): Linear(in_features=30, out_features=20, bias=True)
  (2): FancyMLP(
    (linear): Linear(in_features=20, out_features=20, bias=True)
  )
)
tensor(-0.4674, grad_fn=)

2. 模型参数的访问、初始化和共享

  • 先定义一个含单隐藏层的多层感知机，使用默认方式初始化它的参数，并做一次前向计算（jupyter 文档，后面会用到这里定义的 X,Y,net 等变量）
    import torch
from torch import nn

net = nn.Sequential(nn.Linear(4, 3), nn.ReLU(), nn.Linear(3, 1))  # pytorch已进行默认初始化

print(net)
X = torch.rand(2, 4)
Y = net(X).sum()

    Sequential(
  (0): Linear(in_features=4, out_features=3, bias=True)
  (1): ReLU()
  (2): Linear(in_features=3, out_features=1, bias=True)
)
    该网络结构如下所示
    Pytorch入门（3）—— 构造网络模型_第1张图片

2.1 访问模型参数

  • 在 1.2.1 节已经提到过，可以对 Module 实例调用 .parameters 方法得到一个模型参数的生成器，除此以外，还可以调用 .named_parameters 方法得到一个带名字（含层数前缀）的参数生成器，如下

    print(type(net.parameters()))
for param in net.parameters():
    print(param.size())

print('\n', type(net.named_parameters()))
for name, param in net.named_parameters():
    print(name, param.size())

    
torch.Size([3, 4])
torch.Size([3])
torch.Size([1, 3])
torch.Size([1])

 
0.weight torch.Size([3, 4])
0.bias torch.Size([3])
2.weight torch.Size([1, 3])
2.bias torch.Size([1])

  • pytorch 不区分层和模型，用 [] 索引出 Sequential 中的某层，也可以类似上面访问其中参数

    for name, param in net[0].named_parameters():
    print(name, param.size(), type(param))

    weight torch.Size([3, 4]) 
bias torch.Size([3])

    观察输出可见

    1. 只有一个层，参数名字中没有层数索引前缀了
    2. 返回的 param 类型为 torch.nn.parameter.Parameter，这其实这是 Tensor 的子类，如果一个 Tensor 是 Parameter，那么它会自动被添加到模型的参数列表里
      class MyModel(nn.Module):
    def __init__(self, **kwargs):
        super(MyModel, self).__init__(**kwargs)
        self.weight1 = nn.Parameter(torch.rand(20, 20)) # 直接定义成 Parameter 实例，自动加入模型参数列表
        self.weight2 = torch.rand(20, 20)               # 普通 Tensor 实例不会加入模型参数列表
    def forward(self, x):
        pass

n = MyModel()
for name, param in n.named_parameters():
    print(name) # 只打印 weight1

  • Parameter 本质是 Tensor，可以做 Tensor 能做的任何操作，比如用 .data 访问参数值，用 .grad 访问参数梯度等

    # 这里 net 是第2节最开始的多层感知机
weight_0 = list(net[0].parameters())[0] # 拿出第一层的 weight Parameter

print(weight_0.data) # 访问参数值
print(weight_0.grad) # 反向传播前梯度为 None
Y.backward()         # 对 net 进行反向传播
print(weight_0.grad) # 查看反向传播后梯度

    tensor([[-0.2071, -0.3790, -0.3439, -0.1824],
        [-0.0715, -0.0847, -0.2867,  0.0100],
        [ 0.0529,  0.3474,  0.2165,  0.3396]])
None
tensor([[ 0.0000,  0.0000,  0.0000,  0.0000],
        [ 0.0000,  0.0000,  0.0000,  0.0000],
        [-0.1004, -0.1238, -0.0492, -0.0901]])

2.2 初始化模型参数

  • 模型参数初始化是很重要的一件事，考虑第2节最初的含一个隐藏层的神经网络，假设将每个隐藏单元的参数都初始化为相等的值，由于各个单元的激活函数也一致，那么

    1. 正向传播时每个隐藏单元计算并输出的值都相等
    2. 反向传播时每个隐藏单元的参数梯度值相等，因此这些参数在使用基于梯度的优化算法迭代后值依然相等。之后的迭代也是如此

    可见这种情况下，无论隐藏单元有多少，隐藏层本质上只有1个隐藏单元在发挥作用。因此我们通常将神经网络的模型参数，特别是权重参数，进行随机初始化。

  • pytorch nn.Module 中的模块参数都采取了较为合理的初始化策略，所以其实不考虑初始化问题也是可以的（不同类型的 layer 具体的初始化方式也不同，可以参考源码）。如果一定要用其他方式初始化参数，也有两种途径

2.2.1 使用 pytorch 自带的初始化方法

  • torch.nn.init 模块里提供了多种预设初始化方法，以下代码来自 Pytorch - nn.init 参数初始化方法

    import torch
import torch.nn as nn
from torch.nn import init

w = torch.empty(2, 3)

# 1. 均匀分布 - u(a,b)
# torch.nn.init.uniform_(tensor, a=0, b=1)
nn.init.uniform_(w)
# tensor([[ 0.0578,  0.3402,  0.5034],
#         [ 0.7865,  0.7280,  0.6269]])

# 2. 正态分布 - N(mean, std)
# torch.nn.init.normal_(tensor, mean=0, std=1)
nn.init.normal_(w)
# tensor([[ 0.3326,  0.0171, -0.6745],
#        [ 0.1669,  0.1747,  0.0472]])

# 3. 常数 - 固定值 val
# torch.nn.init.constant_(tensor, val)
nn.init.constant_(w, 0.3)
# tensor([[ 0.3000,  0.3000,  0.3000],
#         [ 0.3000,  0.3000,  0.3000]])

# 4. 对角线为 1，其它为 0
# torch.nn.init.eye_(tensor)
nn.init.eye_(w)
# tensor([[ 1.,  0.,  0.],
#         [ 0.,  1.,  0.]])

# 5. Dirac delta 函数初始化，仅适用于 {3, 4, 5}-维的 torch.Tensor
# torch.nn.init.dirac_(tensor)
w1 = torch.empty(3, 16, 5, 5)
nn.init.dirac_(w1)

# 6. xavier_uniform 初始化
# torch.nn.init.xavier_uniform_(tensor, gain=1)
# From - Understanding the difficulty of training deep feedforward neural networks - Bengio 2010
nn.init.xavier_uniform_(w, gain=nn.init.calculate_gain('relu'))
# tensor([[ 1.3374,  0.7932, -0.0891],
#         [-1.3363, -0.0206, -0.9346]])

# 7. xavier_normal 初始化
# torch.nn.init.xavier_normal_(tensor, gain=1)
nn.init.xavier_normal_(w)
# tensor([[-0.1777,  0.6740,  0.1139],
#         [ 0.3018, -0.2443,  0.6824]])

# 8. kaiming_uniform 初始化
# From - Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification - HeKaiming 2015
# torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')
nn.init.kaiming_uniform_(w, mode='fan_in', nonlinearity='relu')
# tensor([[ 0.6426, -0.9582, -1.1783],
#         [-0.0515, -0.4975,  1.3237]])

# 9. kaiming_normal 初始化
# torch.nn.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')
nn.init.kaiming_normal_(w, mode='fan_out', nonlinearity='relu')
# tensor([[ 0.2530, -0.4382,  1.5995],
#         [ 0.0544,  1.6392, -2.0752]])

# 10. 正交矩阵 - (semi)orthogonal matrix
# From - Exact solutions to the nonlinear dynamics of learning in deep linear neural networks - Saxe 2013
# torch.nn.init.orthogonal_(tensor, gain=1)
nn.init.orthogonal_(w)
# tensor([[ 0.5786, -0.5642, -0.5890],
#         [-0.7517, -0.0886, -0.6536]])

# 11. 稀疏矩阵 - sparse matrix 
# 非零元素采用正态分布 N(0, 0.01) 初始化.
# From - Deep learning via Hessian-free optimization - Martens 2010
# torch.nn.init.sparse_(tensor, sparsity, std=0.01)
nn.init.sparse_(w, sparsity=0.1)
# tensor(1.00000e-03 *
#        [[-0.3382,  1.9501, -1.7761],
#         [ 0.0000,  0.0000,  0.0000]])

  • 下面将权重参数初始化成服从 N ( 0 , 0.0 1 2 ) N(0,0.01^2) N(0,0.012) 的随机数，将偏置初始化为常数

    for name, param in net.named_parameters():
    if 'weight' in name:
        init.normal_(param, mean=0, std=0.01)
        print(name, param.data)
    if 'bias' in name:
        init.constant_(param, val=0)
        print(name, param.data)

    0.weight tensor([[-0.0171, -0.0112,  0.0001, -0.0026],
        [ 0.0006,  0.0125, -0.0181,  0.0049],
        [-0.0083, -0.0032, -0.0037,  0.0103]])
0.bias tensor([0., 0., 0.])
2.weight tensor([[ 0.0071, -0.0074, -0.0086]])
2.bias tensor([0.])

2.2.2 自定义初始化方法

  • 如果我们需要的初始化方法没有在 init 模块中提供，可以自己手动实现一个初始化方法，从而能够像使用其他初始化方法那样使用它

  • 我们先来看看 PyTorch 是怎么实现内置初始化方法的，例如 torch.nn.init.normal_

    def normal_(tensor, mean=0, std=1):
    with torch.no_grad():
        return tensor.normal_(mean, std)

    可以看到这就是一个 inplace 改变 Tensor 值的函数，而且这个过程是不记录梯度的。 我们可以类似地实现一个自定义初始化方法。下面我们令权重有一半概率初始化为 0，有另一半概率初始化为 [ − 10 , − 5 ] [−10,−5] [−10,−5] 和 [ 5 , 10 ] [5,10] [5,10] 两个区间里均匀分布的随机数

    def init_weight_(tensor):
    with torch.no_grad():
        tensor.uniform_(-10, 10)
        tensor *= (tensor.abs() >= 5).float()

for name, param in net.named_parameters():
    if 'weight' in name:
        init_weight_(param)
        print(name, param.data)

    0.weight tensor([[ 0.0000,  0.0000,  0.0000, -0.0000],
        [-5.3037,  9.3310,  0.0000,  0.0000],
        [ 0.0000,  7.8593, -0.0000,  0.0000]])
2.weight tensor([[-6.5195,  0.0000,  0.0000]])

  • 另外考虑到 Parameter 本质是 Tensor，我们还可以通过改变这些参数的 .data，在不影响梯度的情况下改写模型参数值

    for name, param in net.named_parameters():
    if 'bias' in name:
        param.data += 1
        print(name, param.data)

    0.bias tensor([1., 1., 1.])
2.bias tensor([1.])

2.3 共享模型参数

  • 有时我们想在多个层之间共享参数，因为模型参数里包含了梯度，所以在反向传播计算时，这些共享的参数的梯度是累加的
  • 有两种共享参数的方法

    1. 在 Module 的 forward 方法中多次调用同一个层

      class SharePara(nn.Module):
    def __init__(self, **kwargs):
        super(SharePara, self).__init__(**kwargs)
        self.linear = nn.Linear(1, 1, bias=False)

    def forward(self, x):
        x = self.linear(x)
        x = self.linear(x)
        return x
    
net = SharePara() 
print(net)

for name, param in net.named_parameters():
    init.constant_(param, val=3)
    print(name, param.data)

      SharePara(
  (linear): Linear(in_features=1, out_features=1, bias=False)
)
linear.weight tensor([[3.]])

      x = torch.ones(3,1)
print(net(x))

y = net(x).sum()
print(y)
y.backward()
print(net.linear.weight.grad) # 单次梯度是3，每个样本算两次为6，三个样本一共18

      tensor([[9.],
        [9.],
        [9.]], grad_fn=)
tensor(27., grad_fn=)
tensor([[18.]])

    2. 将同一个 Module 实例多次传入 Sequential 模块

      linear = nn.Linear(1, 1, bias=False)

net = nn.Sequential(linear, linear) 
print(net)

for name, param in net.named_parameters():
    init.constant_(param, val=3)
    print(name, param.data)

      Sequential(
  (0): Linear(in_features=1, out_features=1, bias=False)
  (1): Linear(in_features=1, out_features=1, bias=False)
)
0.weight tensor([[3.]])

      x = torch.ones(3,1)
print(net(x))

y = net(x).sum()
print(y)
y.backward()
print(net[0].weight.grad) # 单次梯度是3，每个样本算两次为6，三个样本一共18

      tensor([[9.],
        [9.],
        [9.]], grad_fn=)
tensor(27., grad_fn=)
tensor([[18.]])

3. 自定义层

  • 现代术语“深度学习”诉诸于学习多层次组合这一普遍原理。理论上讲，“宽度学习”（使用足够宽的单隐藏层神经网络）也能拟合任何形状的目标函数，但是其需要的参数量要远多于将神经元进行层次组合的“深度学习”。“深度学习”的模型表示更加“高效”，这样模型复杂度就可以相对低，在不发生过拟合的前提下，尽量减少对数据量的要求
  • pytorch 中不区分“层”、“块”和“模型”，都统一用 nn.Module 库实现

3.1 不含模型参数的自定义层

  • 如果一个层中不含可训练参数，比如 ReLU、dropout、BatchNormanation 等，则它和之前 1.1 节定义的模型类似，可以通过继承 nn.Module 类并重写 __init__ 和 forward 函数来实现。下面的 CenteredLayer 自定义了一个将输入减掉均值后输出的层，层的计算定义在 forward 函数里，该层不含模型参数

    import torch
from torch import nn

class CenteredLayer(nn.Module):
    def __init__(self, **kwargs):
        super(CenteredLayer, self).__init__(**kwargs)
    def forward(self, x):
        return x - x.mean()

layer = CenteredLayer()
layer(torch.tensor([1, 2, 3, 4, 5], dtype=torch.float))

    tensor([-2., -1.,  0.,  1.,  2.])

  • 自定义层可以和其他层、块等混合使用，构造更复杂的模型

    net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())
y = net(torch.rand(4, 8))
y.mean().item()  # 返回 1.862645149230957e-09，加上 CenteredLayer 后输出小了好几个数量级

3.2 含模型参数的自定义层

  • 2.1.1 节已经介绍了 Tensor 的子类 Parameter，如果一个 Tensor 是 Parameter，那么它会自动被添加到模型的参数列表里，所以在自定义含模型参数的层时，我们应该将参数定义成 Parameter。具体来说有三种定义方法

    1. 直接像 2.1.1 节一样将参数定义为 Parameter 类的实例，如 self.weight1 = nn.Parameter(torch.rand(20, 20))

    2. 使用 ParameterList 定义参数的列表。它接收一个 Parameter 实例列表作为输入，得到一个 ParameterList 实例，使用的时候可以用索引来访问某个参数，也可像 python list 一样使用 append 和 extend 在列表后面新增参数

      class MyListDense(nn.Module):
    def __init__(self):
        super(MyListDense, self).__init__()
        self.params = nn.ParameterList([nn.Parameter(torch.randn(4, 4)) for i in range(3)]) # 有三个 Parameter 实例的 ParameterList
        self.params.append(nn.Parameter(torch.randn(4, 1)))                                  # 再添加一个 Parameter 实例

    def forward(self, x):
        for i in range(len(self.params)):
            x = torch.mm(x, self.params[i])
        return x
    
net = MyListDense()
print(net)

      MyListDense(
  (params): ParameterList(
      (0): Parameter containing: [torch.FloatTensor of size 4x4]
      (1): Parameter containing: [torch.FloatTensor of size 4x4]
      (2): Parameter containing: [torch.FloatTensor of size 4x4]
      (3): Parameter containing: [torch.FloatTensor of size 4x1]
  )
)

    3. 使用 ParameterDict 定义参数的字典。它接收一个 Parameter 实例的字典作为输入，得到一个 ParameterDict 实例，使用时可以按照字典的规则使用了，如使用 update() 新增参数，使用 keys() 返回所有键值，使用 items() 返回所有键值对等等。详见 官方文档

      class MyDictDense(nn.Module):
    def __init__(self):
        super(MyDictDense, self).__init__()
        self.params = nn.ParameterDict({                             
                'linear1': nn.Parameter(torch.randn(4, 4)),
                'linear2': nn.Parameter(torch.randn(4, 1))
        })                                                               # 有两个 Parameter 实例的 ParameterDict
        self.params.update({'linear3': nn.Parameter(torch.randn(4, 2))}) # 新增

    def forward(self, x, choice='linear1'):
        return torch.mm(x, self.params[choice])

net = MyDictDense()
print(net)

print('\n可以根据键值选择层进行前向传播')
x = torch.ones(1, 4)
print(net(x, 'linear1'))
print(net(x, 'linear2'))
print(net(x, 'linear3'))

      MyDictDense(
  (params): ParameterDict(
      (linear1): Parameter containing: [torch.FloatTensor of size 4x4]
      (linear2): Parameter containing: [torch.FloatTensor of size 4x1]
      (linear3): Parameter containing: [torch.FloatTensor of size 4x2]
  )
)

可以根据键值选择层进行前向传播
tensor([[-1.3125,  3.8159,  2.0206,  0.2005]], grad_fn=)
tensor([[-0.2396]], grad_fn=)
tensor([[-0.3586, -1.7440]], grad_fn=)

  • 自定义层可以和其他层、块等混合使用，构造更复杂的模型

    net = nn.Sequential(
    MyDictDense(),
    MyListDense(),
)
print(net)
print(net(x))

    Sequential(
  (0): MyDictDense(
    (params): ParameterDict(
        (linear1): Parameter containing: [torch.FloatTensor of size 4x4]
        (linear2): Parameter containing: [torch.FloatTensor of size 4x1]
        (linear3): Parameter containing: [torch.FloatTensor of size 4x2]
    )
  )
  (1): MyListDense(
    (params): ParameterList(
        (0): Parameter containing: [torch.FloatTensor of size 4x4]
        (1): Parameter containing: [torch.FloatTensor of size 4x4]
        (2): Parameter containing: [torch.FloatTensor of size 4x4]
        (3): Parameter containing: [torch.FloatTensor of size 4x1]
    )
  )
)
tensor([[-7.0746]], grad_fn=)

你可能感兴趣的:(#,PyTorch,pytorch,深度学习,权重共享,模型构造,自定义层)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 第一场雪 岁月静好_nx
    早晨起来，外面白茫茫的一片，总算是下雪了，这还是今年第一场雪呢！走在路上，踩着雪“咯吱咯吱”的，空气很湿润。树上、草坪上、屋顶上都落了白白的一层，天上还零星漂着几点雪。慢慢走在路上，呼吸着清新的空气，感受着冬天的美好，心情也好多了。
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • LLM 词汇表 落难Coder LLMsNLP大语言模型大模型llama人工智能
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchaineasyui前端python
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
  • 使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twittereasyui前端python
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
  • 如何部分格式化提示模板:LangChain中的高级技巧 nseejrukjhad langchainjava服务器python
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts信息可视化数据分析
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • 傍晚 小罗琳
    鸟叫声在小区那边，密密稠稠，轻快而明亮，它们是归巢前互道晚安呢！金色的黄昏洋洋洒洒地飘落在房屋上，给它们镀上了一层淡淡的金边。一到黄昏，没有一个地方不是热闹的，街上的车慢慢多起来，出来散步的人也三五成群，谈笑风生。狗狗们似乎也闷坏了，撒欢地你追我赶，尽管小雨刚停，但它们的热情不减，叫着跑着，好不热闹。潮湿的空气弥漫着醉人的芬芳，楼下的杜鹃花也欣欣然张开了嘴，火红的花瓣张扬地舞动着，鲜艳欲滴，花瓣似
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • 下一站深圳 默琊
    昨天已经买好3/15到深圳的机票了，原本上周还有点拖延症发作，不太积极，所以昨天就直接逼迫自己买机票，然后在订房，下周就是确认行业和把具体的面谈日程定下来。行业的选择上目前没有太大的偏好，上一份工作主要是风控和客服，客服部分也算是个小组长，有负责培训和一些案件SOP流程的制定等工作。总感觉客服这个职位的职涯发展只能是垂直的往更高的管理层走，对于横向发展似乎不容易，而鉴于做客服1年的感受，我不太喜欢
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • Xinference如何注册自定义模型 玩人工智能的辣条哥 人工智能AI大模型Xinference
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
  • Shell、Bash、Zsh这都是啥啊 小白码上飞 bashlinux开发语言
    Zsh和Bash都是我们常用的Shell，那先搞明白啥是shell吧。Shell作为一个单词，他是“壳”的意思，蛋壳坚果壳。之所以叫壳，是为了和计算机的“核”来区分，用它表示“为使用者提供的操作界面”。所以这个命名其实很形象，翻译成中文，直译过来叫“壳层”。个人认为这个叫法很奇怪，意译貌似也没有什么好的词汇来匹配。就还是叫shell吧。维基百科给的定义是：Incomputing,ashellisa
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
     这是我自己想到的问题，结果去知呼提问，还没等别人回答， 我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
  • java编程思想 -- 数据的初始化 百合不是茶 java数据的初始化
      1.使用构造器确保数据初始化      /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
  • [航天与宇宙]为什么发射和回收航天器有档期 comsci
           地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁...        所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
  • linux下批量替换文件内容 商人shang linux替换
    1、网络上现成的资料 　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串 　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
  • 网页在线天气预报 oloz 天气预报
    网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
  • SpringMVC和Struts2比较 杨白白 springMVC
    1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。 参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
  • refuse copy, lazy girl! 小桔子 copy
           妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！  
  • apache与php整合 aichenglong php apache web
    一  apache web服务器 1 apeche web服务器的安装   1)下载Apache web服务器   2)配置域名(如果需要使用要在DNS上注册)   3)测试安装访问http://localhost/验证是否安装成功 2 apache管理   1)service.msc进行图形化管理   2)命令管理，配
  • Maven常用内置变量 AILIKES maven
    Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
  • java的类和对象 百合不是茶 JAVA面向对象 类 对象
    java中的类：     java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决   java使用 class 类名   来创建类 ，在Java中类名要求和构造方法，Java的文件名是一样的   创建一个A类： class A{ }   java中的类：将某两个事物有联系的属性包装在一个类中，再通
  • JS控制页面输入框为只读 bijian1013 JavaScript
    在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。  
  • AngularJS与服务器交互 bijian1013 JavaScriptAngularJS$http
            对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
  • [Maven学习笔记八]Maven常用插件应用 bit1129 maven
    常用插件及其用法位于：http://maven.apache.org/plugins/   1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin           1. Jetty Pl
  • 【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
    1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括： 文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
  • 杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
    nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
  • UI设计中我们为什么需要设计动效 brotherlamp UIui教程ui视频ui资料ui自学
    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。 但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。 一、加强体验舒适度 嗯，就是让用户更加爽更加爽的用你的产品。
  • Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan javaspring
    参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
  • 数据库连接池的工作原理 chicony 数据库连接池
           随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动 态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查 询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
  • java 关键字 CrazyMizzz java
    关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：    （1）访问修饰符       public,private,protected       p
  • Hive中的排序语法 daizj 排序hiveorder byDISTRIBUTE BYsort by
    Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。 与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
  • 单态设计模式 dcj3sjt126com 设计模式
      单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{    // 保存类实例在此属性中    private static&
  • svn locked dcj3sjt126com Lock
    post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
  • ARM寄存器学习 e200702084 数据结构C++cC#F#
    无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。     ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）     不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
  • 常用编码资料 gengzg 编码
    List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
  • 进程 vs. 线程 hongtoushizi 线程linux进程
    我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。 首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。 如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。 如果用多线程实现
  • Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linuxcrontab
    一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来： 第一段 代表分钟 0—59 第二段 代表小时 0—23 第三段 代表日期 1—31 第四段 代表月份 1—12 第五段 代表星期几，0代表星期日 0—6   如： */1 * * * *   每分钟执行一次。 *
  • KMP算法详解 hm4123660 数据结构C++算法字符串KMP
         字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。       假设主串s="ababcabcacbab",模式串为t="
  • 枚举类型的单例模式 zhb8015 单例模式
    E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
  • Kafka+Storm+HDFS ssydxa219 storm
    cd /myhome/usr/stormbin/storm nimbus &amp;bin/storm supervisor &amp;bin/storm ui &amp;Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
  • Java获取本地服务器的IP 中华好儿孙 javaWeb获取服务器ip地址
    System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他