Horizon Max

[ 轻量级网络 ] 经典网络模型4——Xception 详解与复现

Author ：Horizon Max

✨ 编程技巧篇：各种操作小结

机器视觉篇：会变魔术 OpenCV

深度学习篇：简单入门 PyTorch

神经网络篇：经典网络模型

算法篇：再忙也别忘了 LeetCode

[ 轻量级网络 ] 经典网络模型4——Xception 详解与复现

Xception
Xception 详解
- Xception 网络结构
- - 结构探索
  - Xception 结构框图
  - Xception 实验测试
Xception 复现

Xception

Xception 是一种受启发于 Inception 的新颖深度卷积神经网络架构；

将 Inception 模块替换为 深度可分离卷积( depthwise separable convolution ) ；

Xception 与 Inception V3 具有相同数量的参数，但由于模型参数的更有效使用，使得性能进一步的提高；

论文地址：Xception: Deep Learning with Depthwise Separable Convolutions

Xception 详解

Xception 网络结构

结构探索

（1）初始的 Inception 模块：

Inception V3 module

（2）简化 Inception 模块，仅包含 3×3卷积去掉简单的模块和平均池化：

A simple Inception module

（3）将所有 1×1卷积进行拼接：

the simplified Inception module

（4）使 3×3卷积的数量与 1×1卷积输出通道的数量相等：

An “extreme” version of Inception module

Extreme Inception 也就是作者提出的新结构 —— Xception ；

Xception 结构框图

Xception 结构有36个卷积层，构成网络特征提取的基础；

每一层后面都接有 逻辑回归层 ，在逻辑回归层前可能会随机插入 全连接层 ；

将36个卷积层结构分为14个模块，除了第一个和最后一个模块，每个模块都有 残差结构 连接；

Xception 实验测试

Classification performance comparison on ImageNet

Size and training speed comparison

Xception 复现

# Here is the code :

import torch
import torch.nn as nn
from torchinfo import summary


class SeparableConv(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=1, stride=1, padding=0, dilation=1):
        super(SeparableConv, self).__init__()

        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size, stride, padding,
                               dilation, groups=in_channels, bias=False)
        self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0,
                                   dilation=1, groups=1, bias=False)

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


class Block(nn.Module):
    def __init__(self, in_channels, out_channels, num_conv, strides=1, start_with_relu=True, channel_change=True):
        super(Block, self).__init__()

        if out_channels != in_channels or strides != 1:
            self.shutcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 1, stride=strides, bias=False),
                nn.BatchNorm2d(out_channels)
            )
        else:
            self.shutcut = nn.Sequential()

        layers = []
        channels = in_channels

        if channel_change:
            layers.append(nn.ReLU(inplace=True))
            layers.append(SeparableConv(in_channels, out_channels, 3, stride=1, padding=1))
            layers.append(nn.BatchNorm2d(out_channels))
            channels = out_channels

        for i in range(num_conv - 1):
            layers.append(nn.ReLU(inplace=True))
            layers.append(SeparableConv(channels, channels, 3, stride=1, padding=1))
            layers.append(nn.BatchNorm2d(channels))

        if not channel_change:
            layers.append(nn.ReLU(inplace=True))
            layers.append(SeparableConv(in_channels, out_channels, 3, stride=1, padding=1))
            layers.append(nn.BatchNorm2d(out_channels))

        if start_with_relu:
            layers = layers
        else:
            layers = layers[1:]

        if strides != 1:
            layers.append(nn.MaxPool2d(3, strides, 1))

        self.layers = nn.Sequential(*layers)

    def forward(self, x):
        layer = self.layers(x)
        shutcut = self.shutcut(x)
        out = layer + shutcut
        return out


class Xception(nn.Module):
    def __init__(self, num_classes=1000):

        super(Xception, self).__init__()

        self.num_classes = num_classes

        # Entry flow
        self.entry_flow = nn.Sequential(
            nn.Conv2d(3, 32, 3, 2, bias=False),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),

            nn.Conv2d(32, 64, 3, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),

            Block(64, 128, 2, 2, start_with_relu=False, channel_change=True),
            Block(128, 256, 2, 2, start_with_relu=True, channel_change=True),
            Block(256, 728, 2, 2, start_with_relu=True, channel_change=True),
        )

        # Middle flow
        self.middle_flow = nn.Sequential(
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
            Block(728, 728, 3, 1, start_with_relu=True, channel_change=True),
        )

        # Exit flow
        self.exit_flow = nn.Sequential(
            Block(728, 1024, 2, 2, start_with_relu=True, channel_change=False),

            SeparableConv(1024, 1536, 3, 1, 1),
            nn.BatchNorm2d(1536),
            nn.ReLU(inplace=True),

            SeparableConv(1536, 2048, 3, 1, 1),
            nn.BatchNorm2d(2048),
            nn.ReLU(inplace=True),

            nn.AdaptiveAvgPool2d((1, 1)),
        )

        self.fc = nn.Linear(2048, num_classes)

    def forward(self, x):
        x = self.entry_flow(x)
        x = self.middle_flow(x)
        x = self.exit_flow(x)

        x = x.view(x.size(0), -1)
        out = self.fc(x)
        return out


def test():
    net = Xception()
    y = net(torch.randn(1, 3, 224, 224))
    print(y.size())
    summary(net, (1, 3, 224, 224), depth=5)


if __name__ == '__main__':
    test()

输出结果：

