zoukankan      html  css  js  c++  java
  • Pytorch-基础入门之CNN

    CNN卷积神经网络现在大家已经耳熟能详,在这里不做太多介绍。本次实验的模型使用两层卷积层。

    这一块的话与上一篇逻辑斯蒂回归使用的是相同的数据集MNIST。

    第一部分:构造模型

    # Import Libraries
    import torch
    import torch.nn as nn
    from torch.autograd import Variable
    
    # Create CNN Model
    class CNNModel(nn.Module):
        def __init__(self):
            super(CNNModel, self).__init__()
            
            # Convolution 1
            self.cnn1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=5, stride=1, padding=0)
            self.relu1 = nn.ReLU()
            
            # Max pool 1
            self.maxpool1 = nn.MaxPool2d(kernel_size=2)
         
            # Convolution 2
            self.cnn2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, stride=1, padding=0)
            self.relu2 = nn.ReLU()
            
            # Max pool 2
            self.maxpool2 = nn.MaxPool2d(kernel_size=2)
            
            # Fully connected 1
            self.fc1 = nn.Linear(32 * 4 * 4, 10) 
        
        def forward(self, x):
            # Convolution 1
            out = self.cnn1(x)
            out = self.relu1(out)
            
            # Max pool 1
            out = self.maxpool1(out)
            
            # Convolution 2 
            out = self.cnn2(out)
            out = self.relu2(out)
            
            # Max pool 2 
            out = self.maxpool2(out)
            
            # flatten
            out = out.view(out.size(0), -1)
    
            # Linear function (readout)
            out = self.fc1(out)
            
            return out
    
    # batch_size, epoch and iteration
    batch_size = 100
    n_iters = 2500
    num_epochs = n_iters / (len(features_train) / batch_size)
    num_epochs = int(num_epochs)
    
    # Pytorch train and test sets
    train = torch.utils.data.TensorDataset(featuresTrain,targetsTrain)
    test = torch.utils.data.TensorDataset(featuresTest,targetsTest)
    
    # data loader
    train_loader = torch.utils.data.DataLoader(train, batch_size = batch_size, shuffle = False)
    test_loader = torch.utils.data.DataLoader(test, batch_size = batch_size, shuffle = False)
        
    # Create CNN
    model = CNNModel()
    
    # Cross Entropy Loss 
    error = nn.CrossEntropyLoss()
    
    # SGD Optimizer
    learning_rate = 0.1
    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
    

      第二部分:训练模型

    # CNN model training
    count = 0
    loss_list = []
    iteration_list = []
    accuracy_list = []
    for epoch in range(num_epochs):
        for i, (images, labels) in enumerate(train_loader):
            
            train = Variable(images.view(100,1,28,28))
            labels = Variable(labels)
            
            # Clear gradients
            optimizer.zero_grad()
            
            # Forward propagation
            outputs = model(train)
            
            # Calculate softmax and ross entropy loss
            loss = error(outputs, labels)
            
            # Calculating gradients
            loss.backward()
            
            # Update parameters
            optimizer.step()
            
            count += 1
            
            if count % 50 == 0:
                # Calculate Accuracy         
                correct = 0
                total = 0
                # Iterate through test dataset
                for images, labels in test_loader:
                    
                    test = Variable(images.view(100,1,28,28))
                    
                    # Forward propagation
                    outputs = model(test)
                    
                    # Get predictions from the maximum value
                    predicted = torch.max(outputs.data, 1)[1]
                    
                    # Total number of labels
                    total += len(labels)
                    
                    correct += (predicted == labels).sum()
                
                accuracy = 100 * correct / float(total)
                
                # store loss and iteration
                loss_list.append(loss.data)
                iteration_list.append(count)
                accuracy_list.append(accuracy)
            if count % 500 == 0:
                # Print Loss
                print('Iteration: {}  Loss: {}  Accuracy: {} %'.format(count, loss.data, accuracy))
    

    结果:

    Iteration: 500  Loss: 0.11975778639316559  Accuracy: 96 %
    Iteration: 1000  Loss: 0.04979655146598816  Accuracy: 97 %
    Iteration: 1500  Loss: 0.03124646656215191  Accuracy: 97 %
    Iteration: 2000  Loss: 0.013534960336983204  Accuracy: 98 %
    

     第三部分:可视化展示

    # visualization loss 
    plt.plot(iteration_list,loss_list)
    plt.xlabel("Number of iteration")
    plt.ylabel("Loss")
    plt.title("CNN: Loss vs Number of iteration")
    plt.show()
    
    # visualization accuracy 
    plt.plot(iteration_list,accuracy_list,color = "red")
    plt.xlabel("Number of iteration")
    plt.ylabel("Accuracy")
    plt.title("CNN: Accuracy vs Number of iteration")
    plt.show()
    

     结果:

     
     
     

     

  • 相关阅读:
    结构体数组
    关于VCL的编写 (一) 如何编写自己的VCL控件
    谈一下怎样设计Oracle 分区表
    c++截取屏幕图片并保存(函数代码实现)
    微信公众平台开发之微团购
    怎么调用系统通讯录并向被选中联系人发送短信
    TFS(Team Foundation Server)介绍和入门
    2014百度之星资格赛题解
    C语言中volatilekeyword的作用
    自己定义滑动开关控件的实现与使用
  • 原文地址:https://www.cnblogs.com/zhuozige/p/14696722.html
Copyright © 2011-2022 走看看