kui9702

Inception v3

2014年ImageNet竞赛的冠军Inception-v1，又名GoogLeNet。Inception v1的特点：模块增加网络的宽度。将模型的的输入经过几种卷积的计算,以concat方式连接。

Inception v2，在v1版本上改进2个方向：

引入BN层

模型在计算过程中，会先对输入进行归一化

Inception v3，在之前的基础上增加：

将大卷积分解成小卷积，使得在感受野不变的情况下，减少参数的计算量

max pooling层在下采样会导致信息损失大，于是设计成计算输入A的卷积结果，计算输入A的pooling结果，并且将卷积的结果与池化的结果concat。这样减少计算量又减少信息损失。

本次复现的是Inception v3（pytorch）。原论文链接https://arxiv.org/abs/1512.00567

整个模型结构会基于基本卷积结构：卷积->BN->Relu

# 卷积->BN->Relu 代码如下
class Conv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=False):
        super(Conv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size,
                              stride=stride, padding=padding, bias=bias)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        return self.relu(x)

InceptionA 结构

代码实现：

class InceptionA(nn.Module):
    def __init__(self, in_channels, pool_channels):
        super(InceptionA, self).__init__()
        self.branch1x1 = Conv2d(in_channels=in_channels, out_channels=64, kernel_size=1)

        self.branch5x5_1 = Conv2d(in_channels=in_channels, out_channels=48, kernel_size=1)
        self.branch5x5_2 = Conv2d(in_channels=48, out_channels=64, kernel_size=5, padding=2)

        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=64, kernel_size=1)
        self.branch3x3_2 = Conv2d(in_channels=64, out_channels=96, kernel_size=3, padding=1)
        self.branch3x3_3 = Conv2d(in_channels=96, out_channels=96, kernel_size=3, padding=1)

        self.branch_pool = Conv2d(in_channels=in_channels, out_channels=pool_channels, kernel_size=1)

    def forward(self, x):
        x_1x1 = self.branch1x1(x)

        x_5x5 = self.branch5x5_1(x)
        x_5x5 = self.branch5x5_2(x_5x5)

        x_3x3 = self.branch3x3_1(x)
        x_3x3 = self.branch3x3_2(x_3x3)
        x_3x3 = self.branch3x3_3(x_3x3)

        x_branch = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        x_branch = self.branch_pool(x_branch)

        # 将结果按行拼接起来,1是行，0是列   输出channel为64 + 64 + 96 + pool_channels
        output = torch.cat([x_1x1, x_5x5, x_3x3, x_branch], 1)
        return output

InceptionB结构

代码实现:

class InceptionB(nn.Module):
    def __init__(self, in_channels):
        super(InceptionB, self).__init__()
        self.branch3x3 = Conv2d(in_channels=in_channels, out_channels=384, kernel_size=3, stride=2)

        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=64, kernel_size=1)
        self.branch3x3_2 = Conv2d(in_channels=64, out_channels=96, kernel_size=3, padding=1)
        self.branch3x3_3 = Conv2d(in_channels=63, out_channels=96, kernel_size=3, stride=2)

    def forward(self, x):
        x_3x3 = self.branch3x3(x)

        x_3x3_1 = self.branch3x3_1(x)
        x_3x3_1 = self.branch3x3_2(x_3x3_1)
        x_3x3_1 = self.branch3x3_3(x_3x3_1)

        x_branch = F.max_pool2d(x, kernel_size=3, stride=2)
        return torch.cat([x_3x3, x_3x3_1, x_branch], 1)   # 384 + 96 + in_channels

InceptionC

代码实现：

class InceptionC(nn.Module):
    def __init__(self, in_channels, channels_7x7):
        super(InceptionC, self).__init__()
        self.branch_1x1 = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)

        self.branch_7x7_1 = Conv2d(in_channels=in_channels, out_channels=channels_7x7, kernel_size=1)
        self.branch_7x7_2 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(1, 7),
                                   padding=(0, 3))
        self.branch_7x7_3 = Conv2d(in_channels=channels_7x7, out_channels=192, kernel_size=(7, 1), padding=(3, 0))

        self.branch_7x7_4 = Conv2d(in_channels=in_channels, out_channels=channels_7x7, kernel_size=1)
        self.branch_7x7_5 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(7, 1), padding=(3, 0))
        self.branch_7x7_6 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(1, 7),
                                   padding=(0, 3))
        self.branch_7x7_7 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(7, 1),
                                   padding=(3, 0))
        self.branch_7x7_8 = Conv2d(in_channels=channels_7x7, out_channels=192, kernel_size=(1, 7),
                                   padding=(0, 3))

        self.branch_pool = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)

    def forward(self, x):
        x_1x1 = self.branch_1x1(x)

        x_7x7_1 = self.branch_7x7_1(x)
        x_7x7_1 = self.branch_7x7_2(x_7x7_1)
        x_7x7_1 = self.branch_7x7_3(x_7x7_1)

        x_7x7_2 = self.branch_7x7_4(x)
        x_7x7_2 = self.branch_7x7_5(x_7x7_2)
        x_7x7_2 = self.branch_7x7_6(x_7x7_2)
        x_7x7_2 = self.branch_7x7_7(x_7x7_2)
        x_7x7_2 = self.branch_7x7_8(x_7x7_2)

        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        branch_pool = self.branch_pool(branch_pool)

        return torch.cat([x_1x1, x_7x7_1, x_7x7_2, branch_pool], 1)   # 192  + 192  + 192 +192

InceptionD结构

代码实现:

