Harry嗷

[PyTorch] 基于Python和PyTorch的cifar-10分类

cifar-10数据集介绍

CIFAR-10数据集由10个类的60000个32x32彩色图像组成，每个类有6000个图像。有50000个训练图像和10000个测试图像。
数据集分为5个训练批次和1个测试批次，每个批次有10000个图像。
以下是数据集中的类，以及来自每个类的10个随机图像：

与MNIST 数据集中目比， cifar-10有以下特点：

CIFAR-10 是3通道的彩色RGB图像，而 MNIST 是1通道的灰度图像。
CIFAR-10 的图片尺寸为32 × 32 ，而MNIST 的图片尺寸为28 × 28 ，比MNIST 稍大。
相比于手写字符， cifar-10 是现实世界中真实的物体，不仅噪声很大，而且物体的比例、特征都不尽相同。直接的线性模型如Softmax 在CIFAR-10 上表现得很差。

下载cifar-10数据集

代码如下

import torch
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

这部分代码主要用到torchvision库，对于这个库的介绍在本人的另一篇博客torchvision库及其常用的函数，或者直接去torchvision - PyTorch中文文档看也可以。

分类代码

需要用到的函数库

import torch
import torchvision
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data as Data
import torchvision.transforms as transforms
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import time
import os

预设参数

# 预设参数
CLASS_NUM = 10
BATCH_SIZE = 128
EPOCH = 15
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device

CLASS_NUM=0表示数据分为10个类
BATCH_SIZE=128 表示每个BATCH中有128个Sample。
EPOCH=15表示整个训练集被遍历15遍。
device也是一个人为设定的超参数，在GPU可用时为cuda，不可用时为CPU。

定义网络模型

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
      	# 输入shape 3*32*32
        self.conv1 = nn.Conv2d(3,64,3,padding=1)        # 64*32*32
        self.conv2 = nn.Conv2d(64,64,3,padding=1)       # 64*32*32
        self.pool1 = nn.MaxPool2d(2, 2)                 # 64*16*16
        self.bn1 = nn.BatchNorm2d(64)                   # 64*16*16
        self.relu1 = nn.ReLU()                          # 64*16*16

        self.conv3 = nn.Conv2d(64,128,3,padding=1)      # 128*16*16
        self.conv4 = nn.Conv2d(128, 128, 3,padding=1)   # 128*16*16
        self.pool2 = nn.MaxPool2d(2, 2, padding=1)      # 128*9*9
        self.bn2 = nn.BatchNorm2d(128)                  # 128*9*9
        self.relu2 = nn.ReLU()                          # 128*9*9

        self.conv5 = nn.Conv2d(128,128, 3,padding=1)    # 128*9*9
        self.conv6 = nn.Conv2d(128, 128, 3,padding=1)   # 128*9*9
        self.conv7 = nn.Conv2d(128, 128, 1,padding=1)   # 128*11*11
        self.pool3 = nn.MaxPool2d(2, 2, padding=1)      # 128*6*6
        self.bn3 = nn.BatchNorm2d(128)                  # 128*6*6
        self.relu3 = nn.ReLU()                          # 128*6*6

        self.conv8 = nn.Conv2d(128, 256, 3,padding=1)   # 256*6*6
        self.conv9 = nn.Conv2d(256, 256, 3, padding=1)  # 256*6*6
        self.conv10 = nn.Conv2d(256, 256, 1, padding=1) # 256*8*8
        self.pool4 = nn.MaxPool2d(2, 2, padding=1)      # 256*5*5
        self.bn4 = nn.BatchNorm2d(256)                  # 256*5*5
        self.relu4 = nn.ReLU()                          # 256*5*5

        self.conv11 = nn.Conv2d(256, 512, 3, padding=1) # 512*5*5
        self.conv12 = nn.Conv2d(512, 512, 3, padding=1) # 512*5*5
        self.conv13 = nn.Conv2d(512, 512, 1, padding=1) # 512*7*7
        self.pool5 = nn.MaxPool2d(2, 2, padding=1)      # 512*4*4
        self.bn5 = nn.BatchNorm2d(512)                  # 512*4*4
        self.relu5 = nn.ReLU()                          # 512*4*4

        self.fc14 = nn.Linear(512*4*4,1024)             # 1*1024
        self.drop1 = nn.Dropout2d()                     # 1*1024
        self.fc15 = nn.Linear(1024,1024)                # 1*1024
        self.drop2 = nn.Dropout2d()                     # 1*1024
        self.fc16 = nn.Linear(1024,10)                  # 1*10

    def forward(self,x):
        x = x.to(device)  # 自加
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.pool1(x)
        x = self.bn1(x)
        x = self.relu1(x)


        x = self.conv3(x)
        x = self.conv4(x)
        x = self.pool2(x)
        x = self.bn2(x)
        x = self.relu2(x)

        x = self.conv5(x)
        x = self.conv6(x)
        x = self.conv7(x)
        x = self.pool3(x)
        x = self.bn3(x)
        x = self.relu3(x)

        x = self.conv8(x)
        x = self.conv9(x)
        x = self.conv10(x)
        x = self.pool4(x)
        x = self.bn4(x)
        x = self.relu4(x)

        x = self.conv11(x)
        x = self.conv12(x)
        x = self.conv13(x)
        x = self.pool5(x)
        x = self.bn5(x)
        x = self.relu5(x)
        # print(" x shape ",x.size())
        x = x.view(-1,512*4*4)
        x = F.relu(self.fc14(x))
        x = self.drop1(x)
        x = F.relu(self.fc15(x))
        x = self.drop2(x)
        x = self.fc16(x)

        return x

# ----------------------------------------------------------------------------------------------------------------------

卷积层函数nn.Conv2d()的参数意义，详见本人的另一篇博客卷积函数 and 解卷积函数，里面对in_channel、out_channel和in_size、out_size有详细的讲解。

nn.BatchNorm2d()的介绍，推荐这两个博客：BatchNormalization、LayerNormalization、InstanceNorm、GroupNorm、SwitchableNorm总结和PyTorch学习之归一化层（BatchNorm、LayerNorm、InstanceNorm、GroupNorm）。
简单来说，nn.BatchNorm2d()以batch为单位进行归一化，即在batch上，对NHW做归一化。
不同归一化的示意图如下：

nn.Dropout2d()是对每个通道按照概率0.5置为0，是用来避免过拟合情况的函数。详见博客：PyTorch笔记8-Dropout

