pytorch白话入门笔记1.9-CNN卷积神经网络

最新推荐文章于 2024-09-11 22:01:32 发布
最新推荐文章于 2024-09-11 22:01:32 发布
阅读量627 收藏 1
点赞数 1
分类专栏： pytorch小白笔记 文章标签： 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bszjyaj/article/details/105216714
版权

1.CNN卷积神经网络

（1）代码

import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision      # 数据库模块
import matplotlib.pyplot as plt

torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 50
LR = 0.001          # 学习率
DOWNLOAD_MNIST = True  # 如果你已经下载好了mnist数据就写上 False


# Mnist 手写数字
train_data = torchvision.datasets.MNIST(
    root='./mnist/',    # 保存或者提取位置
    train=True,  # this is training data
    transform=torchvision.transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

#plot one example
print(train_data.train_data.size)
print(train_data.train_labels.size())
plt.imshow(train_data.train_data[0].numpy(),cmap='gray')
plt.title('%i'%train_data.train_labels[0])
plt.show()

（2）运行结果

torch.Size([60000])

Process finished with exit code 0

2.打印CNN

（1）代码

import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision      # 数据库模块
import matplotlib.pyplot as plt
from torch.autograd import Variable

torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 50
LR = 0.001          # 学习率
DOWNLOAD_MNIST = False  # 如果你已经下载好了mnist数据就写上 False


# Mnist 手写数字
train_data = torchvision.datasets.MNIST(
    root='./mnist/',    # 保存或者提取位置
    train=True,  # this is training data
    transform=torchvision.transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

#plot one example
# print(train_data.train_data.size)
# print(train_data.train_labels.size())
# plt.imshow(train_data.train_data[0].numpy(),cmap='gray')
# plt.title('%i'%train_data.train_labels[0])
# plt.show()

train_loader = Data.DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True,num_workers=2)

test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)#意味着不是train_data,而是testdata

# # 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
# train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# # 为了节约时间, 测试时只测试前2000个
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.   # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
# test_x = Variable(torch.unsqueeze(test_data.test_data,dim=1),volatile=True).type(torch.FloatTensor)[:2000]/255.#运行不通
test_y = test_data.test_labels[:2000]


# 建立CNN神经网络
class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(  #（1，28，28）
                in_channels=1,#输入图片层灰度图1层，RGB3
                out_channels=16,#16个特征，即高度16
                kernel_size=5,#filter 长宽为5个像素点
                stride=1,#每隔多少像素跳动一下
                padding=2,#原始图片周围围上0，为了不丢失边缘数据
                #if strid = 1,padding = (kernel_size-1)/2 = (5-1)/2=2
                # wn+1=(wn+p*2-k)/s+1
            ),#卷积层——过滤器 filter ；（16，28，28）
            nn.ReLU(),#神经网络--非线性激活层
            nn.MaxPool2d(kernel_size=2),#池化层,若不池化，数据大，需stride>1；（16，14，14）
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16,32,5,1,2),#（32,14,14）32= 28+2*2-5/1+1
            nn.ReLU(),#（32,14,14）
            nn.MaxPool2d(2)  #（32,7,7）
        )
        self.out = nn.Linear(32*7*7,10)

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)#batch,32,7,7
        x = x.view(x.size(0),-1) #batch，32*7*7
        output=self.out(x)
        return output


cnn = CNN()
print(cnn)

（2）运行结果

CNN(
  (conv1): Sequential(
    (0): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (conv2): Sequential(
    (0): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (out): Linear(in_features=1568, out_features=10, bias=True)
)

Process finished with exit code 0

3.训练CNN

（1）代码

import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision      # 数据库模块
import matplotlib.pyplot as plt
from torch.autograd import Variable

torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 50  # 批训练的数据个数
LR = 0.001          # 学习率
DOWNLOAD_MNIST = False  # 如果你已经下载好了mnist数据就写上 False


# Mnist 手写数字
train_data = torchvision.datasets.MNIST(
    root='./mnist/',    # 保存或者提取位置
    train=True,  # this is training data
    transform=torchvision.transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

#plot one example
# print(train_data.train_data.size)
# print(train_data.train_labels.size())
# plt.imshow(train_data.train_data[0].numpy(),cmap='gray')
# plt.title('%i'%train_data.train_labels[0])
# plt.show()

train_loader = Data.DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True)## num_workers=2,多线程来读数据 windows删除此行

test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)#意味着不是train_data,而是testdata

# # 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
# train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# # 为节约时间, 测试前2000个
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.   # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)

test_y = test_data.test_labels[:2000]


# 建立CNN神经网络
class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(  #（1，28，28）
                in_channels=1,#输入图片层灰度图1层，RGB3
                out_channels=16,#16个特征，即高度16 filter
                kernel_size=5,#filter size 长宽为5个像素点
                stride=1,#每隔多少像素跳动一下
                padding=2,#原始图片周围围上0，为了不丢失边缘数据
                #if strid = 1,padding = (kernel_size-1)/2 = (5-1)/2=2
                # wn+1=(wn+p*2-k)/s+1
            ),#卷积层——过滤器 filter ；（16，28，28）
            nn.ReLU(),#神经网络--非线性激活层
            nn.MaxPool2d(kernel_size=2),#池化层,若不池化，数据大，需stride>1；（16，14，14）
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16,32,5,1,2),#（32,14,14）32= 28+2*2-5/1+1
            nn.ReLU(),#（32,14,14）
            nn.MaxPool2d(2)  #（32,7,7）
        )
        self.out = nn.Linear(32*7*7,10)

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)#batch,32,7,7
        x = x.view(x.size(0),-1) #batch，32*7*7
        output=self.out(x)
        return output,x


