devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

resnet50网络实现垃圾分类_resnet50垃圾分类

作者：盐析白兔 | 2024-04-06 15:28:30

赞

踩

resnet50垃圾分类

一：介绍：

        经典resnet网络是由何凯明团队于2015年提出，论文名为《Deep Residual Learning for Image Recognition》

        resnet网络所要解决的问题为深度神经网络的“退化”问题，即随着神经网络搭建的越深，拟合效果却越差的问题，并且这个问题不是由过拟合诱发的。

        resnet也成为残差网络，网络由残差块构建：

        残差块由多个级联的卷积层和一个shortcut connections组成，将二者的输出值累加后，通过ReLU激活层得到残差块的输出。多个残差块可以串联起来，从而实现更深的网络。

        残差块有两种设计方式

 

        左图针对较浅的网络，如ResNet-18/34；右图针对较深的网络，又称为”bottleneck” building block，如ResNet-50/101/152，使用此方式的目的就是为了降低参数数目。

        论文给出了五种不同层数的resnet

         ResNet-18/34对应的每个残差块的卷积kernel大小依次是3*3、3*3，ResNet-50/101/152对应的每个残差块的卷积kernel大小依次是1*1、3*3、1*1。

         论文中给出了层数为34的ResNet网络结构

二：实现垃圾分类