下面这张图形象地说明了一个batch内的H(height)、W(width)、C(channel)、N(SampleNumber)的意义。

然后我们分模块，把整个前向传播走一遍。

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [-1, 64, 32, 32]           1,792
            Conv2d-2           [-1, 64, 32, 32]          36,928
         MaxPool2d-3           [-1, 64, 16, 16]               0
       BatchNorm2d-4           [-1, 64, 16, 16]             128
              ReLU-5           [-1, 64, 16, 16]               0
            Conv2d-6          [-1, 128, 16, 16]          73,856
            Conv2d-7          [-1, 128, 16, 16]         147,584
         MaxPool2d-8            [-1, 128, 9, 9]               0
       BatchNorm2d-9            [-1, 128, 9, 9]             256
             ReLU-10            [-1, 128, 9, 9]               0
           Conv2d-11            [-1, 128, 9, 9]         147,584
           Conv2d-12            [-1, 128, 9, 9]         147,584
           Conv2d-13          [-1, 128, 11, 11]          16,512
        MaxPool2d-14            [-1, 128, 6, 6]               0
      BatchNorm2d-15            [-1, 128, 6, 6]             256
             ReLU-16            [-1, 128, 6, 6]               0
           Conv2d-17            [-1, 256, 6, 6]         295,168
           Conv2d-18            [-1, 256, 6, 6]         590,080
           Conv2d-19            [-1, 256, 8, 8]          65,792
        MaxPool2d-20            [-1, 256, 5, 5]               0
      BatchNorm2d-21            [-1, 256, 5, 5]             512
             ReLU-22            [-1, 256, 5, 5]               0
           Conv2d-23            [-1, 512, 5, 5]       1,180,160
           Conv2d-24            [-1, 512, 5, 5]       2,359,808
           Conv2d-25            [-1, 512, 7, 7]         262,656
        MaxPool2d-26            [-1, 512, 4, 4]               0
      BatchNorm2d-27            [-1, 512, 4, 4]           1,024
             ReLU-28            [-1, 512, 4, 4]               0
           Linear-29                 [-1, 1024]       8,389,632
        Dropout2d-30                 [-1, 1024]               0
           Linear-31                 [-1, 1024]       1,049,600
        Dropout2d-32                 [-1, 1024]               0
           Linear-33                   [-1, 10]          10,250
================================================================
Total params: 14,777,162
Trainable params: 14,777,162
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.01
Forward/backward pass size (MB): 3.51
Params size (MB): 56.37
Estimated Total Size (MB): 59.89
----------------------------------------------------------------

特征提取开始

模块1开始

网络结构	函数
卷积层	nn.Conv2d(3,64,3,padding=1)
卷积层	nn.Conv2d(64,64,3,padding=1)
最大池化层	nn.MaxPool2d(2, 2)
归一化	nn.BatchNorm2d(64)
激活函数	nn.ReLU()

第一个卷积层： nn.Conv2d(3,64,3,padding=1)
其参数意义为：

输入通道为 3，RGB图像
输出通道为 64，用到64种卷积核。
卷积核 kernel_size为 3×3
加padding=1

32_输出维度=32_输入维度+2_padding-3_{卷积核size}+1
输出shape为：64×32×32

第二个卷积层： nn.Conv2d(64,64,3,padding=1)
其参数意义为：

输入通道为 64，为上一层的out_channel
输出通道为 64，用到64种卷积核。
卷积核 kernel_size为 3×3
加padding=1

32_输出维度=32_输入维度+2_padding-3_{卷积核size}+1
输出shape为：64×32×32

第一个最大池化层： nn.MaxPool2d(2, 2)
该最大池化层在 2x2 空间里向下采样，步长为2
16_输出维度=32_输入维度/2
输出shape为：64×16×16

第一个BN：nn.BatchNorm2d(64)
参数64为输入数据的通道数
输出shape不变，仍为：64×16×16

第一个激活函数：nn.ReLU()
输出shape不变，仍为：64×16×16
模块1结束

模块2开始

网络结构	函数
卷积层	nn.Conv2d(64,128,3,padding=1)
卷积层	nn.Conv2d(128, 128, 3,padding=1)
最大池化层	nn.MaxPool2d(2, 2, padding=1)
归一化	nn.BatchNorm2d(128)
激活函数	nn.ReLU()

第三个卷积层： nn.Conv2d(64,128,3,padding=1)
其参数意义为：

输入通道为 64，为上一层的out_channel
输出通道为 128，用到128种卷积核。
卷积核 kernel_size为 3×3
加padding=1

16_输出维度=16_输入维度+2_padding-3_{卷积核size}+1
输出shape为：128×16×16

第四个卷积层： nn.Conv2d(128, 128, 3,padding=1)
其参数意义为：

输入通道为 128，为上一层的out_channel
输出通道为 128，用到128种卷积核。
卷积核 kernel_size为 3×3
加padding=1

16_输出维度=16_输入维度+2_padding-3_{卷积核size}+1
输出shape为：128×16×16

第二个最大池化层： nn.MaxPool2d(2, 2, padding=1)
该最大池化层在 2x2 空间里向下采样，输出信号向下取整
9_输出维度=(16_输入维度+2_padding) /2
输出shape为：128×9×9

第二个BN：nn.BatchNorm2d(128)
参数64为输入数据的通道数
输出shape不变，仍为：128×9×9

第二个激活函数：nn.ReLU()
输出shape不变，仍为：128×9×9
模块2结束

模块3开始

网络结构	函数
卷积层	nn.Conv2d(128,128, 3,padding=1)
卷积层	nn.Conv2d(128, 128, 3,padding=1)
卷积层	nn.Conv2d(128, 128, 1,padding=1)
最大池化层	nn.MaxPool2d(2, 2, padding=1)
归一化	nn.BatchNorm2d(128)
激活函数	nn.ReLU()

第五个卷积层： nn.Conv2d(128,128, 3,padding=1)
其参数意义为：

输入通道为 128，为上一层的out_channel
输出通道为 128，用到128种卷积核。
卷积核 kernel_size为 3×3
加padding=1

9_输出维度=9_输入维度+2_padding-3_{卷积核size}+1
输出shape为：128×9×9

第六个卷积层： nn.Conv2d(128, 128, 3,padding=1)
其参数意义为：

输入通道为 128，为上一层的out_channel
输出通道为 128，用到128种卷积核。
卷积核 kernel_size为 3×3
加padding=1