cnn = CNN()
print(cnn)

optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()

# following function (plot_with_labels) is for visualization, can be ignored if not interested
from matplotlib import cm
try: from sklearn.manifold import TSNE; HAS_SK = True
except: HAS_SK = False; print('Please install sklearn for layer visualization')
def plot_with_labels(lowDWeights, labels):
    plt.cla()
    X, Y = lowDWeights[:, 0], lowDWeights[:, 1]
    for x, y, s in zip(X, Y, labels):
        c = cm.rainbow(int(255 * s / 9)); plt.text(x, y, s, backgroundcolor=c, fontsize=9)
    plt.xlim(X.min(), X.max()); plt.ylim(Y.min(), Y.max()); plt.title('Visualize last layer'); plt.show(); plt.pause(0.01)

plt.ion()
# training and testing
for epoch in range(EPOCH):
    for step, (b_x, b_y) in enumerate(train_loader):   # gives batch data, normalize x when iterate train_loader

        output = cnn(b_x)[0]               # cnn output
        loss = loss_func(output, b_y)   # cross entropy loss
        optimizer.zero_grad()           # clear gradients for this training step
        loss.backward()                 # backpropagation, compute gradients
        optimizer.step()                # apply gradients

        if step % 50 == 0:
            test_output, last_layer = cnn(test_x)
            pred_y = torch.max(test_output, 1)[1].data.numpy()
            accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)
            if HAS_SK:
                # Visualization of trained flatten layer (T-SNE)
                tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)
                plot_only = 500
                low_dim_embs = tsne.fit_transform(last_layer.data.numpy()[:plot_only, :])
                labels = test_y.numpy()[:plot_only]
                plot_with_labels(low_dim_embs, labels)
plt.ioff()

# print 10 predictions from test data
test_output, _ = cnn(test_x[:10])
pred_y = torch.max(test_output, 1)[1].data.numpy()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

（2）运行结果