class InceptionD(nn.Module):
    def __init__(self, in_channels):
        super(InceptionD, self).__init__()
        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)
        self.branch3x3_2 = Conv2d(in_channels=192, out_channels=320, kernel_size=3, stride=2)

        self.branch7x7x3_1 = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)
        self.branch7x7x3_2 = Conv2d(in_channels=192, out_channels=192, kernel_size=(1, 7), padding=(0, 3))
        self.branch7x7x3_3 = Conv2d(in_channels=192, out_channels=192, kernel_size=(7, 1), padding=(3, 0))
        self.branch7x7x3_4 = Conv2d(in_channels=192, out_channels=192, kernel_size=3, stride=2)

    def forward(self, x):
        x_3x3_1 = self.branch3x3_1(x)
        x_3x3_1 = self.branch3x3_2(x_3x3_1)

        x_7x7_1 = self.branch7x7x3_1(x)
        x_7x7_1 = self.branch7x7x3_2(x_7x7_1)
        x_7x7_1 = self.branch7x7x3_3(x_7x7_1)
        x_7x7_1 = self.branch7x7x3_4(x_7x7_1)

        branch = F.max_pool2d(x, kernel_size = 3, stride = 2)
        return torch.cat([x_3x3_1, x_7x7_1, branch], 1)   # 320 + 192 + 768 = 1280

InceptionE结构

代码实现:

class InceptionE(nn.Module):
    def __init__(self, in_channels):
        super(InceptionE, self).__init__()
        self.branch1x1 = Conv2d(in_channels=in_channels, out_channels=320, kernel_size=1)

        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=384, kernel_size=1)
        self.branch3x3_2a = Conv2d(in_channels=384, out_channels=384, kernel_size=(1, 3), padding=(0, 1))
        self.branch3x3_2b = Conv2d(in_channels=384, out_channels=384, kernel_size=(3, 1), padding=(1, 0))

        self.branch3x3dbl_1 = Conv2d(in_channels=in_channels, out_channels=448, kernel_size=1)
        self.branch3x3dbl_2 = Conv2d(in_channels=448, out_channels=384, kernel_size=3, padding=1)
        self.branch3x3dbl_3a = Conv2d(in_channels=384, out_channels=384, kernel_size=(1, 3), padding=(0, 1))
        self.branch3x3dbl_3b = Conv2d(in_channels=384, out_channels=384, kernel_size=(3, 1), padding=(1, 0))

        self.branch_pool = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)

    def forward(self, x):
        x_1x1 = self.branch1x1(x)

        x_3x3 = self.branch3x3_1(x)
        x_3x3 = [
            self.branch3x3_2a(x_3x3),
            self.branch3x3_2b(x_3x3)
        ]
        x_3x3 = torch.cat(x_3x3, 1)

        x_3x3_dbl = self.branch3x3dbl_1(x)
        x_3x3_dbl = self.branch3x3dbl_2(x_3x3_dbl)
        x_3x3_dbl = [
            self.branch3x3dbl_3a(x_3x3_dbl),
            self.branch3x3dbl_3b(x_3x3_dbl)
        ]
        x_3x3_dbl = torch.cat(x_3x3_dbl, 1)

        x_branch = F.avg_pool2d(x, kerbel_size=3, stride = 1, padding = 1)
        x_branch = self.branch_pool(x_branch)

        return torch.cat([x_1x1, x_3x3, x_3x3_dbl, x_branch], 1)   # 320 + 384*2 + 384*2 + 192 = 2048

Aux结构：

代码：

class Inception_Aux(nn.Module):
    def __init__(self, in_channels, num_classes):
        super(Inception_Aux, self).__init__()
        self.conv0 = Conv2d(in_channels=in_channels, out_channels=128, kernel_size=1)
        self.conv1 = Conv2d(in_channels=128, out_channels=768, kernel_size=5)
        self.conv1.stddev = 0.01
        self.fc = nn.Linear(768, num_classes)
        self.fc.stddev = 0.001

    def forward(self, x):
        # N x 768 x 17 x 17
        x = F.avg_pool2d(x, kernel_size = 5, stride = 3)
        # N x 768 x 5 x 5
        x = self.conv0(x)
        # N x 128 x 5 x 5
        x = self.conv1(x)
        # N x 768 x 1 x 1
        x = F.adaptive_max_pool2d(x, (1, 1))
        # N x 768 x 1 x 1
        x = torch.flatten(x, 1)
        # N x 768
        x = self.fc(x)
        return x

主体结构：

Inception v3 整体模型结构

主体代码:

class Inception_v3(nn.Module):
    def __init__(self, num_classes, aux_logits):
        super(Inception_v3, self).__init__()
        # 3 conv -> 1 maxpool -> 2 conv -> 1 maxpool
        self.conv_1 = Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=2)
        self.conv_2 = Conv2d(in_channels=32, out_channels=32, kernel_size=3)
        self.conv_3 = Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2)
        self.conv_4 = Conv2d(in_channels=64, out_channels=80, kernel_size=1)
        self.conv_5 = Conv2d(in_channels=80, out_channels=192, kernel_size=3)
        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2)
        self.inception_a_1 = InceptionA(in_channels=192, pool_channels=32)  # out_channels = 64 + 64 + 96 + 32 = 256
        self.inception_a_2 = InceptionA(in_channels=256, pool_channels=64)  # out_channels = 64 + 64 + 96 + 64 = 288
        self.inception_a_3 = InceptionA(in_channels=288, pool_channels=64)  # out_channels = 64 + 64 + 96 + 64 = 288
        self.inception_b_1 = InceptionB(288)    #384 + 96 + in_channels = 768
        self.inception_c_1 = InceptionC(in_channels=768, channels_7x7=128)   # 192 + 192 + 192 + 192 = 768
        self.inception_c_2 = InceptionC(in_channels=768, channels_7x7=160)
        self.inception_c_3 = InceptionC(in_channels=768, channels_7x7=160)
        self.inception_c_4 = InceptionC(in_channels=768, channels_7x7=192)
        self.aux_logits = aux_logits
        if self.aux_logits:
            self.auxlogits = Inception_Aux(768, num_classes=num_classes)
        self.inception_d = InceptionD(in_channels=768)  # 1280
        self.inception_e_1 = InceptionE(in_channels=1280)  # 2048
        self.inception_e_2 = InceptionE(in_channels=2048)
        self.avgpool = nn.AdaptiveAvgPool2d((1,1))
        self.dropout = nn.Dropout()
        self.fc = nn.Linear(2048, num_classes)

    def forward(self, x):
        # N x 3 x 299 x 299
        x = self.conv_1(x)
        # N x 32 x 149 x 149
        x = self.conv_2(x)
        # N x 32 x 147 x 147
        x = self.conv_3(x)
        # N x 64 x 147 x 147
        x = self.maxpool1(x)
        # N x 64 x 73 x 73
        x = self.conv_4(x)
        # N x 80 x 73 x 73
        x = self.conv_5(x)
        # N x 192 x 71 x 71
        x = self.maxpool2(x)
        # N x 192 x 35 x 35
        x = self.inception_a_1(x)
        # N x 256 x 35 x 35
        x = self.inception_a_2(x)
        # N x 288 x 35 x 35
        x = self.inception_a_3(x)
        # N x 288 x 35 x 35
        x = self.inception_b_1(x)
        # N x 768 x 17 x 17
        x = self.inception_c_1(x)
        # N x 768 x 17 x 17
        x = self.inception_c_2(x)
        # N x 768 x 17 x 17
        x = self.inception_c_3(x)
        # N x 768 x 17 x 17
        x = self.inception_c_4(x)
        # N x 768 x 17 x 17
        aux_defined = self.training and self.aux_logits
        if aux_defined:
            aux = self.auxlogits(x)
        else:
            aux = None
        # N x 768 x 17 x 17
        x = self.inception_d(x)
        # N x 1280 x 8 x 8
        x = self.inception_e_1(x)
        # N x 2048 x 8 x 8
        x = self.inception_e_2(x)
        # N x 2048 x 8 x 8
        # Adaptive average pooling
        x = self.avgpool(x)
        # N x 2048 x 1 x 1
        x = self.dropout(x)
        # N x 2048 x 1 x 1
        x = torch.flatten(x, 1)
        # N x 2048
        x = self.fc(x)
        # N x 1000 (num_classes)
        return x, aux