1.准备数据集：

 2.加载数据集：

  1. class garbage_datasets(Dataset):
  2.     def __init__(self, filepath):
  3.         self.images = []
  4.         self.labels = []
  5.         self.transform = transform
  6.         for filename in tqdm(os.listdir(filepath+'Hazardous waste')):
  7.             image = Image.open(filepath+'Hazardous waste/'+filename)
  8.             image = image.resize((224,224))
  9.             image = self.transform(image)
  10.             self.images.append(image)
  11.             self.labels.append(0)
  12.         for filename in tqdm(os.listdir(filepath+'Kitchen waste')):
  13.             image = Image.open(filepath+'Kitchen waste/'+filename)
  14.             image = image.resize((224,224))
  15.             image = self.transform(image)
  16.             self.images.append(image)
  17.             self.labels.append(1)  
  18.         for filename in tqdm(os.listdir(filepath+'Other garbage')):
  19.             image = Image.open(filepath+'Other garbage/'+filename)
  20.             image = image.resize((224,224))
  21.             image = self.transform(image)
  22.             self.images.append(image)
  23.             self.labels.append(2)  
  24.         for filename in tqdm(os.listdir(filepath+'Recyclable garbage')):
  25.             image = Image.open(filepath+'Recyclable garbage/'+filename)
  26.             image = image.resize((224,224))
  27.             image = self.transform(image)
  28.             self.images.append(image)
  29.             self.labels.append(3)                
  30.         self.labels = torch.LongTensor(self.labels)
  31.     
  32.     def __getitem__(self, index):
  33.         return self.images[index], self.labels[index]
  34.  
  35.     def __len__(self):
  36.         images = np.array(self.images)
  37.         len = images.shape[0]
  38.         return len
  39.  
  40.  
  41. train_data = garbage_datasets('data/train/')
  42. train_loader = DataLoader(train_data,batch_size = batch_size,shuffle = True)
  43.  
  44. val_data = garbage_datasets('data/val/')
  45. val_loader = DataLoader(val_data,batch_size = batch_size)

 3.构建网络：

  1. class Bottleneck(nn.Module):
  2.     extention=4
  3.     def __init__(self,inplanes,planes,stride,downsample=None):
  4.  
  5.         super(Bottleneck, self).__init__()
  6.  
  7.         self.conv1=nn.Conv2d(inplanes,planes,kernel_size=1,stride=stride,bias=False)
  8.         self.bn1=nn.BatchNorm2d(planes)
  9.  
  10.         self.conv2=nn.Conv2d(planes,planes,kernel_size=3,stride=1,padding=1,bias=False)
  11.         self.bn2=nn.BatchNorm2d(planes)
  12.  
  13.         self.conv3=nn.Conv2d(planes,planes*self.extention,kernel_size=1,stride=1,bias=False)
  14.         self.bn3=nn.BatchNorm2d(planes*self.extention)
  15.  
  16.         self.relu=nn.ReLU(  )
  17.  
  18.  
  19.         self.downsample=downsample
  20.         self.stride=stride
  21.  
  22.     def forward(self,x):
  23.  
  24.         residual=x
  25.  
  26.         out=self.conv1(x)
  27.         out=self.bn1(out)
  28.         out=self.relu(out)
  29.  
  30.         out=self.conv2(out)
  31.         out=self.bn2(out)
  32.         out=self.relu(out)
  33.  
  34.         out=self.conv3(out)
  35.         out=self.bn3(out)
  36.         out=self.relu(out)
  37.  
  38.  
  39.         if self.downsample is not None:
  40.             residual=self.downsample(x)
  41.  
  42.  
  43.         out=out + residual
  44.         out=self.relu(out)
  45.  
  46.         return out
  47.  
  48.  
  49. class ResNet(nn.Module):
  50.     def __init__(self,block,layers,num_class):
  51.  
  52.         self.inplane=64
  53.         super(ResNet, self).__init__()
  54.  
  55.  
  56.         self.block=block
  57.         self.layers=layers
  58.  
  59.  
  60.         self.conv1=nn.Conv2d(3,self.inplane,kernel_size=7,stride=2,padding=3,bias=False)
  61.         self.bn1=nn.BatchNorm2d(self.inplane)
  62.         self.relu=nn.ReLU()
  63.         self.maxpool=nn.MaxPool2d(kernel_size=3,stride=2,padding=1)
  64.  
  65.  
  66.         self.stage1=self.make_layer(self.block,64,layers[0],stride=1)
  67.         self.stage2=self.make_layer(self.block,128,layers[1],stride=2)
  68.         self.stage3=self.make_layer(self.block,256,layers[2],stride=2)
  69.         self.stage4=self.make_layer(self.block,512,layers[3],stride=2)
  70.  
  71.  
  72.         self.avgpool=nn.AvgPool2d(7)
  73.         self.fc=nn.Linear(512*block.extention,num_class)
  74.  
  75.     def forward(self,x):
  76.  
  77.         out=self.conv1(x)
  78.         out=self.bn1(out)
  79.         out=self.relu(out)
  80.         out=self.maxpool(out)
  81.  
  82.  
  83.         out=self.stage1(out)
  84.         out=self.stage2(out)
  85.         out=self.stage3(out)
  86.         out=self.stage4(out)
  87.  
  88.  
  89.         out=self.avgpool(out)
  90.         out=torch.flatten(out,1)
  91.         out=self.fc(out)
  92.  
  93.         return out
  94.  
  95.     def make_layer(self,block,plane,block_num,stride=1):
  96.         block_list=[]
  97.         downsample=None
  98.         if(stride!=1 or self.inplane!=plane*block.extention):
  99.             downsample=nn.Sequential(
  100.                 nn.Conv2d(self.inplane,plane*block.extention,stride=stride,kernel_size=1,bias=False),
  101.                 nn.BatchNorm2d(plane*block.extention)
  102.             )
  103.         conv_block=block(self.inplane,plane,stride=stride,downsample=downsample)
  104.         block_list.append(conv_block)
  105.         self.inplane=plane*block.extention
  106.  
  107.         for i in range(1,block_num):
  108.             block_list.append(block(self.inplane,plane,stride=1))
  109.  
  110.         return nn.Sequential(*block_list)
  111.  
  112.  
  113.  
  114.  
  115. model=ResNet(Bottleneck,[3,4,6,3],4)

4.训练模型：

  1. def train(epoch):
  2.     model.train()
  3.     print("epoch:",epoch+1)
  4.     running_loss = 0.0
  5.     for batch_idx,data in enumerate(train_loader,0):
  6.         inputs, targets = data
  7.         inputs, targets = inputs.to(device),targets.to(device)
  8.  
  9.         optimizer.zero_grad()
  10.         outputs = model(inputs)
  11.  
  12.         loss = criterion(outputs,targets)
  13.         loss.backward()
  14.         optimizer.step()
  15.         running_loss = running_loss + loss.item()
  16.  
  17.     print('train loss: %.3f' % (running_loss/batch_idx))
  18.     torch.save(model.state_dict(), './model1.pth')

