strivinging

ResNet34之pytorch实现

我的实现：

import torch
from torch import nn
#因为ResNet34包含重复的单元，故用ResidualBlock类来简化代码
class ResidualBlock(nn.Module):
    def __init__(self,inchannel,outchannel,stride,shortcut=None):
        super(ResidualBlock,self).__init__()
        self.basic = nn.Sequential(
            nn.Conv2d(inchannel,outchannel,3,stride,1,bias=False),#要采样的话在这里改变stride
            nn.BatchNorm2d(outchannel),#批处理正则化
            nn.ReLU(inplace=True),#激活
            nn.Conv2d(outchannel,outchannel,3,1,1,bias=False),#采样之后注意保持feature map的大小不变
            nn.BatchNorm2d(outchannel),
        )
        self.shortcut = shortcut
    
    def forward(self,x):
        out = self.basic(x)
        residual = x if self.shortcut is None else self.shortcut(x)#计算残差
        out += residual
        return nn.ReLU(inplace=True)(out)#注意激活
#ResNet类
class ResNet(nn.Module):
    def __init__(self):
        super(ResNet,self).__init__()
        self.pre = nn.Sequential(
            nn.Conv2d(3,64,7,2,3,bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3,2,1),
        )#开始的部分
        self.body = self.makelayers([3,4,6,3])#具有重复模块的部分
        self.classifier = nn.Linear(512,1000)#末尾的部分
        
    def makelayers(self,blocklist):#注意传入列表而不是解列表
        self.layers = []
        for index,blocknum in enumerate(blocklist):
            if index != 0:
                shortcut = nn.Sequential(
                    nn.Conv2d(64*2**(index-1),64*2**index,1,2,bias=False),
                    nn.BatchNorm2d(64*2**index)
                )#使得输入输出通道数调整为一致
                self.layers.append(ResidualBlock(64*2**(index-1),64*2**index,2,shortcut))#每次变化通道数时进行下采样
            for i in range(0 if index==0 else 1,blocknum):
                self.layers.append(ResidualBlock(64*2**index,64*2**index,1))
        return nn.Sequential(*self.layers)
    
    def forward(self,x):
        x = self.pre(x)
        x = self.body(x)
        x = nn.AvgPool2d(7)(x)#kernel_size为7是因为经过多次下采样之后feature map的大小为7*7，即224->112->56->28->14->7
        x = x.view(x.size(0),-1)
        x = self.classifier(x)
        return x
    
net = ResNet()
print(net)

input = torch.autograd.Variable(t.randn(1,3,224,224))
print(net(input))

输出：