全部代码：

import torch
import torch.nn as nn
import torch.nn.functional as F


class Conv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=False):
        super(Conv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size,
                              stride=stride, padding=padding, bias=bias)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        return self.relu(x)


class InceptionA(nn.Module):
    def __init__(self, in_channels, pool_channels):
        super(InceptionA, self).__init__()
        self.branch1x1 = Conv2d(in_channels=in_channels, out_channels=64, kernel_size=1)

        self.branch5x5_1 = Conv2d(in_channels=in_channels, out_channels=48, kernel_size=1)
        self.branch5x5_2 = Conv2d(in_channels=48, out_channels=64, kernel_size=5, padding=2)

        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=64, kernel_size=1)
        self.branch3x3_2 = Conv2d(in_channels=64, out_channels=96, kernel_size=3, padding=1)
        self.branch3x3_3 = Conv2d(in_channels=96, out_channels=96, kernel_size=3, padding=1)

        self.branch_pool = Conv2d(in_channels=in_channels, out_channels=pool_channels, kernel_size=1)

    def forward(self, x):
        x_1x1 = self.branch1x1(x)

        x_5x5 = self.branch5x5_1(x)
        x_5x5 = self.branch5x5_2(x_5x5)

        x_3x3 = self.branch3x3_1(x)
        x_3x3 = self.branch3x3_2(x_3x3)
        x_3x3 = self.branch3x3_3(x_3x3)

        x_branch = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        x_branch = self.branch_pool(x_branch)

        # 将结果按行拼接起来,1是行，0是列   输出channel为64 + 64 + 96 + pool_channels
        output = torch.cat([x_1x1, x_5x5, x_3x3, x_branch], 1)
        return output


class InceptionB(nn.Module):
    def __init__(self, in_channels):
        super(InceptionB, self).__init__()
        self.branch3x3 = Conv2d(in_channels=in_channels, out_channels=384, kernel_size=3, stride=2)

        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=64, kernel_size=1)
        self.branch3x3_2 = Conv2d(in_channels=64, out_channels=96, kernel_size=3, padding=1)
        self.branch3x3_3 = Conv2d(in_channels=63, out_channels=96, kernel_size=3, stride=2)

    def forward(self, x):
        x_3x3 = self.branch3x3(x)

        x_3x3_1 = self.branch3x3_1(x)
        x_3x3_1 = self.branch3x3_2(x_3x3_1)
        x_3x3_1 = self.branch3x3_3(x_3x3_1)

        x_branch = F.max_pool2d(x, kernel_size=3, stride=2)
        return torch.cat([x_3x3, x_3x3_1, x_branch], 1)   # 384 + 96 + in_channels


class InceptionC(nn.Module):
    def __init__(self, in_channels, channels_7x7):
        super(InceptionC, self).__init__()
        self.branch_1x1 = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)

        self.branch_7x7_1 = Conv2d(in_channels=in_channels, out_channels=channels_7x7, kernel_size=1)
        self.branch_7x7_2 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(1, 7),
                                   padding=(0, 3))
        self.branch_7x7_3 = Conv2d(in_channels=channels_7x7, out_channels=192, kernel_size=(7, 1), padding=(3, 0))

        self.branch_7x7_4 = Conv2d(in_channels=in_channels, out_channels=channels_7x7, kernel_size=1)
        self.branch_7x7_5 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(7, 1), padding=(3, 0))
        self.branch_7x7_6 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(1, 7),
                                   padding=(0, 3))
        self.branch_7x7_7 = Conv2d(in_channels=channels_7x7, out_channels=channels_7x7, kernel_size=(7, 1),
                                   padding=(3, 0))
        self.branch_7x7_8 = Conv2d(in_channels=channels_7x7, out_channels=192, kernel_size=(1, 7),
                                   padding=(0, 3))

        self.branch_pool = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)

    def forward(self, x):
        x_1x1 = self.branch_1x1(x)

        x_7x7_1 = self.branch_7x7_1(x)
        x_7x7_1 = self.branch_7x7_2(x_7x7_1)
        x_7x7_1 = self.branch_7x7_3(x_7x7_1)

        x_7x7_2 = self.branch_7x7_4(x)
        x_7x7_2 = self.branch_7x7_5(x_7x7_2)
        x_7x7_2 = self.branch_7x7_6(x_7x7_2)
        x_7x7_2 = self.branch_7x7_7(x_7x7_2)
        x_7x7_2 = self.branch_7x7_8(x_7x7_2)

        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        branch_pool = self.branch_pool(branch_pool)

        return torch.cat([x_1x1, x_7x7_1, x_7x7_2, branch_pool], 1)   # 192  + 192  + 192 +192

