Here is my code and my error picture

error.PNG1291×337 13 KB

%cd
!mkdir -p /root/data
%cd /root/data
!pip install -q -U opencv-python
!pip install -q pandas
!pip install numpy==1.15.0
!pip install torch
!pip3 install torchvision
!pip install --upgrade torch torchvision

from google.colab import drive
drive.mount('/content/gdrive')

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

from google.colab import files
uploaded = files.upload()

items = os.listdir('/content')
print (items) 

for each_image in items:
  if each_image.endswith(".jpg"):
    print (each_image)
    full_path = "/content/" + each_image
    dest_path = "/root/data/" + each_image
    print (full_path)
    image = cv2.imread(full_path)
    im_gray = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)
    im_blur=cv2.GaussianBlur(im_gray,(5,5),0)
    im,thre=cv2.threshold(im_blur,180,255,cv2.THRESH_BINARY_INV) 
    thre2=cv2.resize(thre,(28,28),interpolation=cv2.INTER_AREA)
    plt.subplot(2,3,6)
    plt.tight_layout()  
    plt.imshow(thre2)
    plt.xticks([])
    plt.yticks([])
    plt.show()  
    cv2.imwrite(dest_path,thre2)

!pip install -U -q PyDrive

from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials

# 1. Authenticate and create the PyDrive client.
auth.authenticate_user()
gauth = GoogleAuth()
gauth.credentials = GoogleCredentials.get_application_default()
drive = GoogleDrive(gauth)

from googleapiclient.http import MediaFileUpload
from googleapiclient.discovery import build
drive_service = build('drive','v3')

def save_file_to_drive(name,path):
  file_metadata={
      'name':name,
      'mimeType': 'application/octet-stream'
  }
  media= MediaFileUpload(path,mimetype='application/octet-stream',resumable=True)
  created=drive_service.files().create(body=file_metadata,media_body=media,fields='id').execute()
  return created


import zipfile
!zip -r /root/image.zip  /root/data

 save_file_to_drive('image.zip','/root/image.zip')


n_epochs=3
batch_size_train=32
batch_size_test=89
learning_rate=0.01
momentum=0.5
log_interval=10

random_seed=1
torch.backends.cudnn.enabled=False
torch.manual_seed(random_seed)

data_transforms = transforms.Compose([    
    transforms.Resize(256),
    transforms.CenterCrop(256),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225] )])

%cd /content/gdrive/'My Drive'/root/data

train_datasets = torchvision.datasets.ImageFolder(root= "/content/gdrive/My Drive/root/", transform=data_transforms)

import torch.utils.data as data
train_data_loader = data.DataLoader(train_datasets, batch_size=batch_size_train, shuffle=True,  num_workers=4)
test_data = torchvision.datasets.ImageFolder(root="/content/gdrive/My Drive/root/", transform=data_transforms)
test_data_loader = data.DataLoader(test_data, batch_size=batch_size_test, shuffle=True, num_workers=4)

examples=enumerate(test_data_loader)
batch_idx, (example_data, example_targets) = next(examples)

import matplotlib.pyplot as plt

fig = plt.figure()
for i in range(12):
  plt.subplot(3,4,i+1)
  plt.tight_layout()
  plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
  plt.title("Ground Truth: {}".format(example_targets[i]))
  plt.xticks([])
  plt.yticks([])
fig

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        return F.log_softmax(x)

network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
                      momentum=momentum)

train_losses = []
train_counter = []
test_losses = []
test_counter = [i*len(train_data_loader.dataset) for i in range(n_epochs + 1)]

def train(n_epochs):
  network.train()
  for batch_idx, (data, target) in enumerate(train_data_loader):
    optimizer.zero_grad()
    output = network(data)
    loss = F.nll_loss(output, target)
    loss.backward()
    optimizer.step()
    if batch_idx % log_interval == 0:
      print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
        n_epochs, batch_idx * len(data), len(train_data_loader.dataset),
        100. * batch_idx / len(train_data_loader), loss.item()))
      train_losses.append(loss.item())
      train_counter.append((batch_idx*64) + ((n_epochs-1)*len(train_data_loader.dataset)))
      torch.save(network.state_dict(), 'model.pth')
      torch.save(optimizer.state_dict(), 'optimizer.pth')

def test():
  network.eval()
  test_loss = 0
  correct = 0
  with torch.no_grad():
    for data, target in test_data_loader:
      output = network(data)
      test_loss += F.nll_loss(output, target, size_average=False).item()
      pred = output.data.max(1, keepdim=True)[1]
      correct += pred.eq(target.data.view_as(pred)).sum()
  test_loss /= len(test_data_loader.dataset)
  test_losses.append(test_loss)
  print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, len(test_data_loader.dataset),
    100. * correct / len(test_data_loader.dataset)))

test()
for n_epochs in range(1, n_epochs + 1):
  train(n_epochs)
  test()