ResNet(
  (pre): Sequential(
    (0): Conv2d (3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
    (2): ReLU(inplace)
    (3): MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), dilation=(1, 1))
  )
  (body): Sequential(
    (0): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (1): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (2): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (3): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      )
      (shortcut): Sequential(
        (0): Conv2d (64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (4): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (5): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (6): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (7): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
      (shortcut): Sequential(
        (0): Conv2d (128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (8): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (9): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (10): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (11): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (12): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (13): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      )
      (shortcut): Sequential(
        (0): Conv2d (256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (14): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (15): ResidualBlock(
      (basic): Sequential(
        (0): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
        (2): ReLU(inplace)
        (3): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      )
    )
  )
  (classifier): Linear(in_features=512, out_features=1000)
)
Variable containing:
-0.3515 -0.2473  0.1059  ...  -0.0547 -0.3626  0.5740
[torch.FloatTensor of size 1x1000]

源码实现：

from torchvision import models
print(models.resnet34())

输出：

ResNet(
  (conv1): Conv2d (3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
  (relu): ReLU(inplace)
  (maxpool): MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), dilation=(1, 1))
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
    )
    (2): BasicBlock(
      (conv1): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d (64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      (downsample): Sequential(
        (0): Conv2d (64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
    )
    (2): BasicBlock(
      (conv1): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
    )
    (3): BasicBlock(
      (conv1): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d (128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      (downsample): Sequential(
        (0): Conv2d (128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
    )
    (2): BasicBlock(
      (conv1): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
    )
    (3): BasicBlock(
      (conv1): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
    )
    (4): BasicBlock(
      (conv1): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
    )
    (5): BasicBlock(
      (conv1): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d (256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      (downsample): Sequential(
        (0): Conv2d (256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
    )
    (2): BasicBlock(
      (conv1): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d (512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
    )
  )
  (avgpool): AvgPool2d(kernel_size=7, stride=1, padding=0, ceil_mode=False, count_include_pad=True)
  (fc): Linear(in_features=512, out_features=1000)
)

2023-04-11 短发娃
对我而言，睡前最不能做的事情就是看淘宝。想买，又没有明确目标的时候最不能看。一无所获不说，还看了别的杂七杂八的别的东西，扰乱。到头来一场空虚，一看时间更是追悔莫及。就这样，先睡吧。明天的事情明天再说，今天的事儿已经做完。
零时空间005*99天圆满/似此星辰同昨日～随笔似此星辰同昨日
文l仙派狼王*星辰原创时间过得真快，一晃三个月就过去了。最没想到的是，我这么懒的人，到现在，居然把自己以前写的，那些杂七杂八的东西，整理得差不多了。写不是问题，好赖能够写出来，一说到改，头疼得厉害。再一个就是舍弃，但不是丢弃，怎么说都是我自己的作品。留着有空的时候看看，或许还能找到灵感呢！不知道别人怎么想的，对于写小文，我不是特别喜欢写，总觉得和考试的文章一样，写起来总是感觉不那么舒畅。我翻看以前
坚持学习2018-07-17 （54）王丽娥1
今天又是愉悦的一天，感恩所有的美好！感赏早上儿子补习课回到家，心情不错，和我聊着数学课是他补习课程中觉得最好的一科，说今天物理老师表扬他很聪明，只要多通过练习就可以提高，还开心地说着在补习机构的一些杂七杂八的事，感觉和儿子的关系正在慢慢变好。感赏英语老师早上发来儿子背诵作业完成不是很好，是个负责任的老师，自己收到了信息，给儿子看完后，自己就把它忽略了，下午儿子主动去背诵了并让我考考他，是个知错能改
差点断更楼兰梦舞
不知不觉写了107天了，还是挺能记得的，没有忘记过。昨天第108天差点忘记了。白天吧，倒是开了电脑，打开了准备写，觉得没啥好写的。一天没出门，下午听了一会生涯课，修改了一会PPT，刷了会书，准备和娃一起画老虎的，看看晚饭做好了，时间不太够，就没画了，明天再说。吃完饭吧，约的生涯咨询的时间快到了，因为要共享PPT，于是关掉了电脑上打开的杂七杂八的软件，包括。先聊了会才聊回今天的价值观主题，等咨询结束
我是谁林木之鹿
最近压力好大，事情多的忙不过来，每天陷在各种杂七杂八的事情里，生活没有了计划和安排。学习时间也不能保证，先前觉得有意义的事情现在看来不过是小打小闹，但却花费了我大量的时间，深感不值。未来我可能得学会拒绝学会表达的不满才能活的轻松一点吧。
心累我在枣快乐呀
这个点才洗漱完毕，10点才回到宿舍，莫名心累，觉得时间真的太浪费了。下午4点多才出发桥头，唉，一些所谓的“交流”，时间全花在路上和听“废话”上。最近开放日，加上考试，一大堆杂七杂八的事情，明天上午去听课，下午磨课，级部还要检查环境，周三上午公开课，周四开始月考，莫名心累，如果有那么些瞬间真的想什么岗位都不要，就安安静静地在当一名幸福的班主任，备好课，上好课，教好学生。大家都不容易，刘主任说回到后还
【前世刁蛮女王今生霸道总裁】《美女香魂锦囊》第七章合租女王之短兵相接区块链代币名称设计
第七章合租女王之短兵相接图片发自App【喜欢本人长篇连载区块链科幻题材小说《风流矿娘》、《美女香魂锦囊》、《好儿女（纪实文学）》的友友们，敬请关注，方便追更。谢谢点评！】华若歌在陈忠真和丽斯把房子卫生和杂七杂八的事快做完了，才出现……华若歌是那种很会抢功的人，又将是情场高强竞争对手，而丽斯对他还挺热情的，怪不得陈忠真满腹泛酸——干活时兴高采烈的陈忠真，在丽斯说下楼去接他时，一脸写满了不高兴……单纯
【专注于当下的效率最高】 Alicy赵小连HongBin
2021年2月19日，星期五，上海禹天环保科技有限公司【赵小连】感恩日志第1094天【专注于当下的效率最高】这段时间，收获最大的是当下头脑层的杂七杂八的多余思维，把注意力专注于当下的每一个身、口、意，管理好自己的每一个当下的念头，回A客户就不纠结于B客户的事情，做合同就做合同，做总结报告就不想订单的事情，需要处理的事情，想到了马上就去沟通去处理，处理结束立马换台专注于下一个事情……发现这样的专注和
催催催……催命啊青小桥
事情一多，就会有各种幺蛾子出现，然后就想多米诺骨牌一样，杂七杂八的闹心事都出来了……就比如今天，即使已经预见了今天的糟糕情况。从早上开始，各种人的各种催就没有间断过。首先是客户，跟牛皮糖似的，一个问题还没有解决，就开始问什么时候可以交付；远没有到期的任务，就开始催……不能用脑子想一想呀？问问问……还没有开始的任务就问什么时候能结束？有点常识好不好！明明已经很认真的对待了，还以为别人会懈怠，然后就一
放着工作不做去聚会。恶人IN
昨天周日的事情，讲实话今天可以的话也是不想去工作的。上周末玩的多了，完全没有休息到，不知道这一周要怎么坚持下来。早上出门晚了心情自然变差，路人都成了面目可憎的样子。等地铁看着玻璃上反射出的自己的样子，深深地觉得自己不是自己就好了，不存在就好了。想要凭空消失掉。杂七杂八的事情很多，工作上也是各种自己买单。倒也随意，都是半永久性的东西。昨天结账发现余额不够时愣了一下，倒也在意料之中。脸上无光的还是公司
2019-04-08 凤凰未涅槃
佛陀说无眼耳鼻舌身意，也许也有说让我们专注于自己的心的含义吧……让我们锁定目标，积聚能量，心无旁骛，置心一处，如果我们能够做到如此，想必一定会有所成就与收获…有时候想，常言所说的：知足常乐，会不会害了许多人，物质与精神，唯心与唯物，其实怎可分割，也许人在物质生活方面，可能当身体逐渐老化，并没有那么色声香味触法、眼耳鼻舌身意了，也没有那么多杂七杂八的纷乱想法了，但是人的思想境界，有无限的提升空间，而
美好清晨2020216——育儿育己：人生如梦梦如人生凝飞呀
期盼着下雪的晚上，早早睡下了。期待着一觉醒来，白雪铺满窗台。夜里几次醒来跑去阳台看，都没有，似乎有一次看到阳台落上了薄薄的一层。待清晨醒来，依然不见白雪的踪影。倒是想起自己一夜间做的杂七杂八的各种梦，梦中的挣扎与雀跃、哭泣与欢笑，好像真的一样。不禁想起了一首歌，于是一边吃饭一边听着：等到老去那一天你是否还在我身边看那些誓言谎言随往事慢慢飘散多少人曾爱慕你年轻时的容颜可知谁愿承受岁月无情的变迁多少人
2020-03-24 半亩园cxl
2020一03一24我的“半亩三分地”一断舍离日本作家山下英子的作品《断舍离》，已读了有些时日了，对于可操作的、有指导意义的几句经典，已烂熟于心。目的就是这几天收拾家时能用的上。比如“看不见的收纳空间只能放柒成，看得见的收纳空间只能放五成，给别人看的收纳空间只能放一成”。估计家里所有的收纳空间，按照这个原则都不达标。今咱就试试看吧！前几天，厨房里的冰箱移到客厅已经好几天了。厨房里的杂七杂八的物件仿
老舍《四世同堂》读后小感盛眼yo
《四世同堂》读后小感想读的时候是抱着看名著的心态，越读越深入。完全被那个年代的中国震惊，被那个年代的北平震惊。祁家一家四世同堂经历了战争落得七零八落，但是他们终于等来了日本投降，这终究算个好结局。小羊圈这个胡同，聚集着杂七杂八的人，品行性格各有不同，人生百态一齐上演，人性的丑恶让读者在书前挥拳，汉奸作态的无耻实在让人不可思议，世界之大，无奇不有，战争年代更是奇葩辈出。同样的，战争年代也出了一批一批
【日更38】看了五本整理书，依旧做不好整理这件事落花点点Lydia
因为有段时间特别沉迷整理，所以连续不断的买了五本整理相关的书：《断舍离》，《极简生活》，《整理生活从整理内心开始》，《怦然心动的人生整理魔法》一和《怦然心动的人生整理魔法》二不光买了书，我还曾在公司组织的读书会上分享过关于整理的读书心得。时至今日，怀顾家的四周，跟猪窝又没有什么差别了。为了保持点尊严，我就不上图了。总之，衣服哪里都是，绘本哪里都是，我自己的书哪里都是，其他杂七杂八的东西哪里都是。甚
《心也是它的》——周三周三的简书
午夜.我提笔忘字的默念或许心早已启程哭泣了半夜和一整个早上的天稍许停滞而我却孤独的寒暄你听是否有夜莺、蝉、蛐蛐、蛙、和布谷鸟的叫声杂七杂八的混在一起这一刻我的心已不属于这里也不属于自己···仿佛回到了童年看星数羊依偎在爷爷身边看他烫一壶酒和执一袋烟叶从不缺电视、手机、电脑也不曾听过与它之外的故事现在不慌不忙的上了火车总会看着窗外和轮子和铁轨摩擦过的声音一起写下了一路向北再向西关于火车和青海的故事此
时间可以这样安排可可易希
文/可可易希昨晚妈妈回来了，用先生的话说，妈妈一回来我又轻松了。的确如此，妈妈回来后大部分时间她都会帮我带娃。但毕竟是自己的孩子，很多时候还是得我自己来，再说家里也有些杂七杂八的活需要我去做。所以，时间对于我来说还是挺紧的。每天重复着带娃这件事，总让我感觉到枯燥和乏味，好像也有点烂费时间。所以，我决定重新安排我的时间。通过今天一天尝试下来，感觉还挺好的。参加教育行走的相关活动，是我这个假期经过思考
杂乱无章的大乱炖梁长安
说实话，我这个人想法很多，实行很少，故事讲了不少，写了很少，东西学了很多，成功的很少，这个号也机缘巧合建的，所以写东西可能有点随意，但是若是我发出了的，基本上都是我自己写的罢。若不是我一定标出处的不必担心。本来还有很多话要讲的。奈何此时仍在赶路回宿舍路上。一路上路边文艺小店的灯光，伴着秋风，配着南国的树。风景甚好。但是我饿了。至于以后写故事还是复盘还是什么游记还是什么杂七杂八的。日后再提。就这样。
开笔，梦重新开启灰色乔木
开笔，本意是用手指轻轻将笔头捻松。开笔礼，古代读书人人生四大礼之一，俗称破蒙。原谅知“”未用“”，很新奇，也很懵懂。在翻阅简友的文字时，萌生了动笔写文的念头，脑海里瞬间看到奶娃娃上学的“开笔礼”——开笔启智放飞梦想的场景。于是，郑重其事地写下这段，给小白的自己，一场小小“开笔”仪式。都说“读书破万卷，下笔如有神”，平时喜欢读些杂七杂八的书，读过的书没有过万也有几千，会为翻到一本好书而愉悦，为因一段
菜鸟大妈的糗事菜鸟大妈
菜鸟大妈帮人打扫卫生,那客户是一个三十岁单身小伙。菜鸟大妈曾经帮他家打扫过一次。所以那小伙便记下了菜鸟大妈的电话便有了这一次的服务。那小伙刚搬家。人在机关工作,他家东西又多又杂.他便要将一些不常用的东西要清理掉。扔掉又觉可惜。杂七杂八的于是他问菜鸟大妈要不要?菜鸟大妈心想东西再好用不上,放在那在地方,还不好打扫卫生。菜鸟大妈经常帮人打卫生,最怕人家家里摆设品多。大部份顾主总是希望活干得又快又好。因
结婚有风险，领证需谨慎无限风光在险峰yeah
结婚有风险，领证需谨慎现如今结婚可是越来越难了，难的不是因为男人没车没房，拿不出彩礼。而是男人为了结婚，买车买房，还要给彩礼，当然了还不包括办酒席，那些杂七杂八的费用。一场婚礼足以可以让男方，甚至让男方父母几十年的心血，辛苦赚来的钱一夜回到解放前。但是呢，现在很多女人关键是打着结婚的名义骗钱啊，结个婚没几年一句话不合适，就提出离婚，分家产，赚分手费等，这又是一笔费用，女人从一开始到结束都是不需要花
【剽悍一只猫的剽悍行动营】成长记录——Racle 娜一姐
【标题】【剽悍一只猫的剽悍行动营】成长记录——Racle【作者】剽悍行动营老铁Racle参加剽悍行动营之前，我看不到任何事物的美好，经受不起一点点的挫折和打击，暴躁易怒。每天上班走在路上，就开始觉得工作上那些杂七杂八的事情想想就烦。麻木生活，动不动就指责爱人、训斥孩子。最享受的是看NBA、刷抖音，或是去喝酒、K歌，一嘴油腻地批评这个、指责那个，说些豪言壮语。过后一回到家就像皮球泄气、狼藉一地。22
TED六个月学好一门外课的整理 Facethesun99
去年看过这个视频，周末在油管上又看了一次刚刚好买了一个半年的英语课，本来就打算用6个月时间，每天3-4小时，把英语口语提一提大家在TED上应该能搜索到这个视频，讲的核心方法有：1、良好的学习心态，在心情不好或情绪不佳是，你的思想是会被一些杂七杂八的事情占有的，没有办法做到专注2、要有联想的能力，把学习的内容与我们的生活或工作联系起来，如果做不到，那么就挑出能与我们生活、工作相关的课去记3、把要学习
随记秦家炎
一到睡点写作在不动笔就要流产，怎么办，原来写不上来痛苦，现在写不上麻木，但是又不能不做，写又不知从何写起。每天脑子从来不停的想杂七杂八的事情，想要静静都达不到，可是一到写作想的事情每一件能顶上来的。最近的刻意练习是写作尽可能开头写中心句或者段意句。写作一上来要写美文完成的文章对我来说很不现实，到现在对于写作还没有一个清晰准确的概念，所以想要一篇我认可的文章，现在还想不出来。但是可以一点一点的拱，先
青苹果的记忆南漂的鱼
周日在网上闲逛想买一些苹果，偶然间看到了有卖青苹果的。马上下单买了一些回来。等到货了立马就拿起来去洗了。却在水流的哗哗声中想起了往事。一童年记忆里的甜脆青苹果小时候在苹果产区长大。自家没有种果蔬，但是生产大队有一片专门的果园。里面种满了苹果，桃树，杏树，葡萄等等杂七杂八的水果。地面还种有一些西瓜藤。果蔬周围围了高高的铁丝网，专门用来防止小孩子进入果园的。于是在每个桃花开，杏子长得季节我们都会特意绕
做文案三个多月，每个月工资从未超过四千周鰭祐
图片发自App自九月初到现在，做文案已经三个多月了。每天起早贪黑，兢兢业业，绞尽脑汁的榨干自己的脑细胞，几乎每个月写到五六十篇的量，最后到手工资撑死就三千多，心塞至极，一首凉凉送给自己，在座的各位就别鼓掌了。郁闷是必须的，毕竟每个月的稿子里：通稿+微信稿，还有别的杂七杂八的小众稿件杂交，这样算下来咱可是比廉价劳动力还廉价啊！这付出的劳动与劳动成果完全不成正比有木有？毕竟呕心沥血的工作就是为了挣点公
平凡的一天 mc不吃饭
2018年7月15号，这是非常平凡的一天，这一天没有什么节日，没有什么纪念日。对我自己来说又是怎样的一天呢14号晚上就准备好了的，又不知道要怎么准备的，怀着复杂的心情，一夜没睡的想了杂七杂八的琐事，可能也是习以为常了，第二天起床也不是很困，早早的起床，把被子叠的整整齐齐，洗过澡后，穿上昨天洗的带着洗衣服残留香味的衣服，背上不知道多久前买的小背包。就这样迷迷糊糊的出门。路上耳机里还在放着已经循环了好
Android程序员会遇到的算法(part 6 优先级队列PriorityQueue) qing的世界
Android程序员会遇到的算法(part6优先级队列PriorityQueue)又是隔了四个多月才更新，从十月底来到美国开始上班，中间杂七杂八的事情很多，加上感恩节圣诞节放假出去玩了几趟，一直拖到现在。这一次我想讲一个比较经典的Java里面的数据结构。PriorityQueue，优先级队列的一些对应的算法题。优先级队列听起来很唬，其实就是一个帮助大家排序的数据结构而已，只不过它把插入->push
忙碌，是世界上珍贵的良药悟道修行
忙是治疗一切神经质的良药，一忙，也不伤感了、不八卦了、不自我膨胀了、不花痴了。平静的脸上无怒无喜，看过去只隐隐约约的写了一个“滚”字。很多的病，很多的痛、很多的胡思乱想都是闲出来的；让身体和脑袋动起来，专注一事，你会轻松畅快很多。忙是治疗一切疑心症的良药，一忙，没时间想杂七杂八的事儿，而且自己也有了自信，就算别人骗我，我也能活的好好的。人一闲下来就要多想，本来没什么事儿的老公看着像是出轨了，本来品
乌云糊涂葫芦呼呼
黑色天空，幽静室内推门声，轻哼声，强调声掩饰的假动作，脆耳简洁的敲着键盘有人在想着退路，有人在想着近路。还有着杂七杂八的思绪。好像是暴雨来临的前兆。他们都以为自己是主角，拥有强大的光环，他们相信，只要有明天，只要有一口气。终有一天，幸运会如期降临。因为，你永远也不知道明天，明天是阳光万里还是......
java数字签名三种方式知了ing java jdk
以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
Hibernate学习笔记 caoyong Hibernate
1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境 a>、添加jar包: aa>、hibernatte开发包中/lib/required/所
设计模式之装饰器模式Decorator（结构型）漂泊一剑客 Decorator
1. 概述若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
读取磁盘文件txt，并输入String 一炮送你回车库 String
public static void main(String[] args) throws IOException { String fileContent = readFileContent("d:/aaa.txt"); System.out.println(fileContent);
js三级联动下拉框 3213213333332132 三级联动
//三级联动省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
erlang之parse_transform编译选项的应用 616050468 parse_transform 游戏服务器属性同步 abstract_code
最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
JAVA JSON的解析 darkranger java
// { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
POJ-1273-Drainage Ditches aijuans ACM_POJ
POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
工作流Activiti5表的命名及含义 atongyeye 工作流 Activiti
activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。 A
android的广播机制和广播的简单使用百合不是茶 android 广播机制广播的注册
Android广播机制简介在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
Spring事务传播行为详解 bijian1013 java spring 事务传播行为
在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
eidtplus operate 征客丶 eidtplus
开启列模式: Alt+C 鼠标选择 OR Alt+鼠标左键拖动列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
【Kafka一】Kafka入门 bit1129 kafka
这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
Spring 事务实现机制 BlueSkator spring 代理事务
Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrap dropdown
bootstrap-dropdown组件是个烂东西，我读后的整体感觉。一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
常用代码记录 chenjunt3 UI Excel J#
1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
oracle Health Monitor daizj oracle Health Monitor
About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
JSON字符串转换为对象 dieslrae java json
作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
vagrant学习笔记 dcj3sjt126com vagrant
想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads 查看安装在命令行输入vagrant 2.
14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
1.Tomcat线程池修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
一个不错的shell 脚本教程入门级 HarborChung linux shell
一个不错的shell 脚本教程入门级建立一个脚本　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。　　如同其他语言一样
Spring4新特性——核心容器的其他改进 jinnianshilongnian spring 动态代理 spring4 依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
Linux设置tomcat开机启动 liuxingguome tomcat linux 开机自启动
执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
第13章 Ajax进阶（下） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Troubleshooting Crystal Reports off BW blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE Quite useful, especially this part: SAP BW connectivity For t
Java开发熟手该当心的11个错误 tomcat_oracle java jvm 多线程单元测试
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目可以在属性文件中配置，那么使它成为
正则表达式大全 yang852220741 html 编程正则表达式
今天向大家分享正则表达式大全，它可以大提高你的工作效率正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。一、校验数字的表达式数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$

ResNet34之pytorch实现

你可能感兴趣的:(杂七杂八的)