class Inception_Aux(nn.Module):
    def __init__(self, in_channels, num_classes):
        super(Inception_Aux, self).__init__()
        self.conv0 = Conv2d(in_channels=in_channels, out_channels=128, kernel_size=1)
        self.conv1 = Conv2d(in_channels=128, out_channels=768, kernel_size=5)
        self.conv1.stddev = 0.01
        self.fc = nn.Linear(768, num_classes)
        self.fc.stddev = 0.001

    def forward(self, x):
        # N x 768 x 17 x 17
        x = F.avg_pool2d(x, kernel_size = 5, stride = 3)
        # N x 768 x 5 x 5
        x = self.conv0(x)
        # N x 128 x 5 x 5
        x = self.conv1(x)
        # N x 768 x 1 x 1
        x = F.adaptive_max_pool2d(x, (1, 1))
        # N x 768 x 1 x 1
        x = torch.flatten(x, 1)
        # N x 768
        x = self.fc(x)
        return x

class InceptionD(nn.Module):
    def __init__(self, in_channels):
        super(InceptionD, self).__init__()
        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)
        self.branch3x3_2 = Conv2d(in_channels=192, out_channels=320, kernel_size=3, stride=2)

        self.branch7x7x3_1 = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)
        self.branch7x7x3_2 = Conv2d(in_channels=192, out_channels=192, kernel_size=(1, 7), padding=(0, 3))
        self.branch7x7x3_3 = Conv2d(in_channels=192, out_channels=192, kernel_size=(7, 1), padding=(3, 0))
        self.branch7x7x3_4 = Conv2d(in_channels=192, out_channels=192, kernel_size=3, stride=2)

    def forward(self, x):
        x_3x3_1 = self.branch3x3_1(x)
        x_3x3_1 = self.branch3x3_2(x_3x3_1)

        x_7x7_1 = self.branch7x7x3_1(x)
        x_7x7_1 = self.branch7x7x3_2(x_7x7_1)
        x_7x7_1 = self.branch7x7x3_3(x_7x7_1)
        x_7x7_1 = self.branch7x7x3_4(x_7x7_1)

        branch = F.max_pool2d(x, kernel_size = 3, stride = 2)
        return torch.cat([x_3x3_1, x_7x7_1, branch], 1)   # 320 + 192 + 768 = 1280

class InceptionE(nn.Module):
    def __init__(self, in_channels):
        super(InceptionE, self).__init__()
        self.branch1x1 = Conv2d(in_channels=in_channels, out_channels=320, kernel_size=1)

        self.branch3x3_1 = Conv2d(in_channels=in_channels, out_channels=384, kernel_size=1)
        self.branch3x3_2a = Conv2d(in_channels=384, out_channels=384, kernel_size=(1, 3), padding=(0, 1))
        self.branch3x3_2b = Conv2d(in_channels=384, out_channels=384, kernel_size=(3, 1), padding=(1, 0))

        self.branch3x3dbl_1 = Conv2d(in_channels=in_channels, out_channels=448, kernel_size=1)
        self.branch3x3dbl_2 = Conv2d(in_channels=448, out_channels=384, kernel_size=3, padding=1)
        self.branch3x3dbl_3a = Conv2d(in_channels=384, out_channels=384, kernel_size=(1, 3), padding=(0, 1))
        self.branch3x3dbl_3b = Conv2d(in_channels=384, out_channels=384, kernel_size=(3, 1), padding=(1, 0))

        self.branch_pool = Conv2d(in_channels=in_channels, out_channels=192, kernel_size=1)

    def forward(self, x):
        x_1x1 = self.branch1x1(x)

        x_3x3 = self.branch3x3_1(x)
        x_3x3 = [
            self.branch3x3_2a(x_3x3),
            self.branch3x3_2b(x_3x3)
        ]
        x_3x3 = torch.cat(x_3x3, 1)

        x_3x3_dbl = self.branch3x3dbl_1(x)
        x_3x3_dbl = self.branch3x3dbl_2(x_3x3_dbl)
        x_3x3_dbl = [
            self.branch3x3dbl_3a(x_3x3_dbl),
            self.branch3x3dbl_3b(x_3x3_dbl)
        ]
        x_3x3_dbl = torch.cat(x_3x3_dbl, 1)

        x_branch = F.avg_pool2d(x, kerbel_size=3, stride = 1, padding = 1)
        x_branch = self.branch_pool(x_branch)

        return torch.cat([x_1x1, x_3x3, x_3x3_dbl, x_branch])   # 320 + 384*2 + 384*2 + 192 = 2048

