深度学习数据集—水果数据集大合集

Posted 地理探险家

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了深度学习数据集—水果数据集大合集相关的知识,希望对你有一定的参考价值。

近期整理的各类水果(包括干果)数据集,分享给大家。

1、8类水果图片数据集(每类100张图片左右)['橘子','菠萝','苹果','木瓜','火龙果','香蕉','樱桃','芒果']

从谷歌图像中下载和整理。数据被分成3个文件夹:train(80%)、test(10%)和val(10%)。

 

 

下载地址:8类水果数据集 

2、11个葡萄品种的叶片数据集。

        11个葡萄品种的叶片数据集,欧塞尔罗伊赤霞珠、品丽珠、赤霞珠、霞多丽、梅洛穆勒、图尔高、黑比诺、雷司令、白苏维浓、西拉、丹帕尼罗,葡萄生长环境实地拍摄,高清图片,每类大约100张叶片图片,共1009张图片。

 

 

下载地址:11类葡萄叶片数据集 

3、11水果注释数据集(Yolov5格式)(苹果,鳄梨,蓝莓,辣椒,樱桃,猕猴桃,芒果,橙子,岩瓜,草莓,小麦)

 

 

下载地址: 11类水果注释图片数据集

4、14种不同植物叶片数据集,0“苹果”1“蓝莓”2“樱桃”3“玉米”4“葡萄”5“橘子”6“桃子”7“胡椒”8“马铃薯”9“覆盆子”10“大豆”11“南瓜”12“草莓”13“西红柿”,各类图片数量如下:苹果988蓝莓467樱桃583玉米1206葡萄1458橘子1748桃子977胡椒765马铃薯716树莓264大豆1616南瓜574草莓673番茄5693

 

 

下载地址:14种不同植物叶片数据集

 5、草莓常见病害coco实例分割数据集,angular leafspot 叶角斑 Anthracnose Fruit Rot 炭疽病水果腐烂 Blossom Blight 花朵枯萎 Gray Mold 灰霉病 Leaf Spot 叶斑病 Powdery Mildew Fruit 白粉病水果 Powdery Mildew Leaf 白粉病叶片。

 

 

 

下载地址:草莓常见病害coco实例分割数据集

6、草莓叶片图像数据集,包含了草莓叶片的病虫害图片和正常的叶片图片,2500多张草莓叶子图片,非自然环境,单一背景。

 

 

 

下载地址: 草莓叶片的病虫害图像数据集

7、橙子多类疾病图片数据集,该数据集用于构建机器学习和深度学习算法,以对橙子的疾病进行分类。在这个数据集中,有一类是新鲜橙子,还有其他三类疾病,柑橘溃疡病,黑斑病和柑橘黄变病。每类疾病200-300张图片不等。

 

 

 

下载地址: 橙子多类疾病图片数据集

8、番茄疾病数据集(CSV+图片)18130张番茄叶病害图片

下载地址: 番茄疾病叶片病害图像数据集

9、甘蔗红腐病叶片数据集,总共有900多张图片,分为健康和染病法以及测试三个文件夹

  

下载地址:甘蔗红腐病叶片数据集

10、甘蔗茎秆状态数据集,分为健康和有损害2类,共2800多张图片

 

 下载地址: 甘蔗茎秆状态数据集

11、甘蔗叶面疾病检测数据集,枯萎病、健康、红腐病三类,每类100张图片

 

 

下载地址: 甘蔗叶面疾病检测数据集,枯萎病、健康、红腐病三类,

12、柑橘病虫害数据集,680多张柑橘黄龙病病害图片数据

 

下载地址: 柑橘病虫害数据集

13、柑橘类疾病图像分类数据集,包含柑橘溃疡病和黑斑病,每类1200张图片左右

 

 

下载地址:柑橘类疾病图像分类数据集

14、花生叶片病害检测数据集,该数据集包含图像及其标签xml文件,共335张花生叶片图像。 

 

 下载地址:花生叶片病害检测数据集

15、开心果图像数据集,该数据集共包含2148张图片,其中Kirmizi的1232张和Siirt P的916张。

 