5.验证模型：

  1. def val():
  2.     model.eval()
  3.     correct = 0
  4.     total = 0
  5.     with torch.no_grad():
  6.         for data in val_loader:
  7.             images, labels = data
  8.             images, labels = images.to(device), labels.to(device)
  9.             outputs = model(images)
  10.             _, predicted = torch.max(outputs.data, dim=1)
  11.             total += labels.size(0)
  12.             correct += (predicted == labels).sum().item()
  13.     print('accuracy on test set: %d %% ' % (100*correct/total))
  14.     return correct/total

6.测试模型：

  1. def test(imgpath):
  2.  
  3.     font={	'color': 'red',
  4. 		'size': 20,
  5. 		'family': 'Times New Roman',
  6.     	'style':'italic'}
  7.  
  8.     o_img = Image.open(imgpath)
  9.     o_img1 = o_img.resize((224,224))
  10.  
  11.     img = transform(o_img1)
  12.     img = img.unsqueeze(0)
  13.     img = img.cuda()
  14.     print(img.shape)
  15.  
  16.     model = ResNet(Bottleneck,[3,4,6,3],4)
  17.     model.load_state_dict(torch.load("model.pth")) 
  18.     model = model.cuda()
  19.    
  20.     output = model(img)
  21.     _, predict = torch.max(output,dim=1)
  22.     if predict == 0:
  23.         print("Hazardous waste")
  24.         plt.imshow(o_img)
  25.         plt.text(0, -6.0, "Hazardous waste", fontdict=font)
  26.         plt.show()
  27.     if predict == 1:
  28.         print("Kitchen waste")
  29.         plt.imshow(o_img)
  30.         plt.text(0, -6.0, "Kitchen waste", fontdict=font)
  31.         plt.show() 
  32.     if predict == 2:
  33.         print("Other garbage")
  34.         plt.imshow(o_img)
  35.         plt.text(0, -6.0, "Other garbage", fontdict=font)
  36.         plt.show() 
  37.     if predict == 3:
  38.         print("Recyclable garbage")
  39.         plt.imshow(o_img)
  40.         plt.text(0, -6.0, "Recyclable garbage", fontdict=font)
  41.         plt.show()

