## technological process

To prepare data, you need to prepare DataLoader

To build the model, torch can be used to construct a deep neural network

Model training

Save the model, save the model and continue to use it later

Evaluation of the model, use the test set to observe the quality of the model

## Prepare data

First download the digital image data from torchvsion as the training data set. The download field means whether to download if there is no one. Use the following code to download and save it in the data folder

images = torchvision.datasets.MNIST(r'data',train=True,download=True)

To facilitate data processing, we need to convert the image type

Use torchvision Combine, totensor, normalize classes in transforms

Use the data loader to disrupt the images. Check the data in the data loader at this time. There is a list. The first number in the list is the eigenvalue (a third-order tensor), and the second number is the target value, that is, what is the number

## Build model

Here, the activation function is to make the fitting effect that can only be linear become non-linear, which increases the nonlinear segmentation ability of the model

import torchvision from torch.utils.data import DataLoader from torchvision.transforms import Compose,ToTensor, Normalize import torch.nn as nn import torch.nn.functional as f # Prepare data fn = Compose([ ToTensor(), Normalize((0.1307,), (0.3081,)) ]) minst = torchvision.datasets.MNIST(r'data',train=True,download=True,transform=fn) minst2 = DataLoader(minst,shuffle=True) for i in minst2: print(i) break class MinstModel(nn.model,): def __init__(self): super(MinstModel, self).__init__() self.fc1 = nn.Linear(28 * 28 * 1, 28) # Defines the shape of Linear's input and output self.fc2 = nn.Linear(28, 10) # Defines the shape of Linear's input and output def forward(self, input): # Because the original input data is the shape: [batch_size,1,28,28], matrix multiplication is required for neural network operation # So you need to change the shape # Modify the input to [batch_size,28*28] input = input.view(input[0], 28*28) # Make a full connection (multiplication) and transform the shape input = self.fc1(input) # Activate the processing function, the processing function is ReLU, and the picture is applicable input = f.relu(input) # Make another full connection out = self.fc2(input)

## loss function

The loss function is used to estimate the inconsistency between the predicted value f(x) of the model and the real value Y. finding the minimum value of the loss function is what we require. Here, because we are classified and multi classified, here is an explanation for others

Cross entropy loss function for multi classification: generated by two steps

One line of code

f.log_softmax(), you can perform softmax and log operations on the incoming

## Training model

Put the prepared data into the model for training

Then, through back propagation, the parameters with the best fitting effect and the lowest error are found

def train(ones): # Instantiated training model for idx, (input, traget) in enumerate(minst2): # Set the gradient of all parameters to 0 optimizer.zero_grad() # Model training out out = model1(input) # Get lost, loss = f.nll_loss(out,traget) # Back propagation calculation gradient loss.backward() # Update parameter values optimizer.step() if idx % 10 == 0: print(ones, idx, loss.item()) # Save model if idx % 1000 == 0: torch.save(model1.state_dict(),'./model.pkl') torch.save(optimizer.state_dict(),'./optimizer.pkl')

1. If the gradient is set to 0, it will be accumulated by default

2. The gradient is calculated by back propagation. The principle of back propagation is as follows:

Here, back propagation a,b,c are the parameters we want to find, and j(a,b,c) is the result of derivation according to the loss function, which is brought into the calculation of each parameter gradient and updated

Finally, save the model to avoid training from the beginning every time

## All codes

import os import torch import torchvision from torch.utils.data import DataLoader from torchvision.transforms import Compose,ToTensor, Normalize import torch.nn as nn from torch.optim import Adam import torch.nn.functional as f # Handwritten numeral recognition # Prepare data fn = Compose([ ToTensor(), Normalize((0.1307,), (0.3081,)) ]) minst = torchvision.datasets.MNIST(r'data',train=True,download=True,transform=fn) minst2 = DataLoader(minst,shuffle=True) # Build model class MinstModel(nn.Module): def __init__(self): super(MinstModel, self).__init__() self.fc1 = nn.Linear(28 * 28 * 1, 28) # Defines the shape of Linear's input and output self.fc2 = nn.Linear(28, 10) # Defines the shape of Linear's input and output def forward(self, input): # Because the original input data is the shape: [batch_size,1,28,28], matrix multiplication is required for neural network operation # So you need to change the shape # Modify the input to [batch_size,28*28] input = input.view(-1, 28*28) # Make a full connection (multiplication) and transform the shape input = self.fc1(input) # Activate the processing function, the processing function is ReLU, and the picture is applicable input = f.relu(input) # Make another full connection out = self.fc2(input) # softmax and logarithm the output once out = f.log_softmax(out,dim=-1) return out model1 = MinstModel() # Usage of optimization class: # Instantiation, c optimizer = Adam(model1.parameters(), lr=0.001) if os.path.exists('model.pkl'): model1.load_state_dict(torch.load('./model.pkl')) optimizer.load_state_dict(torch.load('./optimizer.pkl')) def train(): # Instantiated training model for idx, (input, traget) in enumerate(minst2): # Set the gradient of all parameters to 0 optimizer.zero_grad() # Model training out out = model1(input) # Get lost, loss = f.nll_loss(out,traget) # Back propagation calculation gradient loss.backward() # Update parameter values optimizer.step() if idx % 10 == 0: print(idx, loss.item()) # Save model if idx % 1000 == 0: torch.save(model1.state_dict(),'./model.pkl') torch.save(optimizer.state_dict(),'./optimizer.pkl') if __name__ == '__main__': train()