9_输出维度=9_输入维度+2_padding-3_{卷积核size}+1
输出shape为：128×9×9

第七个卷积层： nn.Conv2d(128, 128, 1,padding=1)
其参数意义为：

输入通道为 128，为上一层的out_channel
输出通道为 128，用到128种卷积核。
卷积核 kernel_size为 1×1
加padding=1

9_输出维度=9_输入维度+2_padding-1_{卷积核size}+1
输出shape为：128×11×11

第三个最大池化层： nn.MaxPool2d(2, 2, padding=1)
该最大池化层在 2x2 空间里向下采样，输出信号向下取整
6_输出维度=(11_输入维度+2_padding) /2
输出shape为：128×6×6

第三个BN：nn.BatchNorm2d(128)
参数64为输入数据的通道数
输出shape不变，仍为：128×6×6

第三个激活函数：nn.ReLU()
输出shape不变，仍为：128×6×6

模块3结束

模块4开始

网络结构	函数
卷积层	nn.Conv2d(128, 256, 3,padding=1)
卷积层	nn.Conv2d(256, 256, 3, padding=1)
卷积层	nn.Conv2d(256, 256, 1, padding=1)
最大池化层	nn.MaxPool2d(2, 2, padding=1)
归一化	nn.BatchNorm2d(256)
激活函数	nn.ReLU()

第八个卷积层： nn.Conv2d(128, 256, 3,padding=1)
其参数意义为：

输入通道为 128，为上一层的out_channel
输出通道为 256，用到256种卷积核。
卷积核 kernel_size为 3×3
加padding=1

6_输出维度=6_输入维度+2_padding-3_{卷积核size}+1
输出shape为：256×6×6

第九个卷积层： nn.Conv2d(256, 256, 3, padding=1)
其参数意义为：

输入通道为 256，为上一层的out_channel
输出通道为 256，用到128种卷积核。
卷积核 kernel_size为 3×3
加padding=1

6_输出维度=6_输入维度+2_padding-3_{卷积核size}+1
输出shape为：256×6×6

第十个卷积层： nn.Conv2d(256, 256, 1, padding=1)
其参数意义为：

输入通道为 256，为上一层的out_channel
输出通道为 256，用到128种卷积核。
卷积核 kernel_size为 1×1
加padding=1

8_输出维度=6_输入维度+2_padding-1_{卷积核size}+1
输出shape为：256×8×8

第四个最大池化层： nn.MaxPool2d(2, 2, padding=1)
该最大池化层在 2x2 空间里向下采样，输出信号向下取整
5_输出维度=(8_输入维度+2_padding) /2
输出shape为：256×5×5

第四个BN：nn.BatchNorm2d(128)
参数64为输入数据的通道数
输出shape不变，仍为：256×5×5

第四个激活函数：nn.ReLU()
输出shape不变，仍为：256×5×5

模块4结束

模块5开始

网络结构	函数
卷积层	nn.Conv2d(256, 512, 3, padding=1)
卷积层	nn.Conv2d(512, 512, 3, padding=1)
卷积层	nn.Conv2d(512, 512, 1, padding=1)
最大池化层	nn.MaxPool2d(2, 2, padding=1)
归一化	nn.BatchNorm2d(512)
激活函数	nn.ReLU()

第十一个卷积层： nn.Conv2d(256, 512, 3, padding=1)
其参数意义为：

输入通道为 256，为上一层的out_channel
输出通道为 512，用到256种卷积核。
卷积核 kernel_size为 3×3
加padding=1

5_输出维度=5_输入维度+2_padding-3_{卷积核size}+1
输出shape为：512×5×5

第十二个卷积层： nn.Conv2d(512, 512, 3, padding=1)
其参数意义为：

输入通道为 512，为上一层的out_channel
输出通道为 512，用到128种卷积核。
卷积核 kernel_size为 3×3
加padding=1

5_输出维度=5_输入维度+2_padding-3_{卷积核size}+1
输出shape为：512×5×5

第十三个卷积层： nn.Conv2d(512, 512, 1, padding=1)
其参数意义为：

输入通道为 512，为上一层的out_channel
输出通道为 512，用到128种卷积核。
卷积核 kernel_size为 1×1
加padding=1

7_输出维度=5_输入维度+2_padding-1_{卷积核size}+1
输出shape为：512×7×7

第四个最大池化层： nn.MaxPool2d(2, 2, padding=1)
该最大池化层在 2x2 空间里向下采样，输出信号向下取整
4_输出维度=(7_输入维度+2_padding) /2
输出shape为：512×4×4

第五个BN：nn.BatchNorm2d(128)
参数64为输入数据的通道数
输出shape不变，仍为：512×4×4

第五个激活函数：nn.ReLU()
输出shape不变，仍为：512×4×4
模块5结束

特征提取结束

输出前的数据预处理开始

x.view(-1,512*4 *4)

将 x（即batch_size）个Sample拉成一维。-1表示行自适应。
输出前的数据预处理结束

输出即全连接层开始

网络结构	函数
全连接层	self.fc14 = nn.Linear(512* 4* 4,1024)
概率置零	nn.Dropout2d()
全连接层	nn.Linear(1024,1024)
概率置零	nn.Dropout2d()
全连接层	nn.Linear(1024,10)

第一个全连接层nn.Linear(512* 4* 4,1024)
输入维度为 512 * 4 * 4
设定的输出维度为 1*1024

第一个Dropout层nn.Dropout2d()
数据维度不变，仍为1*1024

第二个全连接层nn.Linear(1024,1024)
输入维度为 1*1024
设定的输出维度为 1*1024

第二个Dropout层nn.Dropout2d()
数据维度不变，仍为1*1024

第三个激活函数nn.Linear(1024,10)
输入维度为 1*1024
设定的输出维度为 10 × 1，对应分类的CLASS_NUM为10
输出即全连接层结束

数据存取（待解决）

def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='bytes')
    return dict


# 从源文件读取数据
# 返回 train_data[50000,3072]和labels[50000]
#    test_data[10000,3072]和labels[10000]
def get_data(train=False):
    data = None
    labels = None
    if train == True:
        for i in range(1, 6):
            batch = unpickle('data/cifar-10-batches-py/data_batch_' + str(i))
            if i == 1:
                data = batch[b'data']
            else:
                data = np.concatenate([data, batch[b'data']])

            if i == 1:
                labels = batch[b'labels']
            else:
                labels = np.concatenate([labels, batch[b'labels']])
    else:
        batch = unpickle('data/cifar-10-batches-py/test_batch')
        data = batch[b'data']
        labels = batch[b'labels']
    return data, labels