下载地址: 开心果图像数据集,该数据集共包含2148张图片

16、木瓜成熟度图像识别数据集,实验共使用了57种水果的130个样本。这些果实可分为三个成熟期(EM1、EM2和EM3)。有些图像有多个采集,拥有多个图像。

下载地址: 木瓜成熟度图像识别数据集

17、苹果病害分类图片数据集,真实环境拍摄,共分为4类,每类在200-600张图片

 

下载地址: 苹果病害分类图片数据集

18、苹果病害数据集,包含保存在“健康”和“Scab”两个文件夹中的分类图像,以识别其类别。还有一个关于苹果叶子结痂症状的数据集,共1190张图片。

 下载地址:苹果病害数据集

19、葡萄叶图像数据集,Ak, Ala Idris, Büzgülü, Dimnit和Nazli葡萄叶子图片,每类葡萄100张图片。

 

 下载地址:葡萄叶图像数据集

20、葡萄在不同发展阶段的图像数据集,文件v0.1 1.212张图片,大小1280x720px,包含3.993个边界框。文件v0.2 2.099张图片,大小1280x720px,包含6.641个边界框。

 

 下载地址:葡萄在不同发展阶段的图像数据集

 21、秋天红黄葡萄叶分类图像数据集,葡萄地实拍,每类有葡萄叶500张以上

 

下载地址:秋天红黄葡萄叶分类图像数据集,葡萄地实拍

22、水果和蔬菜保质期数据集,它包括苹果、香蕉、西红柿、胡萝卜的图片。它可用于根据水果或蔬菜的保质期进行分类(每类水果分为了不同时长的保质期阶段,每个阶段有100张图片左右。例如1-5天的苹果、5-10天的苹果、10-15天的苹果图像。

 

 

下载地址:水果和蔬菜保质期数据集,它包括苹果、香蕉、西红柿、胡萝卜的图片

23、水果和蔬菜图像目标识别数据集,该数据集包含以下食物的图像水果-香蕉,苹果,梨,葡萄,橙子,猕猴桃,西瓜,石榴,菠萝,芒果。蔬菜-黄瓜,胡萝卜,辣椒,洋葱,土豆,柠檬,西红柿,萝卜,甜菜根,卷心菜,生菜,菠菜,黄豆,花椰菜,甜椒,辣椒,萝卜,玉米,甜玉米,甘薯,辣椒粉,jalepeño,姜,大蒜,豌豆,茄子。共3800多张图片

 

 

下载地址:水果和蔬菜图像目标识别数据集,该数据集包含以下食物的图像水果-香蕉,苹果,梨,葡萄,橙子,猕猴桃

24、桃树叶数据集,包含六种桃子的叶子图片。zip文件包含六种不同的桃子品种。里面的每个文件都有一个数字,代表各种类型。1) CP-03-06(试验品种,非官方品种);2)奥罗阿兹台克;3) Oro San Juan;4)细微;5) Colegio;6)罗宾。每类有200-700张图片不等。

 

 下载地址:桃树叶数据集,包含六种桃子的叶子图片

25、桃子成熟程度分类数据集,单张桃子拍照,共572张图片

 

下载地址:桃子成熟程度分类数据集,单张桃子拍照

26、西瓜花数据集,一共包含419张各类西瓜花的图片,可以用于西瓜花的识别模型的训练

 

 

 下载地址:西瓜花数据集,一共包含419张各类西瓜花的图片

深度学习100例 | 第4例:水果识别 - PyTorch实现

文章目录

大家好,我是K同学啊,今天讲《深度学习100例》PyTorch版的第4个例子,前面一些例子主要还是以带大家了解PyTorch为主,建议手动敲一下代码,只有自己动手了,才能真正体会到里面的内容,光看不练是没有用的。今天的重点是在PyTorch调用VGG-16算法模型。先来了解一下PyTorch与TensorFlow的区别

