text: import io
  import torch 
  import torch.nn as nn 
  import torchvision.transforms as transforms 
  from PIL import Image
  
  # load model
  
  class NeuralNet(nn.Module):
      def __init__(self, num_classes):
          super(NeuralNet, self).__init__()
  		
          # Instantiate the ReLU nonlinearity
          self.relu = nn.ReLU()
          
          # Instantiate two convolutional layers
          self.conv1 = nn.Conv2d(in_channels=1, out_channels=5, kernel_size=3, padding=1)
          self.conv2 = nn.Conv2d(in_channels=5, out_channels=10, kernel_size=3, padding=1)
          
          # Instantiate a max pooling layer
          self.pool = nn.MaxPool2d(2, 2)
          
          # Instantiate a fully connected layer
          self.fc = nn.Linear(7 * 7 * 10, 10)
  
      def forward(self, x):
  
          # Apply conv followd by relu, then in next line pool
          x = self.relu(self.conv1(x))
          x = self.pool(x)
  
          # Apply conv followd by relu, then in next line pool
          x = self.relu(self.conv2(x))
          x = self.pool(x)
  
          # Prepare the image for the fully connected layer
          x = x.view(-1, 7 * 7 * 10)
  
          # Apply the fully connected layer and return the result
          return self.fc(x)
  
  input_size = 784 # 28x28
  hidden_size = 500 
  num_classes = 10
  
  model = NeuralNet(num_classes)
  
  PATH = "app/mnist_cnn.pth"
  model.load_state_dict(torch.load(PATH))
  model.eval()
  
  # image -> tensor
  def transform_image(image_bytes):
      transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),
                                      transforms.Resize((28,28)),
                                      transforms.ToTensor(),
                                      transforms.Normalize((0.1307,),(0.3081,))])
  
      image = Image.open(io.BytesIO(image_bytes))
      return transform(image).unsqueeze(0)
  
  # predict
  def get_prediction(image_tensor):
      images = image_tensor
      outputs = model(images)
          # max returns (value ,index)
      _, predicted = torch.max(outputs.data, 1)
      return predicted