class Inception_v3(nn.Module):
    def __init__(self, num_classes, aux_logits):
        super(Inception_v3, self).__init__()
        # 3 conv -> 1 maxpool -> 2 conv -> 1 maxpool
        self.conv_1 = Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=2)
        self.conv_2 = Conv2d(in_channels=32, out_channels=32, kernel_size=3)
        self.conv_3 = Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2)
        self.conv_4 = Conv2d(in_channels=64, out_channels=80, kernel_size=1)
        self.conv_5 = Conv2d(in_channels=80, out_channels=192, kernel_size=3)
        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2)
        self.inception_a_1 = InceptionA(in_channels=192, pool_channels=32)  # out_channels = 64 + 64 + 96 + 32 = 256
        self.inception_a_2 = InceptionA(in_channels=256, pool_channels=64)  # out_channels = 64 + 64 + 96 + 64 = 288
        self.inception_a_3 = InceptionA(in_channels=288, pool_channels=64)  # out_channels = 64 + 64 + 96 + 64 = 288
        self.inception_b_1 = InceptionB(288)    #384 + 96 + in_channels = 768
        self.inception_c_1 = InceptionC(in_channels=768, channels_7x7=128)   # 192 + 192 + 192 + 192 = 768
        self.inception_c_2 = InceptionC(in_channels=768, channels_7x7=160)
        self.inception_c_3 = InceptionC(in_channels=768, channels_7x7=160)
        self.inception_c_4 = InceptionC(in_channels=768, channels_7x7=192)
        self.aux_logits = aux_logits
        if self.aux_logits:
            self.auxlogits = Inception_Aux(768, num_classes=num_classes)
        self.inception_d = InceptionD(in_channels=768)  # 1280
        self.inception_e_1 = InceptionE(in_channels=1280)  # 2048
        self.inception_e_2 = InceptionE(in_channels=2048)
        self.avgpool = nn.AdaptiveAvgPool2d((1,1))
        self.dropout = nn.Dropout()
        self.fc = nn.Linear(2048, num_classes)

    def forward(self, x):
        # N x 3 x 299 x 299
        x = self.conv_1(x)
        # N x 32 x 149 x 149
        x = self.conv_2(x)
        # N x 32 x 147 x 147
        x = self.conv_3(x)
        # N x 64 x 147 x 147
        x = self.maxpool1(x)
        # N x 64 x 73 x 73
        x = self.conv_4(x)
        # N x 80 x 73 x 73
        x = self.conv_5(x)
        # N x 192 x 71 x 71
        x = self.maxpool2(x)
        # N x 192 x 35 x 35
        x = self.inception_a_1(x)
        # N x 256 x 35 x 35
        x = self.inception_a_2(x)
        # N x 288 x 35 x 35
        x = self.inception_a_3(x)
        # N x 288 x 35 x 35
        x = self.inception_b_1(x)
        # N x 768 x 17 x 17
        x = self.inception_c_1(x)
        # N x 768 x 17 x 17
        x = self.inception_c_2(x)
        # N x 768 x 17 x 17
        x = self.inception_c_3(x)
        # N x 768 x 17 x 17
        x = self.inception_c_4(x)
        # N x 768 x 17 x 17
        aux_defined = self.training and self.aux_logits
        if aux_defined:
            aux = self.auxlogits(x)
        else:
            aux = None
        # N x 768 x 17 x 17
        x = self.inception_d(x)
        # N x 1280 x 8 x 8
        x = self.inception_e_1(x)
        # N x 2048 x 8 x 8
        x = self.inception_e_2(x)
        # N x 2048 x 8 x 8
        # Adaptive average pooling
        x = self.avgpool(x)
        # N x 2048 x 1 x 1
        x = self.dropout(x)
        # N x 2048 x 1 x 1
        x = torch.flatten(x, 1)
        # N x 2048
        x = self.fc(x)
        # N x 1000 (num_classes)
        return x, aux

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
番茄西红柿叶子病害分类数据集12882张11类别 futureflsl 数据集分类数据挖掘人工智能
数据集类型：图像分类用，不可用于目标检测无标注文件数据集格式：仅仅包含jpg图片，每个类别文件夹下面存放着对应图片图片数量(jpg文件个数)：12882分类类别数：11类别名称:["Bacterial_Spot_Bacteria","Early_Blight_Fungus","Healthy","Late_Blight_Water_Mold","Leaf_Mold_Fungus","Powdery
遥感影像的切片处理 sand&wich 计算机视觉 python 图像处理
在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！小猪包333 写论文人工智能 AI写作深度学习计算机视觉
在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
[实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估 pytorch python 机器学习
文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
[实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用 pytorch 深度学习人工智能机器学习 python 优化器
文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
吴恩达深度学习笔记(30)-正则化的解释极客Array
正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
计算机视觉中，Pooling的作用 Wils0nEdwards 计算机视觉人工智能
在计算机视觉中，Pooling（池化）是一种常见的操作，主要用于卷积神经网络（CNN）中。它通过对特征图进行下采样，减少数据的空间维度，同时保留重要的特征信息。Pooling的作用可以归纳为以下几个方面：1.降低计算复杂度与内存需求Pooling操作通过对特征图进行下采样，减少了特征图的空间分辨率（例如，高度和宽度）。这意味着网络需要处理的数据量会减少，从而降低了计算量和内存需求。这对大型神经网络
OpenCV图像处理技术（Python）——入门森屿_ opencv
©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
损失函数与反向传播 Star_. PyTorch pytorch 深度学习 python
损失函数定义与作用损失函数(lossfunction)在深度学习领域是用来计算搭建模型预测的输出值和真实值之间的误差。1.损失函数越小越好2.计算实际输出与目标之间的差距3.为更新输出提供依据（反向传播)常见的损失函数回归常见的损失函数有：均方差（MeanSquaredError，MSE）、平均绝对误差（MeanAbsoluteErrorLoss，MAE）、HuberLoss是一种将MSE与MAE
【安装环境】配置MMTracking环境 xuanyu22 安装环境机器学习神经网络深度学习 python
版本v0.14.0安装torchnumpy的版本不能太高，否则后面安装时会发生冲突。先安装numpy，因为pytorch的安装会自动配置高版本numpy。condainstallnumpy=1.21.5mmtracking支持的torch版本有限，需要找到合适的condainstallpytorch==1.11.0torchvision==0.12.0cudatoolkit=10.2-cpytor
Python(PyTorch)和MATLAB及Rust和C++结构相似度指数测量导图亚图跨际 Python 交叉知识算法量化检查图像压缩质量低分辨率多光谱峰值信噪比端到端优化图像压缩手术机器人三维实景实时可微分渲染重建三维可视化
要点量化检查图像压缩质量低分辨率多光谱和高分辨率图像实现超分辨率分析图像质量图像索引/多尺度结构相似度指数和光谱角映射器及视觉信息保真度多种指标峰值信噪比和结构相似度指数测量结构相似性图像分类PNG和JPEG图像相似性近似算法图像压缩，视频压缩、端到端优化图像压缩、神经图像压缩、GPU变速图像压缩手术机器人深度估计算法重建三维可视化推理图像超分辨率算法模型三维实景实时可微分渲染算法MATLAB结构
【深度学习】训练过程中一个OOM的问题，太难查了 weixin_40293999 深度学习深度学习人工智能
现象：各位大佬又遇到过ubuntu的这个问题么？现象是在训练过程中，ssh上不去了，能ping通，没死机，但是ubunutu的pc侧的显示器，鼠标啥都不好用了。只能重启。问题原因：OOM了95G，尼玛！！！！pytorch爆内存了，然后journald假死了，在journald被watchdog干掉之后，系统就崩溃了。这种规模的爆内存一般，即使被oomkill了，也要卡半天的，确实会这样，能不能配
Pyorch中 nn.Conv1d 与 nn.Linear 的区别迪三 #NN_Layer 神经网络
即一维卷积层和全联接层的区别nn.Conv1d和nn.Linear都是PyTorch中的层，它们用于不同的目的，主要区别在于它们处理输入数据的方式和执行的操作类型。nn.Conv1d通过应用滑动过滤器来捕捉序列数据中的局部模式，适用于处理具有时间或序列结构的数据。nn.Linear通过将每个输入与每个输出相连接，捕捉全局关系，适用于将输入数据作为整体处理的任务。1.维度与输入nn.Conv1d（一
图片中的上采样，下采样和通道融合(up-sample, down-sample, channel confusion) 迪三 #图像处理_PyTorch 计算机视觉深度学习人工智能
前言以conv2d为例（即图片），Pytorch中输入的数据格式为tensor，格式为:[N,C,W,H,W]第一维N.代表图片个数，类似一个batch里面有N张图片第二维C.代表通道数，在模型中输入如果为彩色，常用RGB三色图，那么就是3维，即C=3。如果是黑白的，即灰度图，那么只有一个通道，即C=1第三维H.代表图片的高度，H的数量是图片像素的列数第四维W.代表图片的宽度，W的数量是图片像素的
CV、NLP、数据控掘推荐、量化海的那边- AI算法自然语言处理人工智能
下面是对CV（计算机视觉）、NLP（自然语言处理）、数据挖掘推荐和量化的简要概述及其应用领域的介绍：1.CV（计算机视觉，ComputerVision）定义：计算机视觉是一门让计算机能够从图像或视频中提取有用信息，并做出决策的学科。它通过模拟人类的视觉系统来识别、处理和理解视觉信息。主要任务：图像分类：识别图像中的物体并分类，比如猫、狗、车等。目标检测：在图像或视频中定位并识别多个对象，如人脸检测
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
机器学习VS深度学习 nfgo 机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
大数据毕业设计hadoop+spark+hive知识图谱租房数据分析可视化大屏租房推荐系统 58同城租房爬虫房源推荐系统房价预测系统计算机毕业设计机器学习深度学习人工智能 2401_84572577 程序员大数据 hadoop 人工智能
做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。我先来介绍一下这些东西怎么用，文末抱走。（1）Python所有方向的学习路线（
深度学习-13-小语言模型之SmolLM的使用皮皮冰燃深度学习深度学习
文章附录1SmolLM概述1.1SmolLM简介1.2下载模型2运行2.1在CPU/GPU/多GPU上运行模型2.2使用torch.bfloat162.3通过位和字节的量化版本3应用示例4问题及解决4.1attention_mask和pad_token_id报错4.2max_new_tokens=205参考附录1SmolLM概述1.1SmolLM简介SmolLM是一系列尖端小型语言模型，提供三种规
基于深度学习的农作物病害检测 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的农作物病害检测利用卷积神经网络（CNN）、生成对抗网络（GAN）、Transformer等深度学习技术，自动识别和分类农作物的病害，帮助农业工作者提高作物管理效率、减少损失。1.农作物病害检测的挑战病害种类繁多：农作物病害的类型多样，不同病害在同一作物上的表现差异很大，同时同一种病害在不同生长阶段的症状也可能不同。环境影响：天气、光照、湿度等外部环境因素会影响农作物的表现，使得病害检
基于深度学习的文本引导的图像编辑 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的文本引导的图像编辑（Text-GuidedImageEditing）是一种通过自然语言文本指令对图像进行编辑或修改的技术。它结合了图像生成和自然语言处理（NLP）的最新进展，使用户能够通过描述性文本对图像内容进行精确的调整和操控。1.文本引导的图像编辑的挑战文本和图像之间的对齐：如何将文本中的语义信息准确地映射到图像中的特定区域或元素是一个关键挑战。这涉及到多模态数据的对齐和理解。编
深度学习--对抗生成网络（GAN, Generative Adversarial Network） Ambition_LAO 深度学习生成对抗网络
对抗生成网络（GAN,GenerativeAdversarialNetwork）是一种深度学习模型，由IanGoodfellow等人在2014年提出。GAN主要用于生成数据，通过两个神经网络相互对抗，来生成以假乱真的新数据。以下是对GAN的详细阐述，包括其概念、作用、核心要点、实现过程、代码实现和适用场景。1.概念GAN由两个神经网络组成：生成器（Generator）和判别器（Discrimina
深度学习：怎么看pth文件的参数奥利给少年深度学习人工智能
.pth文件是PyTorch模型的权重文件，它通常包含了训练好的模型的参数。要查看或使用这个文件，你可以按照以下步骤操作：1.确保你有模型的定义你需要有创建这个.pth文件时所用的模型的代码。这意味着你需要有模型的类定义和架构。2.加载模型权重使用PyTorch的load_state_dict方法来加载权重。这里是如何操作的：importtorchimporttorch.nnasnn#定义模型结构
chatgpt赋能python：如何在Python中安装Keras库？ turensu ChatGpt python chatgpt keras 计算机
如何在Python中安装Keras库？Keras是一个简单易用的神经网络库，由FrançoisChollet编写。它在Python编程语言中实现了深度学习的功能，可以使您更轻松地构建和试验不同类型的神经网络。如果您是一名Python开发人员，肯定会想知道如何在您的Python项目中安装Keras库。在本文中，我们将向您展示如何安装和配置Keras库。步骤1：安装Python要使用Keras库，您需
iOS http封装 374016526 ios 服务器交互 http 网络请求
程序开发避免不了与服务器的交互，这里打包了一个自己写的http交互库。希望可以帮到大家。内置一个basehttp，当我们创建自己的service可以继承实现。 KuroAppBaseHttp *baseHttp = [[KuroAppBaseHttp alloc] init]; [baseHttp setDelegate:self]; [baseHttp
lolcat ：一个在 Linux 终端中输出彩虹特效的命令行工具 brotherlamp linux linux教程 linux视频 linux自学 linux资料
那些相信 Linux 命令行是单调无聊且没有任何乐趣的人们，你们错了，这里有一些有关 Linux 的文章，它们展示着 Linux 是如何的有趣和“淘气” 。在本文中，我将讨论一个名为“lolcat”的小工具 – 它可以在终端中生成彩虹般的颜色。何为 lolcat ? Lolcat 是一个针对 Linux，BSD 和 OSX 平台的工具，它类似于 cat 命令，并为 cat
MongoDB索引管理（1）——[九] eksliang mongodb MongoDB管理索引
转载请出自出处：http://eksliang.iteye.com/blog/2178427 一、概述数据库的索引与书籍的索引类似，有了索引就不需要翻转整本书。数据库的索引跟这个原理一样，首先在索引中找，在索引中找到条目以后，就可以直接跳转到目标文档的位置，从而使查询速度提高几个数据量级。不使用索引的查询称
Informatica参数及变量 18289753290 Informatica 参数变量
下面是本人通俗的理解，如有不对之处，希望指正 info参数的设置：在info中用到的参数都在server的专门的配置文件中（最好以parma）结尾下面的GLOBAl就是全局的，$开头的是系统级变量，$$开头的变量是自定义变量。如果是在session中或者mapping中用到的变量就是局部变量，那就把global换成对应的session或者mapping名字。 [GLOBAL] $Par
python 解析unicode字符串为utf8编码字符串酷的飞上天空 unicode
php返回的json字符串如果包含中文，则会被转换成\uxx格式的unicode编码字符串返回。在浏览器中能正常识别这种编码，但是后台程序却不能识别，直接输出显示的是\uxx的字符，并未进行转码。转换方式如下 >>> import json >>> q = '{"text":"\u4
Hibernate的总结永夜-极光 Hibernate
1.hibernate的作用,简化对数据库的编码,使开发人员不必再与复杂的sql语句打交道做项目大部分都需要用JAVA来链接数据库，比如你要做一个会员注册的页面，那么获取到用户填写的基本信后，你要把这些基本信息存入数据库对应的表中，不用hibernate还有mybatis之类的框架，都不用的话就得用JDBC，也就是JAVA自己的，用这个东西你要写很多的代码，比如保存注册信
SyntaxError: Non-UTF-8 code starting with '\xc4' 随便小屋 python
刚开始看一下Python语言，传说听强大的，但我感觉还是没Java强吧！写Hello World的时候就遇到一个问题，在Eclipse中写的，代码如下 ''' Created on 2014年10月27日 @author: Logic ''' print("Hello World!"); 运行结果 SyntaxError: Non-UTF-8
学会敬酒礼仪不做酒席菜鸟 aijuans 菜鸟
俗话说，酒是越喝越厚，但在酒桌上也有很多学问讲究，以下总结了一些酒桌上的你不得不注意的小细节。细节一：领导相互喝完才轮到自己敬酒。敬酒一定要站起来，双手举杯。细节二：可以多人敬一人，决不可一人敬多人，除非你是领导。细节三：自己敬别人，如果不碰杯，自己喝多少可视乎情况而定，比如对方酒量，对方喝酒态度，切不可比对方喝得少，要知道是自己敬人。细节四：自己敬别人，如果碰杯，一
《创新者的基因》读书笔记 aoyouzi 读书笔记《创新者的基因》
创新者的基因创新者的“基因”，即最具创意的企业家具备的五种“发现技能”：联想，观察，实验，发问，建立人脉。第一部分破坏性创新，从你开始第一章破坏性创新者的基因如何获得启示：发现以下的因素起到了催化剂的作用：(1) -个挑战现状的问题；(2)对某项技术、某个公司或顾客的观察；(3) -次尝试新鲜事物的经验或实验；(4)与某人进行了一次交谈，为他点醒
表单验证技术百合不是茶 JavaScript DOM对象 String对象事件
js最主要的功能就是验证表单,下面是我对表单验证的一些理解,贴出来与大家交流交流 ,数显我们要知道表单验证需要的技术点, String对象,事件,函数一:String对象;通常是对字符串的操作; 1,String的属性; 字符串.length;表示该字符串的长度; var str= "java"
web.xml配置详解之context-param bijian1013 java servlet web.xml context-param
一.格式定义： <context-param> <param-name>contextConfigLocation</param-name> <param-value>contextConfigLocationValue></param-value> </context-param> 作用：该元
Web系统常见编码漏洞（开发工程师知晓） Bill_chen sql PHP Web fckeditor 脚本
1.头号大敌：SQL Injection 原因：程序中对用户输入检查不严格，用户可以提交一段数据库查询代码，根据程序返回的结果，获得某些他想得知的数据，这就是所谓的SQL Injection，即SQL注入。本质: 对于输入检查不充分，导致SQL语句将用户提交的非法数据当作语句的一部分来执行。示例： String query = "SELECT id FROM users
【MongoDB学习笔记六】MongoDB修改器 bit1129 mongodb
本文首先介绍下MongoDB的基本的增删改查操作，然后，详细介绍MongoDB提供的修改器，以完成各种各样的文档更新操作 MongoDB的主要操作 show dbs 显示当前用户能看到哪些数据库 use foobar 将数据库切换到foobar show collections 显示当前数据库有哪些集合 db.people.update，update不带参数，可
提高职业素养，做好人生规划白糖_ 人生
培训讲师是成都著名的企业培训讲师，他在讲课中提出的一些观点很新颖，在此我收录了一些分享一下。注：讲师的观点不代表本人的观点，这些东西大家自己揣摩。 1、什么是职业规划：职业规划并不完全代表你到什么阶段要当什么官要拿多少钱，这些都只是梦想。职业规划是清楚的认识自己现在缺什么，这个阶段该学习什么，下个阶段缺什么，又应该怎么去规划学习，这样才算是规划。
国外的网站你都到哪边看？ bozch 技术网站国外
学习软件开发技术，如果没有什么英文基础，最好还是看国内的一些技术网站，例如：开源OSchina，csdn，iteye,51cto等等。个人感觉如果英语基础能力不错的话，可以浏览国外的网站来进行软件技术基础的学习，例如java开发中常用的到的网站有apache.org 里面有apache的很多Projects,springframework.org是spring相关的项目网站,还有几个感觉不错的
编程之美-光影切割问题 bylijinnan 编程之美
package a; public class DisorderCount { /**《编程之美》“光影切割问题” * 主要是两个问题： * 1.数学公式（设定没有三条以上的直线交于同一点）： * 两条直线最多一个交点，将平面分成了4个区域； * 三条直线最多三个交点，将平面分成了7个区域； * 可以推出：N条直线 M个交点，区域数为N+M+1。
关于Web跨站执行脚本概念 chenbowen00 Web 安全跨站执行脚本
跨站脚本攻击(XSS)是web应用程序中最危险和最常见的安全漏洞之一。安全研究人员发现这个漏洞在最受欢迎的网站,包括谷歌、Facebook、亚马逊、PayPal,和许多其他网站。如果你看看bug赏金计划,大多数报告的问题属于 XSS。为了防止跨站脚本攻击,浏览器也有自己的过滤器,但安全研究人员总是想方设法绕过这些过滤器。这个漏洞是通常用于执行cookie窃取、恶意软件传播,会话劫持,恶意重定向。在
[开源项目与投资]投资开源项目之前需要统计该项目已有的用户数 comsci 开源项目
现在国内和国外,特别是美国那边,突然出现很多开源项目,但是这些项目的用户有多少,有多少忠诚的粉丝,对于投资者来讲,完全是一个未知数,那么要投资开源项目,我们投资者必须准确无误的知道该项目的全部情况,包括项目发起人的情况,项目的维持时间..项目的技术水平,项目的参与者的势力,项目投入产出的效益.....
oracle alert log file（告警日志文件） daizj oracle 告警日志文件 alert log file
The alert log is a chronological log of messages and errors, and includes the following items: All internal errors (ORA-00600), block corruption errors (ORA-01578), and deadlock errors (ORA-00060)
关于 CAS SSO 文章声明 denger SSO
由于几年前写了几篇 CAS 系列的文章，之后陆续有人参照文章去实现，可都遇到了各种问题，同时经常或多或少的收到不少人的求助。现在这时特此说明几点： 1. 那些文章发表于好几年前了，CAS 已经更新几个很多版本了，由于近年已经没有做该领域方面的事情，所有文章也没有持续更新。 2. 文章只是提供思路，尽管 CAS 版本已经发生变化，但原理和流程仍然一致。最重要的是明白原理，然后
初二上学期难记单词 dcj3sjt126com english word
lesson 课 traffic 交通 matter 要紧；事物 happy 快乐的，幸福的 second 第二的 idea 主意；想法；意见 mean 意味着 important 重要的，重大的 never 从来，决不 afraid 害怕的 fifth 第五的 hometown 故乡，家乡 discuss 讨论；议论 east 东方的 agree 同意；赞成 bo
uicollectionview 纯代码布局, 添加头部视图 dcj3sjt126com Collection
#import <UIKit/UIKit.h> @interface myHeadView : UICollectionReusableView { UILabel *TitleLable; } -(void)setTextTitle; @end #import "myHeadView.h" @implementation m
N 位随机数字串的 JAVA 生成实现 FX夜归人 java Math 随机数 Random
/** * 功能描述随机数工具类<br /> * @author FengXueYeGuiRen * 创建时间 2014-7-25<br /> */ public class RandomUtil { // 随机数生成器 private static java.util.Random random = new java.util.R
Ehcache（09）——缓存Web页面 234390216 ehcache 页面缓存
页面缓存目录 1 SimplePageCachingFilter 1.1 calculateKey 1.2 可配置的初始化参数 1.2.1 cach
spring中少用的注解@primary解析 jackyrong primary
这次看下spring中少见的注解@primary注解，例子 @Component public class MetalSinger implements Singer{ @Override public String sing(String lyrics) { return "I am singing with DIO voice
Java几款性能分析工具的对比 lbwahoo java
Java几款性能分析工具的对比摘自：http://my.oschina.net/liux/blog/51800 在给客户的应用程序维护的过程中，我注意到在高负载下的一些性能问题。理论上，增加对应用程序的负载会使性能等比率的下降。然而，我认为性能下降的比率远远高于负载的增加。我也发现，性能可以通过改变应用程序的逻辑来提升，甚至达到极限。为了更详细的了解这一点，我们需要做一些性能
JVM参数配置大全 nickys jvm 应用服务器
JVM参数配置大全 /usr/local/jdk/bin/java -Dresin.home=/usr/local/resin -server -Xms1800M -Xmx1800M -Xmn300M -Xss512K -XX:PermSize=300M -XX:MaxPermSize=300M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=5 -
搭建 CentOS 6 服务器(14) - squid、Varnish rensanning varnish
（一）squid 安装 # yum install httpd-tools -y # htpasswd -c -b /etc/squid/passwords squiduser 123456 # yum install squid -y 设置 # cp /etc/squid/squid.conf /etc/squid/squid.conf.bak # vi /etc/
Spring缓存注解@Cache使用 tom_seed spring
参考资料 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ http://swiftlet.net/archives/774 缓存注解有以下三个： @Cacheable @CacheEvict @CachePut
dom4j解析XML时出现"java.lang.noclassdeffounderror: org/jaxen/jaxenexception"错误 xp9802
java.lang.NoClassDefFoundError: org/jaxen/JaxenExc 关键字: java.lang.noclassdeffounderror: org/jaxen/jaxenexception 使用dom4j解析XML时，要快速获取某个节点的数据，使用XPath是个不错的方法，dom4j的快速手册里也建议使用这种方式执行时却抛出以下异常： Exceptio

Inception v3

你可能感兴趣的:(#,图像分类,深度学习,pytorch,计算机视觉)