PyTorch VS TensorFlow

  • TensorFlow:简单,模块封装比较好,容易上手,对新手比较友好。在工业界最重要的是模型落地,目前国内的大部分企业支持TensorFlow模型在线部署,不支持Pytorch。
  • PyTorch前沿算法多为PyTorch版本,如果是你高校学生or研究人员,建议学这个。相对于TensorFlow,Pytorch在易用性上更有优势,更加方便调试。

当然如果你时间充足,我建议两个模型都是需要了解一下的,这两者都还是很重要的。

🍨 本文的重点:将讲解如何使用PyTorch构建神经网络模型(将对这一块展开详细的讲解)

🍖 我的环境:

  • 语言环境:Python3.8
  • 编译器:Jupyter Lab
  • 深度学习环境:
    • torch==1.10.0+cu113
    • torchvision==0.11.1+cu113
  • 创作平台:🔗 极链AI云
  • 创作教程:🔎 操作手册

深度学习环境配置教程:小白入门深度学习 | 第四篇:配置PyTorch环境

👉 往期精彩内容

  1. 深度学习100例 | 第1例:猫狗识别 - PyTorch实现
  2. 深度学习100例 | 第2例:人脸表情识别 - PyTorch实现

一、导入数据

from torchvision.transforms import transforms
from torch.utils.data       import DataLoader
from torchvision            import datasets
import torchvision.models   as models
import torch.nn.functional  as F
import torch.nn             as nn
import torch,torchvision

获取类别名字

import os,PIL,random,pathlib

data_dir = './04-data/'
data_dir = pathlib.Path(data_dir)

data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\\\")[1] for path in data_paths]
classeNames
['Apple',
 'Banana',
 'Carambola',
 'Guava',
 'Kiwi',
 'Mango',
 'muskmelon',
 'Orange',
 'Peach',
 'Pear',
 'Persimmon',
 'Pitaya',
 'Plum',
 'Pomegranate',
 'Tomatoes']

加载数据文件

total_datadir = './04-data/'

# 关于transforms.Compose的更多介绍可以参考:https://blog.csdn.net/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor,并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布(高斯分布),使模型更容易收敛
        mean=[0.485, 0.456, 0.406], 
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

total_data = datasets.ImageFolder(total_datadir,transform=train_transforms)
total_data
Dataset ImageFolder
    Number of datapoints: 12000
    Root location: ./04-data/
    StandardTransform
Transform: Compose(
               Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=None)
               ToTensor()
               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
           )

划分数据

train_size = int(0.8 * len(total_data))
test_size  = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
train_dataset, test_dataset
(<torch.utils.data.dataset.Subset at 0x24bbdb84ac0>,
 <torch.utils.data.dataset.Subset at 0x24bbdb84610>)
train_size,test_size
(9600, 2400)
train_loader = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=16,
                                           shuffle=True,
                                           num_workers=1)
test_loader = torch.utils.data.DataLoader(test_dataset,
                                          batch_size=16,
                                          shuffle=True,
                                          num_workers=1)

print("The number of images in a training set is: ", len(train_loader)*16)
print("The number of images in a test set is: ", len(test_loader)*16)
print("The number of batches per epoch is: ", len(train_loader))
The number of images in a training set is:  9600
The number of images in a test set is:  2400
The number of batches per epoch is:  600
for X, y in test_loader:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break
Shape of X [N, C, H, W]:  torch.Size([16, 3, 224, 224])
Shape of y:  torch.Size([16]) torch.int64

二、自建模型

nn.Conv2d()函数:

  • 第一个参数(in_channels)是输入的channel数量,彩色图片为3,黑白图片为1。
  • 第二个参数(out_channels)是输出的channel数量
  • 第三个参数(kernel_size)是卷积核大小
  • 第四个参数(stride)是步长,就是卷积操作时每次移动的格子数,默认为1
  • 第五个参数(padding)是填充大小,默认为0

这里大家最难理解的可能就是nn.Linear(24*50*50, len(classeNames))这行代码了,在理解它之前你需要先补习一下👉卷积计算 的相关知识,然后可参照下面的网络结构图来进行理解