源代码：

  1. import torch.nn as nn
  2. import torch
  3. import numpy as np
  4. from torch.utils.data import DataLoader,Dataset
  5. from torchvision import transforms
  6. import torchvision
  7. import torch.nn.functional as F
  8. import torch.optim as optim
  9. import os
  10. from tqdm import tqdm
  11. from PIL import Image
  12. import matplotlib.pyplot as plt
  13.  
  14. batch_size = 8
  15.  
  16. transform = transforms.Compose([transforms.ToTensor(),
  17.                                 transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])])
  18.  
  19. torch.cuda.empty_cache()
  20.  
  21. class garbage_datasets(Dataset):
  22.     def __init__(self, filepath):
  23.         self.images = []
  24.         self.labels = []
  25.         self.transform = transform
  26.         for filename in tqdm(os.listdir(filepath+'Hazardous waste')):
  27.             image = Image.open(filepath+'Hazardous waste/'+filename)
  28.             image = image.resize((224,224))
  29.             image = self.transform(image)
  30.             self.images.append(image)
  31.             self.labels.append(0)
  32.         for filename in tqdm(os.listdir(filepath+'Kitchen waste')):
  33.             image = Image.open(filepath+'Kitchen waste/'+filename)
  34.             image = image.resize((224,224))
  35.             image = self.transform(image)
  36.             self.images.append(image)
  37.             self.labels.append(1)  
  38.         for filename in tqdm(os.listdir(filepath+'Other garbage')):
  39.             image = Image.open(filepath+'Other garbage/'+filename)
  40.             image = image.resize((224,224))
  41.             image = self.transform(image)
  42.             self.images.append(image)
  43.             self.labels.append(2)  
  44.         for filename in tqdm(os.listdir(filepath+'Recyclable garbage')):
  45.             image = Image.open(filepath+'Recyclable garbage/'+filename)
  46.             image = image.resize((224,224))
  47.             image = self.transform(image)
  48.             self.images.append(image)
  49.             self.labels.append(3)                
  50.         self.labels = torch.LongTensor(self.labels)
  51.     
  52.     def __getitem__(self, index):
  53.         return self.images[index], self.labels[index]
  54.  
  55.     def __len__(self):
  56.         images = np.array(self.images)
  57.         len = images.shape[0]
  58.         return len
  59.  
  60.  
  61. train_data = garbage_datasets('data/train/')
  62. train_loader = DataLoader(train_data,batch_size = batch_size,shuffle = True)
  63.  
  64. val_data = garbage_datasets('data/val/')
  65. val_loader = DataLoader(val_data,batch_size = batch_size)
  66.  
  67.  
  68. class Bottleneck(nn.Module):
  69.     extention=4
  70.     def __init__(self,inplanes,planes,stride,downsample=None):
  71.  
  72.         super(Bottleneck, self).__init__()
  73.  
  74.         self.conv1=nn.Conv2d(inplanes,planes,kernel_size=1,stride=stride,bias=False)
  75.         self.bn1=nn.BatchNorm2d(planes)
  76.  
  77.         self.conv2=nn.Conv2d(planes,planes,kernel_size=3,stride=1,padding=1,bias=False)
  78.         self.bn2=nn.BatchNorm2d(planes)
  79.  
  80.         self.conv3=nn.Conv2d(planes,planes*self.extention,kernel_size=1,stride=1,bias=False)
  81.         self.bn3=nn.BatchNorm2d(planes*self.extention)
  82.  
  83.         self.relu=nn.ReLU(  )
  84.  
  85.  
  86.         self.downsample=downsample
  87.         self.stride=stride
  88.  
  89.     def forward(self,x):
  90.  
  91.         residual=x
  92.  
  93.         out=self.conv1(x)
  94.         out=self.bn1(out)
  95.         out=self.relu(out)
  96.  
  97.         out=self.conv2(out)
  98.         out=self.bn2(out)
  99.         out=self.relu(out)
  100.  
  101.         out=self.conv3(out)
  102.         out=self.bn3(out)
  103.         out=self.relu(out)
  104.  
  105.  
  106.         if self.downsample is not None:
  107.             residual=self.downsample(x)
  108.  
  109.  
  110.         out=out + residual
  111.         out=self.relu(out)
  112.  
  113.         return out
  114.  
  115.  
  116. class ResNet(nn.Module):
  117.     def __init__(self,block,layers,num_class):
  118.  
  119.         self.inplane=64
  120.         super(ResNet, self).__init__()
  121.  
  122.  
  123.         self.block=block
  124.         self.layers=layers
  125.  
  126.  
  127.         self.conv1=nn.Conv2d(3,self.inplane,kernel_size=7,stride=2,padding=3,bias=False)
  128.         self.bn1=nn.BatchNorm2d(self.inplane)
  129.         self.relu=nn.ReLU()
  130.         self.maxpool=nn.MaxPool2d(kernel_size=3,stride=2,padding=1)
  131.  
  132.  
  133.         self.stage1=self.make_layer(self.block,64,layers[0],stride=1)
  134.         self.stage2=self.make_layer(self.block,128,layers[1],stride=2)
  135.         self.stage3=self.make_layer(self.block,256,layers[2],stride=2)
  136.         self.stage4=self.make_layer(self.block,512,layers[3],stride=2)
  137.  
  138.  
  139.         self.avgpool=nn.AvgPool2d(7)
  140.         self.fc=nn.Linear(512*block.extention,num_class)
  141.  
  142.     def forward(self,x):
  143.  
  144.         out=self.conv1(x)
  145.         out=self.bn1(out)
  146.         out=self.relu(out)
  147.         out=self.maxpool(out)
  148.  
  149.  
  150.         out=self.stage1(out)
  151.         out=self.stage2(out)
  152.         out=self.stage3(out)
  153.         out=self.stage4(out)
  154.  
  155.  
  156.         out=self.avgpool(out)
  157.         out=torch.flatten(out,1)
  158.         out=self.fc(out)
  159.  
  160.         return out
  161.  
  162.     def make_layer(self,block,plane,block_num,stride=1):
  163.         block_list=[]
  164.         downsample=None
  165.         if(stride!=1 or self.inplane!=plane*block.extention):
  166.             downsample=nn.Sequential(
  167.                 nn.Conv2d(self.inplane,plane*block.extention,stride=stride,kernel_size=1,bias=False),
  168.                 nn.BatchNorm2d(plane*block.extention)
  169.             )
  170.         conv_block=block(self.inplane,plane,stride=stride,downsample=downsample)
  171.         block_list.append(conv_block)
  172.         self.inplane=plane*block.extention
  173.  
  174.         for i in range(1,block_num):
  175.             block_list.append(block(self.inplane,plane,stride=1))
  176.  
  177.         return nn.Sequential(*block_list)
  178.  
  179.  
  180.  
  181.  
  182. model=ResNet(Bottleneck,[3,4,6,3],4)
  183.  
  184. device = torch.device('cuda'if torch.cuda.is_available else 'cpu')
  185.  
  186. model.to(device)
  187.  
  188. model.load_state_dict(torch.load("model1.pth")) 
  189.  
  190. criterion = torch.nn.CrossEntropyLoss()
  191. optimizer = optim.Adam(model.parameters(),lr = 0.001)
  192.  
  193.  
  194. def train(epoch):
  195.     model.train()
  196.     print("epoch:",epoch+1)
  197.     running_loss = 0.0
  198.     for batch_idx,data in enumerate(train_loader,0):
  199.         inputs, targets = data
  200.         inputs, targets = inputs.to(device),targets.to(device)
  201.  
  202.         optimizer.zero_grad()
  203.         outputs = model(inputs)
  204.  
  205.         loss = criterion(outputs,targets)
  206.         loss.backward()
  207.         optimizer.step()
  208.         running_loss = running_loss + loss.item()
  209.  
  210.     print('train loss: %.3f' % (running_loss/batch_idx))
  211.     torch.save(model.state_dict(), './model1.pth')  
  212.  
  213. def val():
  214.     model.eval()
  215.     correct = 0
  216.     total = 0
  217.     with torch.no_grad():
  218.         for data in val_loader:
  219.             images, labels = data
  220.             images, labels = images.to(device), labels.to(device)
  221.             outputs = model(images)
  222.             _, predicted = torch.max(outputs.data, dim=1)
  223.             total += labels.size(0)
  224.             correct += (predicted == labels).sum().item()
  225.     print('accuracy on test set: %d %% ' % (100*correct/total))
  226.     return correct/total
  227.  
  228. if __name__ == '__main__':
  229.     acc_list = []
  230.     epoch_list = []
  231.  
  232.     for epoch in range(5):
  233.         train(epoch)
  234.         acc = val()
  235.         acc_list.append(acc)
  236.         epoch_list.append(epoch + 1)
  237.  
  238.     plt.plot(epoch_list,acc_list)
  239.     plt.ylabel("ACC")
  240.     plt.xlabel("Epoch")
  241.     plt.show()    
  242.  
  243.