个人认为这是一共提高数据存取效率的模块，用到pickle。
具体的东西现在不甚了解，暂时作为一个遗留问题。

图像和标签的预处理

# 图像预处理函数，Compose会将多个transform操作包在一起
# 对于彩色图像，色彩通道不存在平稳特性
transform = transforms.Compose([
    # ToTensor是指把PIL.Image(RGB) 或者numpy.ndarray(H * W * C)
    # 从0到255的值映射到0到1的范围内，并转化成Tensor格式。
    transforms.ToTensor(),
    # Normalize函数将图像数据归一化到[-1,1]
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
)

# 将标签转换为torch.LongTensor
def target_transform(label):
    label = np.array(label)         # 变为ndarray
    target = torch.from_numpy(label).long()     # 变为torch.LongTensor
    return target

transforms.Compose(transforms)是将多个transform组合起来使用。transforms是由多个transform构成的列表。
在这里transforms.Compose()把.ToTensor()和.Normalize()组合到一起去执行。

将标签转换为torch.LongTensor，就是简单的类型转换了。

下载完成后运行分类代码

import torch
import torchvision
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data as Data
import torchvision.transforms as transforms
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import time
import os
from torchsummary import summary

# 预设参数
CLASS_NUM = 10
BATCH_SIZE = 128
EPOCH = 15

# 检验GPU是否可用
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)

# ----------------------------------------------------------------------------------------------------------------------
class Net(nn.Module):

    def __init__(self):
        super(Net,self).__init__()
        # 输入shape 3*32*32
        self.conv1 = nn.Conv2d(3,64,3,padding=1)        # 64*32*32
        self.conv2 = nn.Conv2d(64,64,3,padding=1)       # 64*32*32
        self.pool1 = nn.MaxPool2d(2, 2)                 # 64*16*16
        self.bn1 = nn.BatchNorm2d(64)                   # 64*16*16
        self.relu1 = nn.ReLU()                          # 64*16*16

        self.conv3 = nn.Conv2d(64,128,3,padding=1)      # 128*16*16
        self.conv4 = nn.Conv2d(128, 128, 3,padding=1)   # 128*16*16
        self.pool2 = nn.MaxPool2d(2, 2, padding=1)      # 128*9*9
        self.bn2 = nn.BatchNorm2d(128)                  # 128*9*9
        self.relu2 = nn.ReLU()                          # 128*9*9

        self.conv5 = nn.Conv2d(128,128, 3,padding=1)    # 128*9*9
        self.conv6 = nn.Conv2d(128, 128, 3,padding=1)   # 128*9*9
        self.conv7 = nn.Conv2d(128, 128, 1,padding=1)   # 128*11*11
        self.pool3 = nn.MaxPool2d(2, 2, padding=1)      # 128*6*6
        self.bn3 = nn.BatchNorm2d(128)                  # 128*6*6
        self.relu3 = nn.ReLU()                          # 128*6*6

        self.conv8 = nn.Conv2d(128, 256, 3,padding=1)   # 256*6*6
        self.conv9 = nn.Conv2d(256, 256, 3, padding=1)  # 256*6*6
        self.conv10 = nn.Conv2d(256, 256, 1, padding=1) # 256*8*8
        self.pool4 = nn.MaxPool2d(2, 2, padding=1)      # 256*5*5
        self.bn4 = nn.BatchNorm2d(256)                  # 256*5*5
        self.relu4 = nn.ReLU()                          # 256*5*5

        self.conv11 = nn.Conv2d(256, 512, 3, padding=1) # 512*5*5
        self.conv12 = nn.Conv2d(512, 512, 3, padding=1) # 512*5*5
        self.conv13 = nn.Conv2d(512, 512, 1, padding=1) # 512*7*7
        self.pool5 = nn.MaxPool2d(2, 2, padding=1)      # 512*4*4
        self.bn5 = nn.BatchNorm2d(512)                  # 512*4*4
        self.relu5 = nn.ReLU()                          # 512*4*4

        self.fc14 = nn.Linear(512*4*4,1024)             # 1*1024
        self.drop1 = nn.Dropout2d()                     # 1*1024
        self.fc15 = nn.Linear(1024,1024)                # 1*1024
        self.drop2 = nn.Dropout2d()                     # 1*1024
        self.fc16 = nn.Linear(1024,10)                  # 1*10

    def forward(self,x):
        x = x.to(device)  # 自加
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.pool1(x)
        x = self.bn1(x)
        x = self.relu1(x)


        x = self.conv3(x)
        x = self.conv4(x)
        x = self.pool2(x)
        x = self.bn2(x)
        x = self.relu2(x)

        x = self.conv5(x)
        x = self.conv6(x)
        x = self.conv7(x)
        x = self.pool3(x)
        x = self.bn3(x)
        x = self.relu3(x)

        x = self.conv8(x)
        x = self.conv9(x)
        x = self.conv10(x)
        x = self.pool4(x)
        x = self.bn4(x)
        x = self.relu4(x)

        x = self.conv11(x)
        x = self.conv12(x)
        x = self.conv13(x)
        x = self.pool5(x)
        x = self.bn5(x)
        x = self.relu5(x)
        # print(" x shape ",x.size())
        x = x.view(-1,512*4*4)
        x = F.relu(self.fc14(x))
        x = self.drop1(x)
        x = F.relu(self.fc15(x))
        x = self.drop2(x)
        x = self.fc16(x)

        return x

# ----------------------------------------------------------------------------------------------------------------------

def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='bytes')
    return dict


# 从源文件读取数据
# 返回 train_data[50000,3072]和labels[50000]
#    test_data[10000,3072]和labels[10000]
def get_data(train=False):
    data = None
    labels = None
    if train == True:
        for i in range(1, 6):
            batch = unpickle('data/cifar-10-batches-py/data_batch_' + str(i))
            if i == 1:
                data = batch[b'data']
            else:
                data = np.concatenate([data, batch[b'data']])

            if i == 1:
                labels = batch[b'labels']
            else:
                labels = np.concatenate([labels, batch[b'labels']])
    else:
        batch = unpickle('data/cifar-10-batches-py/test_batch')
        data = batch[b'data']
        labels = batch[b'labels']
    return data, labels