class Network_bn(nn.Module):
    def __init__(self):
        super(Network_bn, self).__init__()
        """
        nn.Conv2d()函数:
        第一个参数(in_channels)是输入的channel数量
        第二个参数(out_channels)是输出的channel数量
        第三个参数(kernel_size)是卷积核大小
        第四个参数(stride)是步长,默认为1
        第五个参数(padding)是填充大小,默认为0
        """
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(12)
        self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn2 = nn.BatchNorm2d(12)
        self.pool = nn.MaxPool2d(2,2)
        self.conv4 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn4 = nn.BatchNorm2d(24)
        self.conv5 = nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn5 = nn.BatchNorm2d(24)
        self.fc1 = nn.Linear(24*25*25, len(classeNames))

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))      
        x = F.relu(self.bn2(self.conv2(x)))     
        x = self.pool(x)                        
        x = F.relu(self.bn4(self.conv4(x)))     
        x = F.relu(self.bn5(self.conv5(x)))  
        x = self.pool(x)                        
        x = x.view(-1, 24*50*50)
        x = self.fc1(x)

        return x

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using  device".format(device))

model = Network_bn().to(device)
model
Using cuda device

Network_bn(
  (conv1): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (fc1): Linear(in_features=60000, out_features=15, bias=True)
)

三、模型训练

1. 优化器与损失函数

optimizer  = torch.optim.Adam(model.parameters(), lr=0.0001, weight_decay=0.0001)
loss_model = nn.CrossEntropyLoss()
from torch.autograd import Variable

def test(model, test_loader, loss_model):
    size = len(test_loader.dataset)
    num_batches = len(test_loader)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in test_loader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_model(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \\n Accuracy: (100*correct):>0.1f%, Avg loss: test_loss:>8f \\n")
    return correct,test_loss

def train(model,train_loader,loss_model,optimizer):
    model=model.to(device)
    model.train()
    
    for i, (images, labels) in enumerate(train_loader, 0):

        images = Variable(images.to(device))
        labels = Variable(labels.to(device))

        optimizer.zero_grad()
        outputs = model(images)
        loss = loss_model(outputs, labels)
        loss.backward()
        optimizer.step()

        if i % 1000 == 0:    
            print('[%5d] loss: %.3f' % (i, loss))

2. 模型的训练

test_acc_list  = []
epochs = 30

for t in range(epochs):
    print(f"Epoch t+1\\n-------------------------------")
    train(model,train_loader,loss_model,optimizer)
    test_acc,test_loss = test(model, test_loader, loss_model)
    test_acc_list.append(test_acc)
print("Done!")
Epoch 1
-------------------------------
[    0] loss: 2.780
Test Error: 
 Accuracy: 85.8%, Avg loss: 0.440920 

Epoch 2
-------------------------------
[    0] loss: 0.468
Test Error: 
 Accuracy: 89.2%, Avg loss: 0.377265 

......

Epoch 29
-------------------------------
[    0] loss: 0.000
Test Error: 
 Accuracy: 91.2%, Avg loss: 0.885408 

Epoch 30
-------------------------------
[    0] loss: 0.000
Test Error: 
 Accuracy: 91.8%, Avg loss: 0.660563 

Done!

四、结果分析

import numpy as np
import matplotlib.pyplot as plt

x = [i for i in range(1,31)]

plt.plot(x, test_acc_list, label="Accuracy", alpha=0.8)

plt.xlabel("Epoch")
plt.ylabel("Accuracy")

plt.legend()    
plt.show()

以上是关于深度学习数据集—水果数据集大合集的主要内容,如果未能解决你的问题,请参考以下文章

水果识别小程序-结合python深度学习识别

毕业设计水果图像识别系统 - 深度学习 OpenCV python

深度学习最全资料合集

[人工智能-深度学习-18]:神经网络基础 - 模型训练 - 监督式学习常见学习材料:训练数据集验证数据集测试数据集

[人工智能-深度学习-70]:数据集 - 目标检测常见公开数据集之MS COCO

[人工智能-深度学习-69]:数据集 - 目标检测常见公开数据集之PASCAL VOC