测试源码：

  1. from torchvision import transforms
  2. from PIL import Image
  3. import matplotlib.pyplot as plt
  4. import torch
  5. import torch.nn as nn
  6.  
  7.  
  8. transform = transforms.Compose([transforms.ToTensor(),
  9.                                 transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])])
  10.  
  11. class Bottleneck(nn.Module):
  12.  
  13.     extention=4
  14.     def __init__(self,inplanes,planes,stride,downsample=None):
  15.  
  16.         super(Bottleneck, self).__init__()
  17.  
  18.         self.conv1=nn.Conv2d(inplanes,planes,kernel_size=1,stride=stride,bias=False)
  19.         self.bn1=nn.BatchNorm2d(planes)
  20.  
  21.         self.conv2=nn.Conv2d(planes,planes,kernel_size=3,stride=1,padding=1,bias=False)
  22.         self.bn2=nn.BatchNorm2d(planes)
  23.  
  24.         self.conv3=nn.Conv2d(planes,planes*self.extention,kernel_size=1,stride=1,bias=False)
  25.         self.bn3=nn.BatchNorm2d(planes*self.extention)
  26.  
  27.         self.relu=nn.ReLU(  )
  28.  
  29.  
  30.         self.downsample=downsample
  31.         self.stride=stride
  32.  
  33.     def forward(self,x):
  34.  
  35.         residual=x
  36.  
  37.         out=self.conv1(x)
  38.         out=self.bn1(out)
  39.         out=self.relu(out)
  40.  
  41.         out=self.conv2(out)
  42.         out=self.bn2(out)
  43.         out=self.relu(out)
  44.  
  45.         out=self.conv3(out)
  46.         out=self.bn3(out)
  47.         out=self.relu(out)
  48.  
  49.  
  50.         if self.downsample is not None:
  51.             residual=self.downsample(x)
  52.  
  53.  
  54.         out=out + residual
  55.         out=self.relu(out)
  56.  
  57.         return out
  58.  
  59.  
  60. class ResNet(nn.Module):
  61.     def __init__(self,block,layers,num_class):
  62.  
  63.         self.inplane=64
  64.         super(ResNet, self).__init__()
  65.  
  66.  
  67.         self.block=block
  68.         self.layers=layers
  69.  
  70.  
  71.         self.conv1=nn.Conv2d(3,self.inplane,kernel_size=7,stride=2,padding=3,bias=False)
  72.         self.bn1=nn.BatchNorm2d(self.inplane)
  73.         self.relu=nn.ReLU()
  74.         self.maxpool=nn.MaxPool2d(kernel_size=3,stride=2,padding=1)
  75.  
  76.  
  77.         self.stage1=self.make_layer(self.block,64,layers[0],stride=1)
  78.         self.stage2=self.make_layer(self.block,128,layers[1],stride=2)
  79.         self.stage3=self.make_layer(self.block,256,layers[2],stride=2)
  80.         self.stage4=self.make_layer(self.block,512,layers[3],stride=2)
  81.  
  82.  
  83.         self.avgpool=nn.AvgPool2d(7)
  84.         self.fc=nn.Linear(512*block.extention,num_class)
  85.  
  86.     def forward(self,x):
  87.  
  88.         out=self.conv1(x)
  89.         out=self.bn1(out)
  90.         out=self.relu(out)
  91.         out=self.maxpool(out)
  92.  
  93.  
  94.         out=self.stage1(out)
  95.         out=self.stage2(out)
  96.         out=self.stage3(out)
  97.         out=self.stage4(out)
  98.  
  99.  
  100.         out=self.avgpool(out)
  101.         out=torch.flatten(out,1)
  102.         out=self.fc(out)
  103.  
  104.         return out
  105.  
  106.     def make_layer(self,block,plane,block_num,stride=1):
  107.         block_list=[]
  108.         downsample=None
  109.         if(stride!=1 or self.inplane!=plane*block.extention):
  110.             downsample=nn.Sequential(
  111.                 nn.Conv2d(self.inplane,plane*block.extention,stride=stride,kernel_size=1,bias=False),
  112.                 nn.BatchNorm2d(plane*block.extention)
  113.             )
  114.         conv_block=block(self.inplane,plane,stride=stride,downsample=downsample)
  115.         block_list.append(conv_block)
  116.         self.inplane=plane*block.extention
  117.  
  118.         for i in range(1,block_num):
  119.             block_list.append(block(self.inplane,plane,stride=1))
  120.  
  121.         return nn.Sequential(*block_list)
  122.  
  123. def test(imgpath):
  124.  
  125.     font={	'color': 'red',
  126. 		'size': 20,
  127. 		'family': 'Times New Roman',
  128.     	'style':'italic'}
  129.  
  130.     o_img = Image.open(imgpath)
  131.     o_img1 = o_img.resize((224,224))
  132.  
  133.     img = transform(o_img1)
  134.     img = img.unsqueeze(0)
  135.     img = img.cuda()
  136.     print(img.shape)
  137.  
  138.     model = ResNet(Bottleneck,[3,4,6,3],4)
  139.     model.load_state_dict(torch.load("model.pth")) 
  140.     model = model.cuda()
  141.    
  142.     output = model(img)
  143.     _, predict = torch.max(output,dim=1)
  144.     if predict == 0:
  145.         print("Hazardous waste")
  146.         plt.imshow(o_img)
  147.         plt.text(0, -6.0, "Hazardous waste", fontdict=font)
  148.         plt.show()
  149.     if predict == 1:
  150.         print("Kitchen waste")
  151.         plt.imshow(o_img)
  152.         plt.text(0, -6.0, "Kitchen waste", fontdict=font)
  153.         plt.show() 
  154.     if predict == 2:
  155.         print("Other garbage")
  156.         plt.imshow(o_img)
  157.         plt.text(0, -6.0, "Other garbage", fontdict=font)
  158.         plt.show() 
  159.     if predict == 3:
  160.         print("Recyclable garbage")
  161.         plt.imshow(o_img)
  162.         plt.text(0, -6.0, "Recyclable garbage", fontdict=font)
  163.         plt.show()   
  164.  
  165.  
  166. if __name__ == "__main__":
  167.     test('data/test/Hazardous waste/2.jpg')

最终验证集的准确率可达到70%

附几张测试成功的图片

    

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/372773
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号