# 图像预处理函数，Compose会将多个transform操作包在一起
# 对于彩色图像，色彩通道不存在平稳特性
transform = transforms.Compose([
    # ToTensor是指把PIL.Image(RGB) 或者numpy.ndarray(H * W * C)
    # 从0到255的值映射到0到1的范围内，并转化成Tensor格式。
    transforms.ToTensor(),
    # Normalize函数将图像数据归一化到[-1,1]
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
)

# 将标签转换为torch.LongTensor
def target_transform(label):
    label = np.array(label)         # 变为ndarray
    target = torch.from_numpy(label).long()     # 变为torch.LongTensor
    return target


'''
自定义数据集读取框架来载入cifar10数据集
需要继承data.Dataset
'''

# 数据集
class Cifar10_Dataset(Data.Dataset):
    def __init__(self, train=True, transform=None, target_transform=None):
        # 初始化文件路径
        self.transform = transform
        self.target_transform = target_transform
        self.train = train
        # 载入训练数据集
        if self.train:
            self.train_data, self.train_labels = get_data(train)
            self.train_data = self.train_data.reshape((50000, 3, 32, 32))
            # 将图像数据格式转换为[height,width,channels]方便预处理
            self.train_data = self.train_data.transpose((0, 2, 3, 1))
            # 载入测试数据集
        else:
            self.test_data, self.test_labels = get_data()
            self.test_data = self.test_data.reshape((10000, 3, 32, 32))
            self.test_data = self.test_data.transpose((0, 2, 3, 1))
        pass

    # 从数据集中读取一个数据并对数据进行预处理返回一个数据对，如（data,label）
    def __getitem__(self, index):
        if self.train:
            img, label = self.train_data[index], self.train_labels[index]
        else:
            img, label = self.test_data[index], self.test_labels[index]
        img = Image.fromarray(img)
        # 图像预处理
        if self.transform is not None:
            img = self.transform(img)
        # 标签预处理
        if self.target_transform is not None:
            target = self.target_transform(label)

        return img, target

    def __len__(self):
        # 返回数据集的size
        if self.train:
            return len(self.train_data)
        else:
            return len(self.test_data)


if __name__ == '__main__':
    # 读取训练集和测试集
    train_data = Cifar10_Dataset(True, transform, target_transform)
    print('size of train_data:{}'.format(train_data.__len__()))
    test_data = Cifar10_Dataset(False, transform, target_transform)
    print('size of test_data:{}'.format(test_data.__len__()))
    train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

    net = Net()
    net.to(device)
    # ------------------------------------------------
    with torch.no_grad():
        for input_data, _ in train_loader:
            break
        # summary(model.to(hyperparams['device']), input.size()[1:], device=hyperparams['device'])
        # print(input_data.size())
        summary(net, input_data.size()[1:])
    os.system('pause')
    # ------------------------------------------------

    # 定义优化器
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9,
                          weight_decay=5e-4)  # 优化方式为mini-batch momentum-SGD，并采用L2正则化（权重衰减）
    # 定义损失函数
    # 在使用CrossEntropyLoss时target直接使用类别索引，不适用one-hot
    loss_fn = nn.CrossEntropyLoss()

    loss_list = []
    Accuracy = []
    for epoch in range(1, EPOCH + 1):
        # 训练部分
        timestart = time.time()         # 自加计时
        for step, (x, y) in enumerate(train_loader):
            b_x = Variable(x)
            b_y = Variable(y)
            output = net(b_x)
            b_x, b_y = b_x.to(device), b_y.to(device)   # CPU 转 GPU
            loss = loss_fn(output, b_y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            # 记录loss
            if step % 50 == 0:
                loss_list.append(loss)
        # 每完成一个epoch进行一次测试观察效果
        pre_correct = 0.0
        test_loader = Data.DataLoader(dataset=test_data, batch_size=100, shuffle=True)
        for (x, y) in (test_loader):
            b_x = Variable(x)
            b_y = Variable(y)
            b_x, b_y = b_x.to(device), b_y.to(device)       # 自加
            output = net(b_x)
            pre = torch.max(output, 1)[1]
            # pre_correct = pre_correct.to(device)        # 自加
            pre_correct = pre_correct + float(torch.sum(pre == b_y))
        print('EPOCH:{epoch},ACC:{acc}%'.format(epoch=epoch, acc=(pre_correct / float(10000)) * 100))
        Accuracy.append(pre_correct / float(10000) * 100)

        # 自加计时
        print('epoch %d cost %3f sec' % (epoch, time.time() - timestart))

    # 保存网络模型
    torch.save(net, 'lenet_cifar_10.model')
    # 绘制loss变化曲线
    plt.figure()
    plt.plot(loss_list)
    plt.figure()
    plt.plot(Accuracy)
    plt.show()

网络结构

其中用到的网络结构为

class Net(nn.Module):

    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(3,64,3,padding=1)
        self.conv2 = nn.Conv2d(64,64,3,padding=1)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu1 = nn.ReLU()

        self.conv3 = nn.Conv2d(64,128,3,padding=1)
        self.conv4 = nn.Conv2d(128, 128, 3,padding=1)
        self.pool2 = nn.MaxPool2d(2, 2, padding=1)
        self.bn2 = nn.BatchNorm2d(128)
        self.relu2 = nn.ReLU()

        self.conv5 = nn.Conv2d(128,128, 3,padding=1)
        self.conv6 = nn.Conv2d(128, 128, 3,padding=1)
        self.conv7 = nn.Conv2d(128, 128, 1,padding=1)
        self.pool3 = nn.MaxPool2d(2, 2, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.relu3 = nn.ReLU()

        self.conv8 = nn.Conv2d(128, 256, 3,padding=1)
        self.conv9 = nn.Conv2d(256, 256, 3, padding=1)
        self.conv10 = nn.Conv2d(256, 256, 1, padding=1)
        self.pool4 = nn.MaxPool2d(2, 2, padding=1)
        self.bn4 = nn.BatchNorm2d(256)
        self.relu4 = nn.ReLU()

        self.conv11 = nn.Conv2d(256, 512, 3, padding=1)
        self.conv12 = nn.Conv2d(512, 512, 3, padding=1)
        self.conv13 = nn.Conv2d(512, 512, 1, padding=1)
        self.pool5 = nn.MaxPool2d(2, 2, padding=1)
        self.bn5 = nn.BatchNorm2d(512)
        self.relu5 = nn.ReLU()

        self.fc14 = nn.Linear(512*4*4,1024)
        self.drop1 = nn.Dropout2d()
        self.fc15 = nn.Linear(1024,1024)
        self.drop2 = nn.Dropout2d()
        self.fc16 = nn.Linear(1024,10)

    def forward(self,x):
        x = x.to(device)  # 自加
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.pool1(x)
        x = self.bn1(x)
        x = self.relu1(x)


        x = self.conv3(x)
        x = self.conv4(x)
        x = self.pool2(x)
        x = self.bn2(x)
        x = self.relu2(x)

        x = self.conv5(x)
        x = self.conv6(x)
        x = self.conv7(x)
        x = self.pool3(x)
        x = self.bn3(x)
        x = self.relu3(x)

        x = self.conv8(x)
        x = self.conv9(x)
        x = self.conv10(x)
        x = self.pool4(x)
        x = self.bn4(x)
        x = self.relu4(x)

        x = self.conv11(x)
        x = self.conv12(x)
        x = self.conv13(x)
        x = self.pool5(x)
        x = self.bn5(x)
        x = self.relu5(x)
        # print(" x shape ",x.size())
        x = x.view(-1,512*4*4)
        x = F.relu(self.fc14(x))
        x = self.drop1(x)
        x = F.relu(self.fc15(x))
        x = self.drop2(x)
        x = self.fc16(x)

        return x

网络结构图表

运行结果

change of Accuracy

change of loss

你可能感兴趣的:(PyTorch)

[实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用 pytorch 深度学习人工智能机器学习 python 优化器
文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
【安装环境】配置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的数量是图片像素的
深度学习：怎么看pth文件的参数奥利给少年深度学习人工智能
.pth文件是PyTorch模型的权重文件，它通常包含了训练好的模型的参数。要查看或使用这个文件，你可以按照以下步骤操作：1.确保你有模型的定义你需要有创建这个.pth文件时所用的模型的代码。这意味着你需要有模型的类定义和架构。2.加载模型权重使用PyTorch的load_state_dict方法来加载权重。这里是如何操作的：importtorchimporttorch.nnasnn#定义模型结构
每天五分钟玩转深度学习PyTorch：模型参数优化器torch.optim 幻风_huanfeng 深度学习框架pytorch 深度学习 pytorch 人工智能神经网络机器学习优化算法
本文重点在机器学习或者深度学习中，我们需要通过修改参数使得损失函数最小化(或最大化)，优化算法就是一种调整模型参数更新的策略。在pytorch中定义了优化器optim，我们可以使用它调用封装好的优化算法，然后传递给它神经网络模型参数，就可以对模型进行优化。本文是学习第6步(优化器)，参考链接pytorch的学习路线随机梯度下降算法在深度学习和机器学习中，梯度下降算法是最常用的参数更新方法，它的公式
【深度学习】【OnnxRuntime】【Python】模型转化、环境搭建以及模型部署的详细教程牙牙要健康深度学习 onnx onnxruntime 深度学习 python 人工智能
【深度学习】【OnnxRuntime】【Python】模型转化、环境搭建以及模型部署的详细教程提示:博主取舍了很多大佬的博文并亲测有效,分享笔记邀大家共同学习讨论文章目录【深度学习】【OnnxRuntime】【Python】模型转化、环境搭建以及模型部署的详细教程前言模型转换--pytorch转onnxWindows平台搭建依赖环境onnxruntime调用onnx模型ONNXRuntime推理核
天下苦英伟达久矣！PyTorch官方免CUDA加速推理，Triton时代要来？诗者才子酒中仙物联网 /互联网 /人工智能 /其他 pytorch 人工智能 python
在做大语言模型（LLM）的训练、微调和推理时，使用英伟达的GPU和CUDA是常见的做法。在更大的机器学习编程与计算范畴，同样严重依赖CUDA，使用它加速的机器学习模型可以实现更大的性能提升。虽然CUDA在加速计算领域占据主导地位，并成为英伟达重要的护城河之一。但其他一些工作的出现正在向CUDA发起挑战，比如OpenAI推出的Triton，它在可用性、内存开销、AI编译器堆栈构建等方面具有一定的优势
pytorch安装(windows) m0_62244898 windows 人工智能
（1）下载pycharmPyCharm:thePythonIDEforProfessionalDevelopersbyJetBrains(2)下载anacondaAnaconda|TheWorld'sMostPopularDataSciencePlatform(3)创建一个新环境：torchcondacreate-ntorch-y(4)进入新环境condaactivatetorch(5)加入清华源
深度学习入门篇：PyTorch实现手写数字识别 AI_Guru人工智能深度学习 pytorch 人工智能
深度学习作为机器学习的一个分支，近年来在图像识别、自然语言处理等领域取得了显著的成就。在众多的深度学习框架中，PyTorch以其动态计算图、易用性强和灵活度高等特点，受到了广泛的喜爱。本篇文章将带领大家使用PyTorch框架，实现一个手写数字识别的基础模型。手写数字识别简介手写数字识别是计算机视觉领域的一个经典问题，目的是让计算机能够识别并理解手写数字图像。这个问题通常作为深度学习入门的练习，因为
【ShuQiHere】小白也能懂的 TensorFlow 和 PyTorch GPU 配置教程 ShuQiHere tensorflow pytorch 人工智能
【ShuQiHere】在深度学习中，GPU的使用对于加速模型训练至关重要。然而，对于许多刚刚入门的小白来说，如何在TensorFlow和PyTorch中指定使用GPU进行训练可能会感到困惑。在本文中，我将详细介绍如何在这两个主流的深度学习框架中指定使用GPU进行训练，并确保每一个步骤都简单易懂，跟着我的步骤来，你也能轻松上手！1.安装所需库首先，确保你已经安装了TensorFlow或PyTorch
解决ModuleNotFoundError: No module named ‘torch的方法梅菊林各种问题解决方案开发语言
ModuleNotFoundError:Nomodulenamed‘torch’错误是Python在尝试导入名为torch的模块时找不到该模块而抛出的异常。torch是PyTorch深度学习框架的核心库，如果你的Python环境中没有安装这个库，尝试导入时就会遇到这个错误。文章目录报错问题报错原因解决方法报错问题当你尝试在Python脚本或交互式环境中执行以下命令时：importtorch如果Py
Python中item()和items()的用处 ~|Bernard| 深度学习疑点总结 python pytorch 深度学习
item()区别一:在pytorch训练时，一般用到.item()。比如loss.item()。我们可以做个简单测试代码看看它的区别:importtorchx=torch.randn(2,2)print(x)print(x[1,1])print(x[1,1].item())运行结果:tensor([[-2.0743,0.1675],[0.7016,-0.6779]])tensor(-0.6779)
GPU版pytorch安装普通攻击往后拉 python tips 神经网络基础模型关键点
由于经常重装系统，导致电脑的环境需要经常重新配置，其中尤其是cudatorch比较难以安装，因此记录一下安装GPU版本torch的过程。1）安装CUDAtoolkit这个可以看做是N卡所有cuda计算的基础，一般都会随驱动的更新自动安装，但是不全，仍然需要安装toolkit，并不需要先看已有版本是哪个，反正下载完后会自动覆盖原有的cuda。下载网站两个：国内网站：只能下载最新的toolkit，但是
轻松升级：Ollama + OpenWebUI 安装与配置【AIStarter】 ai_xiaogui AI作画 AI软件人工智能 AI写作 AIStarter
Ollama是一个开源项目，用于构建和训练大规模语言模型，而OpenWebUI则提供了一个方便的前端界面来管理和监控这些模型。本文将指导你如何更新这两个工具，并顺利完成配置。准备工作确保你的系统已安装Git和Python环境。安装必要的依赖库，如TensorFlow或PyTorch等。更新步骤克隆项目：使用Git命令行工具克隆最新的Ollama和OpenWebUI仓库到本地。更新代码：确保你正在使
conda环境管理 Johnson0722 python python conda 环境管理
Anaconda使用软件包管理系统Conda进行包管理，为用户对不同版本、不同功能的工具包的环境进行配置和管理提供便利。来看一看使用conda来进行环境管理的基本命令创建环境创建一个名为test的python环境，指定python版本是3.7.3，并在test环境中安装pytorchcondacreate--nametestpython=3.7.3pytorch查看系统中的所有环境用户安装的不同环
R-Drop pytorch实现 warpin 深度学习深度学习 pytorch
Pytorch实现了R-Drop，可以用于训练分类模型。#-*-coding:utf-8-*-"""Description:AnimplementationofR-Drop(https://arxiv.org/pdf/2106.14448.pdf).Authors:lihpCreateDate:2021/8/24"""fromtorchimportnnfromtorch.nnimportfunct
Transformer模型：WordEmbedding实现 Galaxy.404 Transformer transformer 深度学习人工智能 embedding
前言最近在学Transformer，学了理论的部分之后就开始学代码的实现，这里是跟着b站的up主的视频记的笔记，视频链接：19、Transformer模型Encoder原理精讲及其PyTorch逐行实现_哔哩哔哩_bilibili正文首先导入所需要的包：importtorchimportnumpyasnpimporttorch.nnasnnimporttorch.nn.functionalasF关
如何使用Pytorch-Metric-Learning？鱼儿也有烦恼 PyTorch pytorch
文章目录如何使用Pytorch-Metric-Learning？1.Pytorch-Metric-Learning库9个模块的功能1.1Sampler模块1.2Miner模块1.3Loss模块1.4Reducer模块1.5Distance模块1.6Regularizer模块1.7Trainer模块1.8Tester模块1.9Utils模块2.如何使用PyTorchMetricLearning库中的
每天五分钟玩转深度学习框架PyTorch：获取神经网络模型的参数幻风_huanfeng 深度学习框架pytorch 深度学习 pytorch 神经网络人工智能模型参数 python
本文重点当我们定义好神经网络之后，这个网络是由多个网络层构成的，每层都有参数，我们如何才能获取到这些参数呢？我们将再下面介绍几个方法来获取神经网络的模型参数，此文我们是为了学习第6步（优化器）。获取所有参数Parametersfromtorchimportnnnet=nn.Sequential(nn.Linear(4,2),nn.Linear(2,2))print(list(net.paramet
一维数组 list 呢，怎么转换成 (批次句子长度特征值 )三维向量 python pytorch lstm 编程人工智能 zhangfeng1133 python pytorch 人工智能数据挖掘
一、介绍对于一维数组，如果你想将其转换成适合深度学习模型（如LSTM）输入的格式，你需要考虑将其扩展为三维张量。这通常涉及到批次大小（batchsize）、序列长度（sequencelength）和特征数量（numberoffeatures）的维度。以下是如何将一维数组转换为这种格式的步骤：###1.确定维度-**批次大小（BatchSize）**：这是你一次处理的样本数量。-**序列长度（Seq
每天五分钟玩转深度学习框架PyTorch：将nn的神经网络层连接起来幻风_huanfeng 深度学习框架pytorch 深度学习 pytorch 神经网络人工智能机器学习 python
本文重点前面我们学习pytorch中已经封装好的神经网络层，有全连接层，激活层，卷积层等等，我们可以直接使用。如代码所示我们直接使用了两个nn.Linear（），这两个linear之间并没有组合在一起，所以forward的之后，分别调用了，在实际使用中我们常常将几个神经层组合在一起，这样不仅操作方便，而且代码清晰。这里介绍一下Sequential()和ModuleList()，它们可以将多个神经网
项目实训十四 qq_51946537 项目实训 python
将pytorch模型封装成接口由于前面对于模型的构建、训练、评估都以完成，接下来要做的就是将按照项目要求，将模型封装成接口，供后端直接调用。我需要做的是后端直接调用系统命令pythonprase.py-img图片便可以直接得到解析结果。由于前面的测试模型的正确率都是批量处理过的图片，而现在前端只会传过来要解析的图片或者图片路径，而且图片也是未经处理过的，显然直接输入不会得到好的结果，并且性能也会比
pytorch矩阵乘法 weixin_45694975 pytorch 深度学习神经网络
一、torch.bmminput1shape:(batch_size,seq1_len,emb_dim)input2shape:(batch_size,emb_dim,seq2_len)outputshape:(batch_size,seq1_len,seq2_len)注意：torch.bmm只适合三维tensor做矩阵运算特别地，torch.bmm支持tenso广播运算input1shape:(
pytorch矩阵乘法总结 chenxi yan PyTorch 学习 pytorch 矩阵深度学习
1.element-wise（*）按元素相乘，支持广播，等价于torch.mul()a=torch.tensor([[1,2],[3,4]])b=torch.tensor([[2,3],[4,5]])c=a*b#等价于torch.mul(a,b)#tensor([[2,6],#[12,20]])a*torch.tensor([1,2])#广播,等价于torch.mul(a,torch.tensor
推荐开源项目：PyTorch-Metric-Learning 潘惟妍
推荐开源项目：PyTorch-Metric-Learningpytorch-metric-learningTheeasiestwaytousedeepmetriclearninginyourapplication.Modular,flexible,andextensible.WritteninPyTorch.项目地址:https://gitcode.com/gh_mirrors/py/pytorc
pytroch2.4 提示到不到fbgemm.dll bziyue python pytorch
#python/pytorch/问题记录```>>>importtorchTraceback(mostrecentcalllast):File"",line1,inFile"C:\Users\95416\AppData\Local\Programs\Python\Python312\Lib\site-packages\torch\__init__.py",line148,inraiseerrOSE
xml解析小猪猪08 xml
1、DOM解析的步奏准备工作： 1.创建DocumentBuilderFactory的对象 2.创建DocumentBuilder对象 3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件 4.通过Document的getElem
每个开发人员都需要了解的一个SQL技巧 brotherlamp linux linux视频 linux教程 linux自学 linux资料
对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： CREATE TABLE books ( id &
Quartz——CronTrigger触发器 eksliang quartz CronTrigger
转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。二.Cron表达式介绍 1）Cron表达式规则表 Quartz
Informatica基础 18289753290 Informatica Monitor manager workflow Designer
1. 1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 2）Workflow Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 3）Workflow Monitor：监控Workflow和Session运行情况，生成日志和报告 4）Repository Manager：
linux下为程序创建启动和关闭的的sh文件，scrapyd为例酷的飞上天空 scrapy
对于一些未提供service管理的程序每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件下面以scrapy启动server为例，文件名为run.sh： #端口号，根据此端口号确定PID PORT=6800 #启动命令所在目录 HOME='/home/jmscra/scrapy/' #查询出监听了PORT端口
人--自私与无私永夜-极光
今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么? 从客观的角度来看,人有自私的行为,也有无私的
Ubuntu安装NS-3 环境脚本随便小屋 ubuntu
将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令： sudo ./ns3environment.sh >>result 这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示 com
创业的简单感受 aijuans 创业的简单感受
2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
如何经营自己的独立人脉 aoyouzi 如何经营自己的独立人脉
独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。以一个普通的银行柜员
JSP基础百合不是茶 jsp 注释隐式对象
1,JSP语句的声明 <%! 声明 %> 　　声明：这个就是提供java代码声明变量、方法等的场所。表达式 <%= 表达式 %> 　　这个相当于赋值，可以在页面上显示表达式的结果，程序代码段/小型指令　<% 程序代码片段 %> 2,JSP的注释
web.xml之session-config、mime-mapping bijian1013 java web.xml servlet session-config mime-mapping
session-config 1.定义： <session-config> <session-timeout>20</session-timeout> </session-config> 2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。 mime-mapping 1.定义： <mime-m
互联网开放平台（1） Bill_chen 互联网 qq 新浪微博百度腾讯
现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 1.淘宝开放平台(TOP) 网址：http://open.taobao.com/ 依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。目前TOP的三条主线： TOP访问网站：open.taobao.com ISV后台：my.open.ta
【MongoDB学习笔记九】MongoDB索引 bit1129 mongodb
索引可以在任意列上建立索引索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 使用索引可以加快查询,但同时会降低修改,插入等的性能内嵌文档照样可以建立使用索引测试数据 var p1 = { "name":"Jack", "age&q
JDBC常用API之外的总结白糖_ jdbc
做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。 ResultSetMetaData获取ResultSet对象的元数据信息
apache VelocityEngine使用记录 bozch VelocityEngine
VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。使用方法如下： VelocityEngine engine = new VelocityEngine();// 定义模板引擎 Properties properties = new Properties();// 模板引擎属
编程之美-快速找出故障机器 bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; public class TheLostID { /*编程之美假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。 1.假设在某个时间得到一个数据文件ID的列表，是
关于Java中redirect与forward的区别 chenbowen00 java servlet
在Servlet中两种实现： forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); redirect方式：response.sendRedirect(“/somePage.jsp”); forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
[信号与系统]人体最关键的两个信号节点 comsci 系统
如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做百汇穴, 另外一个节点在腰部,中医的名称叫做命门如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
oracle 存储过程执行权限 daizj oracle 存储过程权限执行者调用者
在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 CREATE OR REPLACE PROCEDURE TestProc IS fla
为mysql数据库建立索引 dengkane mysql 性能索引
前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
学习C语言常见误区如何看懂一个程序如何掌握一个程序以及几个小题目示例 dcj3sjt126com c 算法
如果看懂一个程序，分三步 1、流程 2、每个语句的功能 3、试数如何学习一些小算法的程序尝试自己去编程解决它，大部分人都自己无法解决如果解决不了就看答案关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义照着答案去敲调试错误
centos6.3安装php5.4报错 dcj3sjt126com centos6
报错内容如下: Resolving Dependencies --> Running transaction check ---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed --> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for
JSONP请求 flyer0126 jsonp
使用jsonp不能发起POST请求。 It is not possible to make a JSONP POST request. JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
Spring Security（03）——核心类简介 234390216 Authentication
核心类简介目录 1.1 Authentication 1.2 SecurityContextHolder 1.3 AuthenticationManager和AuthenticationProvider 1.3.1 &nb
在CentOS上部署JAVA服务 java--hhf java jdk centos Java服务
本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行第一步：卸载旧Linux自带的JDK ①查看本机JDK版本 java -version 结果如下 java version "1.6.0"
oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date] ldzyz007 oracle mysql SQL Server
oracle &n
记Protocol Oriented Programming in Swift of WWDC 2015 ningandjin protocol WWDC 2015 Swift2.0
其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭，把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS rensanning keepalived
（一）Keepalived （1）安装 # cd /usr/local/src # wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz # tar zxvf keepalived-1.2.15.tar.gz # cd keepalived-1.2.15 # ./configure # make &a
ORACLE数据库SCN和时间的互相转换 tomcat_oracle oracle sql
SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换；　　用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了；　　操作方法：　　1、通过dbms_f
Spring MVC 方法注解拦截器 xp9802 spring mvc
应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理先看一个实例,使用@access_required拦截： ?