CNN(
  (conv1): Sequential(
    (0): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (conv2): Sequential(
    (0): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (out): Linear(in_features=1568, out_features=10, bias=True)
)
Epoch:  0 | train loss: 2.3105 | test accuracy: 0.06
Epoch:  0 | train loss: 0.6184 | test accuracy: 0.83
Epoch:  0 | train loss: 0.1290 | test accuracy: 0.87
Epoch:  0 | train loss: 0.2371 | test accuracy: 0.91
Epoch:  0 | train loss: 0.4058 | test accuracy: 0.93
Epoch:  0 | train loss: 0.0850 | test accuracy: 0.94
Epoch:  0 | train loss: 0.1956 | test accuracy: 0.94
Epoch:  0 | train loss: 0.1087 | test accuracy: 0.95
Epoch:  0 | train loss: 0.1238 | test accuracy: 0.96
Epoch:  0 | train loss: 0.0703 | test accuracy: 0.96
Epoch:  0 | train loss: 0.2217 | test accuracy: 0.96
Epoch:  0 | train loss: 0.2101 | test accuracy: 0.96
Epoch:  0 | train loss: 0.0237 | test accuracy: 0.97
Epoch:  0 | train loss: 0.0844 | test accuracy: 0.97
Epoch:  0 | train loss: 0.2158 | test accuracy: 0.97
Epoch:  0 | train loss: 0.1007 | test accuracy: 0.97
Epoch:  0 | train loss: 0.0433 | test accuracy: 0.97
Epoch:  0 | train loss: 0.0923 | test accuracy: 0.98
Epoch:  0 | train loss: 0.0564 | test accuracy: 0.98
Epoch:  0 | train loss: 0.1006 | test accuracy: 0.98
Epoch:  0 | train loss: 0.0320 | test accuracy: 0.98
Epoch:  0 | train loss: 0.0229 | test accuracy: 0.98
Epoch:  0 | train loss: 0.0233 | test accuracy: 0.98
Epoch:  0 | train loss: 0.1208 | test accuracy: 0.98
[7 2 1 0 4 1 4 9 5 9] prediction number
[7 2 1 0 4 1 4 9 5 9] real number

Process finished with exit code 0

青青不熬夜
关注
专栏目录
【t-SNE可视化CNNs特征向量-代码】
a5_b6c7的博客
03-07 1040
T-SNE可视化CNNs特征向量-代码
CNN结果 TSNE可视化
dannyle的博客
07-07 3662
CNN结果 TSNE可视化
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
最新发布
weixin_48060069的博客
09-11 420
DataLoader是 PyTorch 提供的一个工具类，用于高效地加载和处理数据集。它可以帮助你在训练模型时更有效地管理和批量加载数据。让我们详细解析一下DataLoader。
pytorch使用CNN实现MNIST手写体的识别
weixin_43792166的博客
07-31 8447
**MNIST数据集介绍：**MNIST数据集在torvision.datasets里面，可以自行加载，其中训练集有6W张，测试集有1W，都为灰度图，即channel为1，图片的大小都是28x28，下面图片就是一部分数据。 导入工具包 import torch from torch.autograd import Variable import torch.nn as nn import mat...
torch dataloader 数据并行_【PyTorch修炼】三、先做减法，具体例子带你了解torch使用的基本套路（分类和时间序列小例子）...
weixin_39949889的博客
11-22 587
一、前言最近确实太忙了，没能很好的写这个系列的文章，但是大家不要急，好事多磨，我要保证每一篇的质量。今天要讲的是利用torch去做实验，大体完成一个任务的写法框架思路。因为这节之后我会大量的举例以及各种完整的代码细节讲解，大概意思就是我想利用例子把很多细节抠出来这样来说明一些知识点，这样操作可能要比直接列出来知识点更具体些，大家接受这些知识点也能更加的舒服一些。二、做减法，思考整个流程都需要什么？...
一文搞定Pytorch快速入门
小陈说CV的博客
06-05 266
文章目录1 简介2 CNN3 RNN 1 简介 Pytorch 是 Facebook 开发的 DL 开源框架，目前学术界运用广泛，本文将通过 MNIST 手写数字识别案例分享 Pytorch 的常用操作。 2 CNN import torch import torch.nn as nn import torch.utils.data as Data import torchvision import matplotlib.pyplot as plt torch.manual_seed(1)
pytorch-cnn-visualizations:卷积神经网络可视化技术的Pytorch实现
04-05
该存储库包含许多在PyTorch中实现的卷积神经网络可视化技术。 注意：我删除了cv2依赖性并将存储库移至PIL。 有些事情可能会坏掉（尽管我测试了所有方法），如果在某些情况下无法解决问题，可以提出问题，我将不胜...
基于多尺度1D-CNN卷积神经网络的轴承故障诊断代码+数据集
06-13
数据集：CWRU 训练集：0hp，1hp，2hp（3种故障大小） 测试集：3hp（3种故障...参考论文：基于多尺度卷积神经网络的电机故障诊断方法研究_王威 适用对象：初学者 代码注释完整，下载即可使用，提供半小时线上答疑讲解
3DUnetCNN:Pytorch 3D U-Net卷积神经网络（CNN）设计用于医学图像分割
05-13
3D U-Net卷积神经网络 背景 我们设计3DUnetCNN使其易于应用和控制各种深度学习模型对医学成像数据的训练和应用。 上面的链接提供了有关如何将本项目与来自MICCAI各种挑战的数据一起使用的示例/教程。 依存关系 火炬 ...
GestureRecognition-PyTorch:动作识别网络-CNN + LSTM
05-13
手势动作识别 微调预训练的CNN模型（AlexNet，VGG，ResNet），然后微调LSTM。 该网络应用于手势控制无人机。 训练： 下载直升机编组数据集： : usp ... pyTorch-0.3.xx Opencv的3.3.1 PIL-5.0.0 Numpy-1.13.1
卷积神经网络CNN火焰识别Pytorch训练代码 基于UFS-Net识别火焰白烟黑烟
08-09
# 卷积神经网络CNN火焰识别Pytorch训练代码 基于UFS_Net识别火焰白烟黑烟 本项目实现了训练UFS-Net模型用于火焰识别。UFS-Net是一个用于图像分类的神经网络模型，用于检测火焰、白烟和黑烟等烟雾类别。解压后下载...
pytorch test单张图片_（五）pytorch学习笔记
weixin_39804641的博客
11-25 742
博客地址：https://blog.csdn.net/CoderPai/article/details/104166883点击阅读原文，更好的阅读体验CoderPai 是一个专注于人工智能在量化交易应用的算法实战平台，主要关注人工智能在量化交易上面的应用。如果你对人工智能感兴趣，请快快关注 “CoderPai” 微信号(coderpai)吧。(一)pytorch学习笔记(二)pytorc...
Pytorch（五）入门：DataLoader 和 Dataset
热门推荐
嘿芝麻的树洞
09-22 29万+
DataLoader 和 Dataset 构建模型的基本方法，我们了解了。 接下来，我们就要弄明白怎么对数据进行预处理，然后加载数据，我们以前手动加载数据的方式，在数据量小的时候，并没有太大问题，但是到了大数据量，我们需要使用 shuffle, 分割成mini-batch 等操作的时候，我们可以使用PyTorch的API快速地完成这些操作。 Dataset是一个包装类，用来将数据包装为Datas...
机器学习pytorch平台代码学习笔记（10）——循环神经网络RNN
玥晓珖的博客
05-09 2993
https://morvanzhou.github.io/tutorials/machine-learning/torch/4-02-A-RNN/RNN用来分析有序数据，新状态和旧状态有关。也就是它在有顺序的数据上进行学习. 为了记住这些数据, RNN 会像人一样产生对先前发生事件的记忆. 不能回忆久远记忆（神经网络较深），因为梯度消失或者梯度爆炸。为了解决普通RNN的弊端提出了LSTM 技术（ ...
pytorch学习笔记（一）：Dataset和DataLoader
qq_38432089的博客
09-16 1243
参考：https://blog.csdn.net/zw__chen/article/details/82806900 一、DataLoader 1、DataLoader 是 torch 给你用来包装你的数据的工具. 所以你要将自己的 (numpy array 或其他) 数据形式装换成 Tensor, 然后再放进这个包装器中. 2、Dataset是一个抽象类，不能实例化，要先继承。DataLoader可以直接实例化 3、Dataset有内置数据集： 这些内置数据集有对应的__getitem__()和__l
PyTorch学习系列(一)——加载数据并生成batch数据
CodeTutor
05-17 5万+
开始学习PyTorch，在此记录学习过程。准备按顺序写以下系列： 加载数据并生成batch数据 数据预处理 构建神经网络 Tensor和Variable 定义loss 自动求导 优化器更新参数 训练神经网络 参数_定义 参数_初始化 如何在训练时固定一些层？ 绘制loss和accuracy曲线 torch.nn.Container和torch.nn.Module 各层参数及激活值的可视化 保存训练好
任务七（pytorch）
weixin_41741008的博客
04-19 410
前言 Pytorch实现CNN卷积神将网络，以MNIST数据集为例 环境 Python 3 代码 import torch import torch.nn as nn from torch.autograd import Variable import torch.utils.data as Data import torchvision import matplotlib.pyplot as p...
PyTorch学习
omnispace的博客
09-21 1万+
一、PyTorch介绍 1、说明 PyTorch 是 Torch 在 Python 上的衍生（Torch 是一个使用 Lua 语言的神经网络库）和tensorflow比较 PyTorch建立的神经网络是动态的Tensorflow是建立静态图Tensorflow 的高度工业化, 它的底层代码是很难看懂的.PyTorch 好那么一点点, 如果你深入 API, 你至少能比看 T
Python Dataloader 多进程报错 num_workers参数设置
欢迎关注，共同进步！
12-12 5460
该报错一般发生在Windows系统中使用多进程。比如在Pycharm中执行如下代码： import torch import torch.utils.data as Data import numpy as np from sklearn.datasets import load_iris iris_x, irisy = load_iris(return_X_y=True) print("iris_x.dtype:", iris_x.dtype) print("irisy:", irisy.dtype
PyTorch项目：基于R-CNN算法的目标检测实现
- 卷积神经网络训练：利用AlexNet这一经典的卷积神经网络模型进行预训练。在目标检测项目中，网络需要被训练成能够识别汽车这一特定类别的特征。 - 分类器训练：通过线性SVM（支持向量机）对特征向量进行分类。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值