torch.Size([1, 1000])
===============================================================================================
Layer (type:depth-idx)                        Output Shape              Param #
===============================================================================================
Xception                                      --                        --
├─Sequential: 1-1                             [1, 728, 14, 14]          --
│    └─Conv2d: 2-1                            [1, 32, 111, 111]         864
│    └─BatchNorm2d: 2-2                       [1, 32, 111, 111]         64
│    └─ReLU: 2-3                              [1, 32, 111, 111]         --
│    └─Conv2d: 2-4                            [1, 64, 109, 109]         18,432
│    └─BatchNorm2d: 2-5                       [1, 64, 109, 109]         128
│    └─ReLU: 2-6                              [1, 64, 109, 109]         --
│    └─Block: 2-7                             [1, 128, 55, 55]          --
│    │    └─Sequential: 3-1                   [1, 128, 55, 55]          --
│    │    │    └─SeparableConv: 4-1           [1, 128, 109, 109]        --
│    │    │    │    └─Conv2d: 5-1             [1, 64, 109, 109]         576
│    │    │    │    └─Conv2d: 5-2             [1, 128, 109, 109]        8,192
│    │    │    └─BatchNorm2d: 4-2             [1, 128, 109, 109]        256
│    │    │    └─ReLU: 4-3                    [1, 128, 109, 109]        --
│    │    │    └─SeparableConv: 4-4           [1, 128, 109, 109]        --
│    │    │    │    └─Conv2d: 5-3             [1, 128, 109, 109]        1,152
│    │    │    │    └─Conv2d: 5-4             [1, 128, 109, 109]        16,384
│    │    │    └─BatchNorm2d: 4-5             [1, 128, 109, 109]        256
│    │    │    └─MaxPool2d: 4-6               [1, 128, 55, 55]          --
│    │    └─Sequential: 3-2                   [1, 128, 55, 55]          --
│    │    │    └─Conv2d: 4-7                  [1, 128, 55, 55]          8,192
│    │    │    └─BatchNorm2d: 4-8             [1, 128, 55, 55]          256
│    └─Block: 2-8                             [1, 256, 28, 28]          --
│    │    └─Sequential: 3-3                   [1, 256, 28, 28]          --
│    │    │    └─ReLU: 4-9                    [1, 128, 55, 55]          --
│    │    │    └─SeparableConv: 4-10          [1, 256, 55, 55]          --
│    │    │    │    └─Conv2d: 5-5             [1, 128, 55, 55]          1,152
│    │    │    │    └─Conv2d: 5-6             [1, 256, 55, 55]          32,768
│    │    │    └─BatchNorm2d: 4-11            [1, 256, 55, 55]          512
│    │    │    └─ReLU: 4-12                   [1, 256, 55, 55]          --
│    │    │    └─SeparableConv: 4-13          [1, 256, 55, 55]          --
│    │    │    │    └─Conv2d: 5-7             [1, 256, 55, 55]          2,304
│    │    │    │    └─Conv2d: 5-8             [1, 256, 55, 55]          65,536
│    │    │    └─BatchNorm2d: 4-14            [1, 256, 55, 55]          512
│    │    │    └─MaxPool2d: 4-15              [1, 256, 28, 28]          --
│    │    └─Sequential: 3-4                   [1, 256, 28, 28]          --
│    │    │    └─Conv2d: 4-16                 [1, 256, 28, 28]          32,768
│    │    │    └─BatchNorm2d: 4-17            [1, 256, 28, 28]          512
│    └─Block: 2-9                             [1, 728, 14, 14]          --
│    │    └─Sequential: 3-5                   [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-18                   [1, 256, 28, 28]          --
│    │    │    └─SeparableConv: 4-19          [1, 728, 28, 28]          --
│    │    │    │    └─Conv2d: 5-9             [1, 256, 28, 28]          2,304
│    │    │    │    └─Conv2d: 5-10            [1, 728, 28, 28]          186,368
│    │    │    └─BatchNorm2d: 4-20            [1, 728, 28, 28]          1,456
│    │    │    └─ReLU: 4-21                   [1, 728, 28, 28]          --
│    │    │    └─SeparableConv: 4-22          [1, 728, 28, 28]          --
│    │    │    │    └─Conv2d: 5-11            [1, 728, 28, 28]          6,552
│    │    │    │    └─Conv2d: 5-12            [1, 728, 28, 28]          529,984
│    │    │    └─BatchNorm2d: 4-23            [1, 728, 28, 28]          1,456
│    │    │    └─MaxPool2d: 4-24              [1, 728, 14, 14]          --
│    │    └─Sequential: 3-6                   [1, 728, 14, 14]          --
│    │    │    └─Conv2d: 4-25                 [1, 728, 14, 14]          186,368
│    │    │    └─BatchNorm2d: 4-26            [1, 728, 14, 14]          1,456
├─Sequential: 1-2                             [1, 728, 14, 14]          --
│    └─Block: 2-10                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-7                   [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-27                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-28          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-13            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-14            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-29            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-30                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-31          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-15            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-16            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-32            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-33                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-34          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-17            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-18            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-35            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-8                   [1, 728, 14, 14]          --
│    └─Block: 2-11                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-9                   [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-36                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-37          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-19            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-20            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-38            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-39                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-40          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-21            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-22            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-41            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-42                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-43          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-23            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-24            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-44            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-10                  [1, 728, 14, 14]          --
│    └─Block: 2-12                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-11                  [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-45                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-46          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-25            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-26            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-47            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-48                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-49          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-27            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-28            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-50            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-51                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-52          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-29            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-30            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-53            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-12                  [1, 728, 14, 14]          --
│    └─Block: 2-13                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-13                  [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-54                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-55          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-31            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-32            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-56            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-57                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-58          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-33            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-34            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-59            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-60                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-61          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-35            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-36            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-62            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-14                  [1, 728, 14, 14]          --
│    └─Block: 2-14                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-15                  [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-63                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-64          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-37            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-38            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-65            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-66                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-67          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-39            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-40            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-68            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-69                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-70          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-41            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-42            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-71            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-16                  [1, 728, 14, 14]          --
│    └─Block: 2-15                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-17                  [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-72                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-73          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-43            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-44            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-74            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-75                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-76          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-45            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-46            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-77            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-78                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-79          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-47            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-48            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-80            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-18                  [1, 728, 14, 14]          --
│    └─Block: 2-16                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-19                  [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-81                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-82          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-49            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-50            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-83            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-84                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-85          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-51            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-52            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-86            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-87                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-88          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-53            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-54            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-89            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-20                  [1, 728, 14, 14]          --
│    └─Block: 2-17                            [1, 728, 14, 14]          --
│    │    └─Sequential: 3-21                  [1, 728, 14, 14]          --
│    │    │    └─ReLU: 4-90                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-91          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-55            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-56            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-92            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-93                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-94          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-57            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-58            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-95            [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-96                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-97          [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-59            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-60            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-98            [1, 728, 14, 14]          1,456
│    │    └─Sequential: 3-22                  [1, 728, 14, 14]          --
├─Sequential: 1-3                             [1, 2048, 1, 1]           --
│    └─Block: 2-18                            [1, 1024, 7, 7]           --
│    │    └─Sequential: 3-23                  [1, 1024, 7, 7]           --
│    │    │    └─ReLU: 4-99                   [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-100         [1, 728, 14, 14]          --
│    │    │    │    └─Conv2d: 5-61            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-62            [1, 728, 14, 14]          529,984
│    │    │    └─BatchNorm2d: 4-101           [1, 728, 14, 14]          1,456
│    │    │    └─ReLU: 4-102                  [1, 728, 14, 14]          --
│    │    │    └─SeparableConv: 4-103         [1, 1024, 14, 14]         --
│    │    │    │    └─Conv2d: 5-63            [1, 728, 14, 14]          6,552
│    │    │    │    └─Conv2d: 5-64            [1, 1024, 14, 14]         745,472
│    │    │    └─BatchNorm2d: 4-104           [1, 1024, 14, 14]         2,048
│    │    │    └─MaxPool2d: 4-105             [1, 1024, 7, 7]           --
│    │    └─Sequential: 3-24                  [1, 1024, 7, 7]           --
│    │    │    └─Conv2d: 4-106                [1, 1024, 7, 7]           745,472
│    │    │    └─BatchNorm2d: 4-107           [1, 1024, 7, 7]           2,048
│    └─SeparableConv: 2-19                    [1, 1536, 7, 7]           --
│    │    └─Conv2d: 3-25                      [1, 1024, 7, 7]           9,216
│    │    └─Conv2d: 3-26                      [1, 1536, 7, 7]           1,572,864
│    └─BatchNorm2d: 2-20                      [1, 1536, 7, 7]           3,072
│    └─ReLU: 2-21                             [1, 1536, 7, 7]           --
│    └─SeparableConv: 2-22                    [1, 2048, 7, 7]           --
│    │    └─Conv2d: 3-27                      [1, 1536, 7, 7]           13,824
│    │    └─Conv2d: 3-28                      [1, 2048, 7, 7]           3,145,728
│    └─BatchNorm2d: 2-23                      [1, 2048, 7, 7]           4,096
│    └─ReLU: 2-24                             [1, 2048, 7, 7]           --
│    └─AdaptiveAvgPool2d: 2-25                [1, 2048, 1, 1]           --
├─Linear: 1-4                                 [1, 1000]                 2,049,000
===============================================================================================
Total params: 22,855,952
Trainable params: 22,855,952
Non-trainable params: 0
Total mult-adds (G): 4.55
===============================================================================================
Input size (MB): 0.60
Forward/backward pass size (MB): 250.18
Params size (MB): 91.42
Estimated Total Size (MB): 342.20
===============================================================================================

Python语言的安全开发慕璃嫣包罗万象 golang 开发语言后端
Python语言的安全开发引言在信息技术迅速发展的今天，网络安全问题愈发凸显。随着Python语言的广泛应用，尤其是在数据分析、人工智能、Web开发等领域，其安全问题越来越受到重视。Python作为一门高效且易于学习的编程语言，虽然在开发过程中为我们提供了很多便利，但如果忽视了安全性，将可能导致严重的安全漏洞和数据泄露等问题。因此，本文将围绕Python语言的安全开发展开讨论，重点分析常见的安全问
如果我想设计一款复古风格的壁纸，应该选什么颜色？ 2401_89910411 前端 html
设计复古风格的壁纸时，选择合适的颜色是营造怀旧和经典氛围的关键。复古风格通常使用一些温暖、柔和且带有岁月痕迹的色调。以下是一些适合复古风格壁纸的颜色选择和搭配建议：一、复古风格的主色调棕色系：特点：棕色是复古风格的经典颜色，带有温暖和质朴的感觉，适合营造自然和怀旧的氛围。应用：可以作为背景色，搭配一些木质纹理或纸张纹理，增加质感。例如，深棕色的背景可以搭配浅棕色的木纹，营造出复古的书架效果。示例：
全面解析文件包含漏洞：原理、危害与防护垚垚 Securify 前沿站十大漏洞网络安全 web安全系统安全网络安全
目录前言漏洞介绍漏洞原理产生条件攻击方式造成的影响经典漏洞介绍防御措施结语前言在当今复杂的网络安全环境中，文件包含漏洞就像潜藏在暗处的危险陷阱，随时可能对防护薄弱的Web应用发起致命攻击。随着互联网的迅猛发展，各类Web应用如雨后春笋般涌现，文件包含漏洞也随之成为Web应用安全的一大隐患。深入了解文件包含漏洞的原理、危害及防范措施，对于保障网络安全、维护数据隐私以及确保系统稳定运行至关重要。漏洞介
获取PPT中的MSO格式图片报错 ♢.＊ ppt python
亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、Java与Python的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！image.ext的报错ValueEr
知识图谱技术剖析 ♢.＊人工智能知识图谱大数据
亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、Java与Python的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！一、引言在当今数字化信息爆炸的时代，如
Deepseek技术浅析（一）爱研究的小牛 AIGC—概述大模型 AIGC 人工智能深度学习自然语言处理
DeepSeek是北京深度求索人工智能基础技术研究有限公司推出的人工智能技术品牌，专注于大语言模型（LLM）的研发与应用。其技术涵盖了从模型架构、训练方法到应用部署的多个层面，展现出强大的创新能力和应用潜力。以下将详细介绍DeepSeek的核心技术、工作原理以及具体实现方式。一、核心技术1.大语言模型（LLM）DeepSeek的核心产品是自研的大语言模型，其主要特点包括：(1)基于Transfor
启元世界（Inspir.ai）技术浅析（一）爱研究的小牛 AIGC—游戏制作人工智能机器学习 AIGC 深度学习
启元世界（Inspir.ai）作为全球领先的通用人工智能平台公司，自2017年成立以来，一直致力于通过人工智能技术提升产业效能和生活体验。公司汇聚了来自全球顶尖公司和高等学府的技术专家，专注于深度强化学习、推荐算法以及机器学习系统平台等前沿领域，并成功将人工智能技术应用于数字娱乐、智能决策和机器人等多个领域。一、核心技术启元世界在人工智能领域取得了多项突破性进展，其核心技术涵盖了以下几个方面：1.
Lumen5——AI视频制作，提取关键信息生成带有视觉效果的视频爱研究的小牛 AIGC—视频人工智能 AIGC 深度学习
一、Lumen5介绍Lumen5是一款基于人工智能的自动化视频制作平台，专为非专业用户设计，帮助其将博客、文章、新闻等文字内容快速转换为视频。Lumen5的目标是简化视频制作流程，让内容创作者、市场营销人员、社交媒体团队等无需视频制作经验即可轻松制作吸引观众的高质量视频。二、Lumen5的主要功能文字转视频Lumen5最具特色的功能是通过AI自动将文本转化为视频。用户可以输入一段文字或直接粘贴文章
python神经网络框架有哪些,python调用神经网络模型小明技术分享 python 神经网络深度学习
人工智能Python深度学习库有哪些由于Python的易用性和可扩展性，众多深度学习框架提供了Python接口，其中较为流行的深度学习库如下：第一：CaffeCaffe是一个以表达式、速度和模块化为核心的深度学习框架，具备清晰、可读性高和快速的特性，在视频、图像处理方面应用较多。Caffe中的网络结构与优化都以配置文件形式定义，容易上手，无须通过代码构建网络;网络训练速度快，能够训练大型数据集与S
人工智能的前景与未来就业市场：机遇、挑战与社会影响苹果酱0567 面试题汇总与解析 java 开发语言中间件 spring boot 后端
随着科技的飞速发展，人工智能（AI）已经逐渐渗透到我们生活的方方面面，它不仅引领着技术革新的浪潮，更在无声中重塑着我们的就业市场和社会结构。站在这个时代的交汇点上，我们不禁要问：人工智能将如何影响我们的未来就业市场？它带来的究竟是机遇还是挑战？回望过去，每一次科技革命都伴随着就业市场的剧烈震荡。而今，人工智能作为第四次工业革命的核心驱动力，正以前所未有的速度改变着劳动力市场的格局。从自动化生产线上
Python实现复原毫米波雷达呼吸波形的示例 go5463158465 python 算法机器学习 python 开发语言
以下是一个使用Python实现复原毫米波雷达呼吸波形的示例，该示例将涉及模型算法在重建损失和KL（Kullback-Leibler）损失之间的平衡问题。我们将使用深度学习中的变分自编码器（VAE）作为模型来进行呼吸波形的复原，因为VAE可以很好地处理重建和潜在空间分布的问题。步骤概述数据准备：生成或加载毫米波雷达的呼吸波形数据。定义VAE模型：包括编码器和解码器。定义损失函数：结合重建损失和KL损
对话系统(Chatbots) 原理与代码实例讲解 AI天才研究院 AI大模型企业级应用开发实战大数据AI人工智能计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
1.背景介绍1.1对话系统的发展历程对话系统，又称聊天机器人(Chatbots)，是模拟人类对话的计算机程序。从早期的基于规则的系统到如今基于深度学习的智能体，对话系统经历了漫长的发展历程。第一阶段：基于规则的系统(1960s-1990s)早期的对话系统主要基于预先定义的规则和模板。例如，ELIZA(1966)是一个模拟心理治疗师的程序，通过模式匹配和关键词识别来生成回复。这些系统只能处理有限的对
如何使用深度学习中的 Transformer 算法进行视频目标检测 go5463158465 python 算法深度学习 python 开发语言
以下将介绍如何使用深度学习中的Transformer算法进行视频目标检测，并给出一个复现相关论文思路及示例代码。这里以DETR（End-to-EndObjectDetectionwithTransformers）为基础进行说明，它是将Transformer引入目标检测领域的经典论文。步骤概述环境准备：安装必要的库，如PyTorch、torchvision等。数据准备：使用公开的视频目标检测数据集，
探索SakuraLLM：轻小说与Galgame翻译的新纪元蒋素萍Marilyn
探索SakuraLLM：轻小说与Galgame翻译的新纪元SakuraLLM适配轻小说/Galgame的日中翻译大模型项目地址:https://gitcode.com/gh_mirrors/sa/SakuraLLM在人工智能的浪潮中，SakuraLLM以其独特的魅力和强大的功能，成为了日中翻译领域的一颗璀璨明星。本文将深入介绍SakuraLLM项目，分析其技术特点，探讨其应用场景，并揭示其与众不同
大模型问答机器人的智能化程度 AI大模型应用之禅 AI大模型与大数据 java python javascript kotlin golang 架构人工智能
大模型、问答机器人、智能化程度、自然语言处理、深度学习、Transformer模型、知识图谱、推理能力、对话系统1.背景介绍近年来，人工智能技术取得了飞速发展，特别是深度学习的兴起，为自然语言处理（NLP）领域带来了革命性的变革。其中，大模型问答机器人作为一种新型的智能交互系统，凭借其强大的语言理解和生成能力，在客服、教育、娱乐等领域展现出广阔的应用前景。问答机器人是指能够理解用户自然语言问题并给
【笔记】从华为云看4P理论的卓越践行者通信_楠木笔记华为云系统架构用户运营产品运营产品经理
在当今竞争激烈的云计算市场中，华为云犹如一颗明星取得了令人瞩目的成绩。其成功的背后，离不开对4P营销理论——产品（Product）、价格（Price）、渠道（Place）、促销（Promotion）的巧妙运用与深度融合。这一经典的营销理论框架，在华为云的市场战略布局中被赋予了新的活力与内涵，下面就结合最近的学习总结，让我们深入探究华为云是如何运用4P营销理论书写其辉煌篇章的。学习是一种愉悦，一种收
SpringBoot中运行Yolov5程序 eqa11 spring boot YOLO 后端
文章目录SpringBoot中运行Yolov5程序一、引言二、环境搭建1、SpringBoot项目创建2、YOLOv5环境配置三、SpringBoot与YOLOv5集成1、创建Python服务2、SpringBoot调用Python服务四、使用示例1、创建控制器五、总结SpringBoot中运行Yolov5程序一、引言在人工智能领域，目标检测是一个热门且实用的技术。YOLOv5作为目标检测算法中的
大语言模型原理与工程实践：残差连接与层归一化 AI大模型应用之禅 AI大模型与大数据计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
1.背景介绍随着自然语言处理（NLP）的发展，深度学习在过去几年中取得了令人瞩目的成果。其中，循环神经网络（RNN）和卷积神经网络（CNN）在图像和文本分类、语义角色标注、机器翻译等领域表现出色。然而，这些网络在训练过程中经常遭遇梯度消失和梯度爆炸的问题。为了解决这些问题，我们引入了残差连接（ResidualConnections）和层归一化（BatchNormalization）来改善模型性能。
阿里巴巴Qwen团队发布AI模型，可操控PC和手机新加坡内哥谈技术人工智能深度学习语言模型学习
每周跟踪AI热点新闻动向和震撼发展想要探索生成式人工智能的前沿进展吗？订阅我们的简报，深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同，从行业内部的深度分析和实用指南中受益。不要错过这个机会，成为AI领域的领跑者。点击订阅，与未来同行！订阅：https://rengongzhineng.io/这周，科技界的目光几乎都被DeepSeek的R1模型吸引，但阿里巴巴并没有袖手旁观。1月
对比DeepSeek、ChatGPT和Kimi的学术写作摘要能力 AIWritePaper官方账号 DeepSeek AIWritePaper ChatGPT 人工智能 chatgpt llama 数据分析论文阅读
摘要摘要是文章的精华，通常在200-250词左右。要包括研究的目的、方法、结果和结论。让AI工具作为某领域内资深的研究专家，编写摘要需要言简意赅，直接概括论文的核心，为读者提供快速了解的窗口。下面我们使用DeepSeek、ChatGPT4以及Kimi辅助编写摘要。提示词：你现在是一名[计算机理论专家]，研究方向集中在[人工智能、大模型、数据挖掘等计算机相关方向]。我现在需要撰写一篇围绕[人工智能在
Transformer架构的GPU并行和之前的NLP算法并行有什么不同？ AI大模型学习不迷路 transformer 自然语言处理大模型深度学习 NLP LLM 大语言模型
1.什么是GPU并行计算？GPU并行计算是一种利用图形处理单元（GPU）进行大规模并行数据处理的技术。与传统的中央处理单元（CPU）相比，GPU拥有更多的核心，能够同时处理数千个线程，这使得GPU在处理高度并行的任务时表现出色。在深度学习中，GPU并行计算被广泛应用于训练神经网络，加速模型训练过程。在2017年之前，自然语言处理（NLP）领域的研究者们通常会从头开始训练模型，那时能够利用GPU进行
计算机视觉：解锁未来智能的钥匙及其代码实践我的运维人生计算机视觉人工智能运维开发技术共享
计算机视觉：解锁未来智能的钥匙及其代码实践在当今这个数据爆炸的时代，计算机视觉作为人工智能的一个重要分支，正以前所未有的速度推动着科技的边界。它不仅让机器“看懂”世界，更在自动驾驶、医疗影像分析、智能制造、安防监控等众多领域展现出巨大的应用潜力。本文将深入探讨计算机视觉的核心技术、最新进展，并通过一个具体的代码案例，展示如何在实践中应用这些技术，旨在为读者提供一个理论与实践相结合的全面视角。一、计
ImportError: DLL load failed while importing _rust: 找不到指定的程序的解决方案爱编程的喵喵 Python基础课程 python ImportError DLL load failed _rust 解决方案
大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。本文主要介绍了ImportError:DLLloa
《向量数据库指南》——MoE应用：解锁深度学习新境界的钥匙大禹智库《实战AI智能体》《向量数据库指南》深度学习人工智能向量数据库大禹智库低代码 MoE模型
在深度学习的广阔天地里，混合专家（MoE）模型如同一把锐利的钥匙，正逐步解锁着各种复杂应用场景的新境界。作为大禹智库的向量数据库高级研究员，同时也是《向量数据库指南》的作者，我深感MoE模型在推动AI技术向前发展中所扮演的重要角色。今天，我将带大家深入探讨MoE模型在自然语言处理、计算机视觉以及多模态学习等领域的应用，并巧妙引导大家通过《向量数据库指南》获取更多干货和深度实战经验。一、自然语言处理
C语言经典贪心算法之加油站问题（详解）鸿蒙Next C语言算法算法 c语言贪心算法数据结构程序人生
文章目录一、贪心算法二、加油站问题一、贪心算法贪心算法暗示一种不追求最优解，只希望找到较为满意解的方法。贪心算法省去了为找最优解要穷尽所有可能而必须耗费大量时间，因此它一般可以快速得到较为满意的答案。贪心算法常常以当前情况为基础做最优选择，而不考虑各种的整体情况，所以贪心算法不需要回溯。二、加油站问题1、问题一辆汽车加满油后可以行驶n千米，旅途中有若干个加油站（加油站是已经确定好的），为了使沿途加
小南每日 AI 资讯 | 国产AI之光DeepSeek暴击硅谷？？？ | 25/01/29 小南AI学院人工智能
1.中国AI模型震惊硅谷：DeepSeek为何一夜火出圈？国产AI大模型DeepSeek迅速崛起，引发硅谷关注。2.中国银行支持AI产业：1万亿元金融扶持助推智能化升级中国银行宣布提供1万亿元资金支持人工智能产业链发展，助力智能化升级。3.国产AI大模型DeepSeek惊艳全球：游戏科学冯骥称其为“国运级别科技成果”DeepSeek的AI模型引起全球关注，游戏科学的冯骥高度评价其意义。4.AI产业
【我的阅读】【nature |ai4science】Scientific discovery in the age of artificial intelligence【人工智能时代的科学发现】算法研究员【AI 4 Science】人工智能
相关资料：https://www.nature.com/articles/s41586-023-06221-2#Sec15文章目录Abstract摘要Conclusion结论Abstract摘要Artificialintelligence(AI)isbeingincreasinglyintegratedintoscientificdiscoverytoaugmentandaccelerateres
Hugging Face挑战DeepSeek，AI开源竞赛升级！新加坡内哥谈技术人工智能深度学习语言模型学习
每周跟踪AI热点新闻动向和震撼发展想要探索生成式人工智能的前沿进展吗？订阅我们的简报，深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同，从行业内部的深度分析和实用指南中受益。不要错过这个机会，成为AI领域的领跑者。点击订阅，与未来同行！订阅：https://rengongzhineng.io/DeepSeek的R1推理模型刚刚引发全球轰动，开源AI界的“顶流”HuggingFac
LLM based Single Agent System AGI大模型与大数据研究院大数据AI人工智能计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
LLM-BasedSingleAgentSystem:ANewEraofIntelligentAutomation关键词：大语言模型，单智能体系统，强化学习，自然语言处理，智能自动化1.背景介绍近年来，随着深度学习技术的快速发展，大语言模型(LLM)在自然语言处理(NLP)领域取得了突破性进展。LLM凭借其强大的语言理解和生成能力，正在改变着人们与信息交互的方式。同时，人工智能领域的另一个重要研究
DeepSeek：硅谷AI格局的拐点？新加坡内哥谈技术人工智能深度学习语言模型学习
每周跟踪AI热点新闻动向和震撼发展想要探索生成式人工智能的前沿进展吗？订阅我们的简报，深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同，从行业内部的深度分析和实用指南中受益。不要错过这个机会，成为AI领域的领跑者。点击订阅，与未来同行！订阅：https://rengongzhineng.io/本周，硅谷迎来了一个令人大跌眼镜的现实：打造先进人工智能模型，可能远没有想象中那么高深莫
Java常用排序算法/程序员必须掌握的8大排序算法 cugfy java
分类： 1）插入排序（直接插入排序、希尔排序） 2）交换排序（冒泡排序、快速排序） 3）选择排序（直接选择排序、堆排序） 4）归并排序 5）分配排序（基数排序）所需辅助空间最多：归并排序所需辅助空间最少：堆排序平均速度最快：快速排序不稳定：快速排序，希尔排序，堆排序。先来看看8种排序之间的关系： 1.直接插入排序（1
【Spark102】Spark存储模块BlockManager剖析 bit1129 manager
Spark围绕着BlockManager构建了存储模块，包括RDD，Shuffle，Broadcast的存储都使用了BlockManager。而BlockManager在实现上是一个针对每个应用的Master/Executor结构，即Driver上BlockManager充当了Master角色，而各个Slave上(具体到应用范围，就是Executor)的BlockManager充当了Slave角色
linux 查看端口被占用情况详解 daizj linux 端口占用 netstat lsof
经常在启动一个程序会碰到端口被占用，这里讲一下怎么查看端口是否被占用，及哪个程序占用，怎么Kill掉已占用端口的程序 1、lsof -i:port port为端口号 [root@slave /data/spark-1.4.0-bin-cdh4]# lsof -i:8080 COMMAND PID USER FD TY
Hosts文件使用周凡杨 hosts locahost
一切都要从localhost说起，经常在tomcat容器起动后，访问页面时输入http://localhost:8088/index.jsp，大家都知道localhost代表本机地址，如果本机IP是10.10.134.21，那就相当于http://10.10.134.21:8088/index.jsp，有时候也会看到http: 127.0.0.1:
java excel工具 g21121 Java excel
直接上代码，一看就懂，利用的是jxl： import java.io.File; import java.io.IOException; import jxl.Cell; import jxl.Sheet; import jxl.Workbook; import jxl.read.biff.BiffException; import jxl.write.Label; import
web报表工具finereport常用函数的用法总结（数组函数）老A不折腾 finereport web报表函数总结
ADD2ARRAY ADDARRAY(array,insertArray, start):在数组第start个位置插入insertArray中的所有元素，再返回该数组。示例： ADDARRAY([3,4, 1, 5, 7], [23, 43, 22], 3)返回[3, 4, 23, 43, 22, 1, 5, 7]. ADDARRAY([3,4, 1, 5, 7], "测试&q
游戏服务器网络带宽负载计算墙头上一根草服务器
家庭所安装的4M，8M宽带。其中M是指，Mbits/S 其中要提前说明的是： 8bits = 1Byte 即8位等于1字节。我们硬盘大小50G。意思是50*1024M字节，约为 50000多字节。但是网宽是以“位”为单位的，所以，8Mbits就是1M字节。是容积体积的单位。 8Mbits/s后面的S是秒。8Mbits/s意思是每秒8M位，即每秒1M字节。我是在计算我们网络流量时想到的
我的spring学习笔记2-IoC（反向控制依赖注入） aijuans Spring 3 系列
IoC（反向控制依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明：如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
高性能mysql 之选择存储引擎(一) annan211 mysql InnoDB MySQL引擎存储引擎
1 没有特殊情况，应尽可能使用InnoDB存储引擎。原因：InnoDB 和 MYIsAM 是mysql 最常用、使用最普遍的存储引擎。其中InnoDB是最重要、最广泛的存储引擎。她被设计用来处理大量的短期事务。短期事务大部分情况下是正常提交的，很少有回滚的情况。InnoDB的性能和自动崩溃恢复特性使得她在非事务型存储的需求中也非常流行，除非有非常
UDP网络编程百合不是茶 UDP编程局域网组播
UDP是基于无连接的,不可靠的传输与TCP/IP相反 UDP实现私聊,发送方式客户端,接受方式服务器 package netUDP_sc; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.Ine
JQuery对象的val()方法执行结果分析 bijian1013 JavaScript js jquery
JavaScript中，如果id对应的标签不存在（同理JAVA中，如果对象不存在），则调用它的方法会报错或抛异常。在实际开发中，发现JQuery在id对应的标签不存在时，调其val()方法不会报错，结果是undefined。
http请求测试实例（采用json-lib解析） bijian1013 json http
由于fastjson只支持JDK1.5版本，因些对于JDK1.4的项目，可以采用json-lib来解析JSON数据。如下是http请求的另外一种写法，仅供参考。 package com; import java.util.HashMap; import java.util.Map; import
【RPC框架Hessian四】Hessian与Spring集成 bit1129 hessian
在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中介绍了基于Hessian的RPC服务的实现步骤，在那里使用Hessian提供的API完成基于Hessian的RPC服务开发和客户端调用，本文使用Spring对Hessian的集成来实现Hessian的RPC调用。定义模型、接口和服务器端代码 |---Model &nb
【Mahout三】基于Mahout CBayes算法的20newsgroup流程分析 bit1129 Mahout
1.Mahout环境搭建 1.下载Mahout http://mirror.bit.edu.cn/apache/mahout/0.10.0/mahout-distribution-0.10.0.tar.gz 2.解压Mahout 3. 配置环境变量 vim /etc/profile export HADOOP_HOME=/home
nginx负载tomcat遇非80时的转发问题 ronin47
　　nginx负载后端容器是tomcat（其它容器如WAS,JBOSS暂没发现这个问题）非８０端口，遇到跳转异常问题。解决的思路是：$host:port 详细如下：　　该问题是最先发现的，由于之前对nginx不是特别的熟悉所以该问题是个入门级别的： ? 1 2 3 4 5
java-17-在一个字符串中找到第一个只出现一次的字符 bylijinnan java
public class FirstShowOnlyOnceElement { /**Q17.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b * 1.int[] count:count[i]表示i对应字符出现的次数 * 2.将26个英文字母映射：a-z <--> 0-25 * 3.假设全部字母都是小写 */ pu
mongoDB 复制集开窍的石头 mongodb
mongo的复制集就像mysql的主从数据库，当你往其中的主复制集(primary)写数据的时候，副复制集(secondary)会自动同步主复制集(Primary)的数据,当主复制集挂掉以后其中的一个副复制集会自动成为主复制集。提供服务器的可用性。和防止当机问题 mo
[宇宙与天文]宇宙时代的经济学 comsci 经济
宇宙尺度的交通工具一般都体型巨大，造价高昂。。。。。在宇宙中进行航行，近程采用反作用力类型的发动机，需要消耗少量矿石燃料，中远程航行要采用量子或者聚变反应堆发动机，进行超空间跳跃，要消耗大量高纯度水晶体能源以目前地球上国家的经济发展水平来讲，
Git忽略文件 Cwind git
有很多文件不必使用git管理。例如Eclipse或其他IDE生成的项目文件，编译生成的各种目标或临时文件等。使用git status时，会在Untracked files里面看到这些文件列表，在一次需要添加的文件比较多时（使用git add . / git add -u），会把这些所有的未跟踪文件添加进索引。 ==== ==== ==== 一些牢骚
MySQL连接数据库的必须配置 dashuaifu mysql 连接数据库配置
MySQL连接数据库的必须配置 1.driverClass：com.mysql.jdbc.Driver 2.jdbcUrl：jdbc:mysql://localhost:3306/dbname 3.user：username 4.password：password 其中1是驱动名；2是url，这里的‘dbna
一生要养成的60个习惯 dcj3sjt126com 习惯
一生要养成的60个习惯第1篇让你更受大家欢迎的习惯 1 守时，不准时赴约,让别人等,会失去很多机会。如何做到： ①该起床时就起床， ②养成任何事情都提前15分钟的习惯。 ③带本可以随时阅读的书，如果早了就拿出来读读。 ④有条理，生活没条理最容易耽误时间。 ⑤提前计划：将重要和不重要的事情岔开。 ⑥今天就准备好明天要穿的衣服。 ⑦按时睡觉，这会让按时起床更容易。 2 注重
[介绍]Yii 是什么 dcj3sjt126com PHP yii2
Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。名字 Yii （读作易）在中文里有“极致简单与不断演变”两重含义，也可看作 Yes It Is! 的缩写。 Yii 最适合做什么？ Yii 是一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的 Web 应用。因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应
Linux SSH常用总结 eksliang linux ssh SSHD
转载请出自出处：http://eksliang.iteye.com/blog/2186931 一、连接到远程主机格式： ssh name@remoteserver 例如： ssh [email protected] 二、连接到远程主机指定的端口格式： ssh name@remoteserver -p 22 例如： ssh i
快速上传头像到服务端工具类FaceUtil gundumw100 android
快速迭代用 import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOExceptio
jQuery入门之怎么使用 ini JavaScript html jquery Web css
jQuery的强大我何问起（个人主页：hovertree.com）就不用多说了，那么怎么使用jQuery呢？首先，下载jquery。下载地址：http://hovertree.com/hvtart/bjae/b8627323101a4994.htm，一个是压缩版本，一个是未压缩版本，如果在开发测试阶段，可以使用未压缩版本，实际应用一般使用压缩版本(min)。然后就在页面上引用。
带filter的hbase查询优化 kane_xie 查询优化 hbase RandomRowFilter
问题描述 hbase scan数据缓慢，server端出现LeaseException。hbase写入缓慢。问题原因直接原因是： hbase client端每次和regionserver交互的时候，都会在服务器端生成一个Lease,Lease的有效期由参数hbase.regionserver.lease.period确定。如果hbase scan需
java设计模式-单例模式 men4661273 java 单例枚举反射 IOC
单例模式1，饿汉模式 //饿汉式单例类.在类初始化时，已经自行实例化 public class Singleton1 { //私有的默认构造函数 private Singleton1() {} //已经自行实例化 private static final Singleton1 singl
mongodb 查询某一天所有信息的3种方法，根据日期查询 qiaolevip 每天进步一点点学习永无止境 mongodb 纵观千象
// mongodb的查询真让人难以琢磨，就查询单天信息，都需要花费一番功夫才行。 // 第一种方式： coll.aggregate([ {$project:{sendDate: {$substr: ['$sendTime', 0, 10]}, sendTime: 1, content:1}}, {$match:{sendDate: '2015-
二维数组转换成JSON tangqi609567707 java 二维数组 json
原文出处：http://blog.csdn.net/springsen/article/details/7833596 public class Demo { public static void main(String[] args) { String[][] blogL
erlang supervisor wudixiaotie erlang
定义supervisor时，如果是监控celuesimple_one_for_one则删除children的时候就用supervisor:terminate_child (SupModuleName, ChildPid)，如果shutdown策略选择的是brutal_kill，那么supervisor会调用exit(ChildPid, kill)，这样的话如果Child的behavior是gen_

[ 轻量级网络 ] 经典网络模型4——Xception 详解与复现

[ 轻量级网络 ] 经典网络模型4——Xception 详解与复现

Xception

Xception 详解

Xception 网络结构

结构探索

Xception 结构框图

Xception 实验测试

Xception 复现

你可能感兴趣的:(经典网络模型,人工智能,深度学习,轻量级网络,Xception,神经网络)