优达学城《DeepLearning》项目2：犬种分类器

最新推荐文章于 2024-04-07 22:45:00 发布
最新推荐文章于 2024-04-07 22:45:00 发布
阅读量469 收藏 3
点赞数
分类专栏： 优达学城_深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42118657/article/details/118268021
版权

在这个notebook中，你将迈出第一步，来开发可以作为移动端或 Web应用程序一部分的算法。在这个项目的最后，你的程序将能够把用户提供的任何一个图像作为输入。如果可以从图像中检测到一只狗，它会输出对狗品种的预测。如果图像中是一个人脸，它会预测一个与其最相似的狗的种类。下面这张图展示了完成项目后可能的输出结果。

  • Step 0: 导入数据集
  • Step 1: 检测人脸
  • Step 2: 检测狗狗
  • Step 3: 从头创建一个CNN来分类狗品种
  • Step 4: 使用一个CNN来区分狗的品种(使用迁移学习)
  • Step 5: 完成你的算法
  • Step 6: 测试你的算法

步骤 0: 导入数据集

下载狗数据集：dog dataset，放置在data文件夹内并解压。

下载人数据集：human dataset（一个人脸识别数据集），放置在data文件夹内并解压。

步骤1：检测人脸

我们将使用 OpenCV 中的 Haar feature-based cascade classifiers 来检测图像中的人脸。OpenCV 提供了很多预训练的人脸检测模型，它们以XML文件保存在 github。我们已经下载了其中一个检测模型，并且把它存储在 haarcascades 的目录中。

在如下代码单元中，我们将演示如何使用这个检测模型在样本图像中找到人脸。

写一个人脸探测器

我们可以使用这个程序编写一个函数，如果在图像中检测到人脸，则返回True，否则返回False。这个函数名为face_detector，将图像的文件路径作为输入，出现在下面的代码块中。

评估人脸检测器

问题1:使用下面的代码单元格来测试face_detector函数的性能。

  • 在human_files的前100张图片中有多大概率检测到人脸?
  • 在dog_files的前100张图片中中有多大概率检测到人脸?

步骤 2: 检测狗狗

在这个部分中，我们使用预训练的 vgg16 模型去检测图像中的狗。

给定一个图像，这个预先训练过的vgg16模型将为图像中包含的对象返回一个预测(来自ImageNet中的1000个可能类别)。

用预先训练好的模型进行预测

在下一个代码单元格中，您将编写一个函数，它接受图像的路径作为输入，并返回由预先训练的vgg -16模型预测的ImageNet类对应的索引。输出应该始终是0到999之间的整数(含999)。

from PIL import Image
import torchvision.transforms as transforms

# Set PIL to be tolerant of image files that are truncated.
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True

def VGG16_predict(img_path):
    '''
    Use pre-trained VGG-16 model to obtain index corresponding to 
    predicted ImageNet class for image at specified path
    
    Args:
        img_path: path to an image
        
    Returns:
        Index corresponding to VGG-16 model's prediction
    '''
    
    ## TODO: Complete the function.
    ## Load and pre-process an image from the given img_path
    ## Return the *index* of the predicted class for that image
    normalize = transforms.Normalize(
       mean=[0.485, 0.456, 0.406],
       std=[0.229, 0.224, 0.225]
    )
    transform = transforms.Compose([transforms.Resize((224,224)),
                                    transforms.CenterCrop(224),
                                    transforms.ToTensor(),
                                    normalize
                                   ])
    image = Image.open(img_path)
    #print(image.size)
    image = transform(image)
    image.unsqueeze_(0)
    #print(image.size)
    if use_cuda:
        image = image.cuda()
        
    output = VGG16(image)
    
    if use_cuda:
        output = output.cuda()
        
    class_index = output.data.cpu().numpy().argmax()    
    
    
    return class_index # predicted class index

#print(dog_files[0])
VGG16_predict(dog_files[0])

结果：

252

写一个狗狗探测器

在研究该 清单 的时候，你会注意到，狗类别对应的序号为151-268。因此，在检查预训练模型判断图像是否包含狗的时候，我们只需要检查如上的 VGG16_predict 函数是否返回一个介于151和268之间（包含区间端点）的值。

我们通过这些想法来完成下方的 dog_detector 函数，如果从图像中检测到狗就返回 True，否则返回 False。

问题2:使用下面的代码单元格来测试dog_detector函数的性能。

  • 在human_files_short中有多少百分比检测到狗?
  • 在dog_files_short中有多少百分比检测到狗?

你可以自由地探索其他预先训练网络(如Inception-v3, ResNet-50等)。请使用下面的代码单元来测试其他预先训练好的PyTorch模型。如果您决定执行这个可选任务，请报告human_files_short和dog_files_short的性能。

步骤 3: 从头开始创建一个CNN来分类狗品种

现在我们已经实现了一个函数，能够在图像中识别人类及狗狗。但我们需要更进一步的方法，来对狗的类别进行识别。在这一步中，你需要实现一个卷积神经网络来对狗的品种进行分类。你需要从头实现你的卷积神经网络（在这一阶段，你还不能使用迁移学习），并且你需要达到超过1%的测试集准确率。在本项目的步骤五种，你还有机会使用迁移学习来实现一个准确率大大提高的模型。

值得注意的是，对狗的图像进行分类是一项极具挑战性的任务。因为即便是一个正常人，也很难区分布列塔尼犬和威尔士史宾格犬。

不难发现其他的狗品种会有很小的类间差别（比如金毛寻回犬和美国水猎犬）。

同样，拉布拉多犬（labradors）有黄色、棕色和黑色这三种。那么你设计的基于视觉的算法将不得不克服这种较高的类间差别，以达到能够将这些不同颜色的同类狗分到同一个品种中。

我们也提到了随机分类将得到一个非常低的结果：不考虑品种略有失衡的影响，随机猜测到正确品种的概率是1/133，相对应的准确率是低于1%的。

请记住，在深度学习领域，实践远远高于理论。大量尝试不同的框架吧，相信你的直觉！当然，玩得开心！

为Dog数据集指定数据加载器

问题3:描述您选择的数据预处理过程。

  • 你的代码如何调整图像的大小(裁剪，拉伸等)?输入张量的大小是多少，为什么?
  • 你决定扩大数据集了吗?如果有，如何(通过平移，翻转，旋转等)?如果没有，为什么?

指定损失函数和优化器

训练和验证模型

# the following import is required for training to be robust to truncated images
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True

def train(n_epochs, loaders, model, optimizer, criterion, use_cuda, save_path):
    """returns trained model"""
    # initialize tracker for minimum validation loss
    valid_loss_min = np.Inf 
    
    for epoch in range(1, n_epochs+1):
        # initialize variables to monitor training and validation loss
        train_loss = 0.0
        valid_loss = 0.0
        
        ###################
        # train the model #
        ###################
        model.train()
        for batch_idx, (data, target) in enumerate(loaders['train']):
            # move to GPU
            if use_cuda:
                data, target = data.cuda(), target.cuda()
            ## find the loss and update the model parameters accordingly
            ## record the average training loss, using something like
            ## train_loss = train_loss + ((1 / (batch_idx + 1)) * (loss.data - train_loss))
            optimizer.zero_grad()    
            ## find the loss and update the model parameters accordingly
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            ## record the average training loss, using something like
            ## train_loss = train_loss + ((1 / (batch_idx + 1)) * (loss.data - train_loss))
            train_loss += ((1 / (batch_idx + 1)) * (loss.data - train_loss))
            
             # print training/validation statistics 
            if (batch_idx+1) % 40 == 0:
                print('Epoch: {} \tBatch: {} \tTraining Loss: {:.6f}'.format(epoch, batch_idx + 1, train_loss))

            
        ######################    
        # validate the model #
        ######################
        model.eval()
        for batch_idx, (data, target) in enumerate(loaders['valid']):
            # move to GPU
            if use_cuda:
                data, target = data.cuda(), target.cuda()
            ## update the average validation loss
            output = model(data)
            loss = criterion(output, target)
            valid_loss += ((1 / (batch_idx + 1)) * (loss.data - valid_loss))
            # print training/validation statistics 
            if (batch_idx+1) % 40 == 0:
                print('Epoch: {} \tBatch: {} \tValidation Loss: {:.6f}'.format(epoch, batch_idx + 1, valid_loss))
            
        # print training/validation statistics 
        print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
            epoch, 
            train_loss,
            valid_loss
            ))
        
        ## TODO: save the model if validation loss has decreased
        if valid_loss <= valid_loss_min:
            print('Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...'.format(
                    valid_loss_min,
                    valid_loss))
            torch.save(model.state_dict(), save_path)
            valid_loss_min = valid_loss    
            
    # return trained model
    return model

epoch = 10

# train the model
model_scratch = train(epoch, loaders_scratch, model_scratch, optimizer_scratch, 
                      criterion_scratch, use_cuda, 'model_scratch.pt')

# load the model that got the best validation accuracy
model_scratch.load_state_dict(torch.load('model_scratch.pt'))

结果：

Epoch: 1 	Batch: 40 	Training Loss: 4.889728
Epoch: 1 	Batch: 80 	Training Loss: 4.887787
Epoch: 1 	Batch: 120 	Training Loss: 4.887685
Epoch: 1 	Batch: 160 	Training Loss: 4.885648
Epoch: 1 	Batch: 200 	Training Loss: 4.881847
Epoch: 1 	Batch: 240 	Training Loss: 4.873278
Epoch: 1 	Batch: 280 	Training Loss: 4.862270
Epoch: 1 	Batch: 320 	Training Loss: 4.854340
Epoch: 1 	Batch: 40 	Validation Loss: 4.712207
Epoch: 1 	Training Loss: 4.851301 	Validation Loss: 4.704982
Validation loss decreased (inf --> 4.704982).  Saving model ...
Epoch: 2 	Batch: 40 	Training Loss: 4.730308
Epoch: 2 	Batch: 80 	Training Loss: 4.719476
Epoch: 2 	Batch: 120 	Training Loss: 4.701708
Epoch: 2 	Batch: 160 	Training Loss: 4.695746
Epoch: 2 	Batch: 200 	Training Loss: 4.692133
Epoch: 2 	Batch: 240 	Training Loss: 4.675904
Epoch: 2 	Batch: 280 	Training Loss: 4.663143
Epoch: 2 	Batch: 320 	Training Loss: 4.650386
Epoch: 2 	Batch: 40 	Validation Loss: 4.488307
Epoch: 2 	Training Loss: 4.643542 	Validation Loss: 4.494160
Validation loss decreased (4.704982 --> 4.494160).  Saving model ...
Epoch: 3 	Batch: 40 	Training Loss: 4.474283
Epoch: 3 	Batch: 80 	Training Loss: 4.501595
Epoch: 3 	Batch: 120 	Training Loss: 4.477735
Epoch: 3 	Batch: 160 	Training Loss: 4.488136
Epoch: 3 	Batch: 200 	Training Loss: 4.490754
Epoch: 3 	Batch: 240 	Training Loss: 4.487989
Epoch: 3 	Batch: 280 	Training Loss: 4.490090
Epoch: 3 	Batch: 320 	Training Loss: 4.481546
Epoch: 3 	Batch: 40 	Validation Loss: 4.262285
Epoch: 3 	Training Loss: 4.479444 	Validation Loss: 4.275317
Validation loss decreased (4.494160 --> 4.275317).  Saving model ...
Epoch: 4 	Batch: 40 	Training Loss: 4.402790
Epoch: 4 	Batch: 80 	Training Loss: 4.372338
Epoch: 4 	Batch: 120 	Training Loss: 4.365306
Epoch: 4 	Batch: 160 	Training Loss: 4.367325
Epoch: 4 	Batch: 200 	Training Loss: 4.374326
Epoch: 4 	Batch: 240 	Training Loss: 4.369847
Epoch: 4 	Batch: 280 	Training Loss: 4.365964
Epoch: 4 	Batch: 320 	Training Loss: 4.363493
Epoch: 4 	Batch: 40 	Validation Loss: 4.249445
Epoch: 4 	Training Loss: 4.364571 	Validation Loss: 4.248449
Validation loss decreased (4.275317 --> 4.248449).  Saving model ...
Epoch: 5 	Batch: 40 	Training Loss: 4.229365
Epoch: 5 	Batch: 80 	Training Loss: 4.267400
Epoch: 5 	Batch: 120 	Training Loss: 4.269664
Epoch: 5 	Batch: 160 	Training Loss: 4.257591
Epoch: 5 	Batch: 200 	Training Loss: 4.261866
Epoch: 5 	Batch: 240 	Training Loss: 4.247512
Epoch: 5 	Batch: 280 	Training Loss: 4.239336
Epoch: 5 	Batch: 320 	Training Loss: 4.230827
Epoch: 5 	Batch: 40 	Validation Loss: 4.043582
Epoch: 5 	Training Loss: 4.231559 	Validation Loss: 4.039588
Validation loss decreased (4.248449 --> 4.039588).  Saving model ...
Epoch: 6 	Batch: 40 	Training Loss: 4.180193
Epoch: 6 	Batch: 80 	Training Loss: 4.140314
Epoch: 6 	Batch: 120 	Training Loss: 4.153989
Epoch: 6 	Batch: 160 	Training Loss: 4.140887
Epoch: 6 	Batch: 200 	Training Loss: 4.151268
Epoch: 6 	Batch: 240 	Training Loss: 4.153749
Epoch: 6 	Batch: 280 	Training Loss: 4.153314
Epoch: 6 	Batch: 320 	Training Loss: 4.156451
Epoch: 6 	Batch: 40 	Validation Loss: 3.940857
Epoch: 6 	Training Loss: 4.149529 	Validation Loss: 3.945810
Validation loss decreased (4.039588 --> 3.945810).  Saving model ...
Epoch: 7 	Batch: 40 	Training Loss: 4.060485
Epoch: 7 	Batch: 80 	Training Loss: 4.065772
Epoch: 7 	Batch: 120 	Training Loss: 4.056967
Epoch: 7 	Batch: 160 	Training Loss: 4.068470
Epoch: 7 	Batch: 200 	Training Loss: 4.076772
Epoch: 7 	Batch: 240 	Training Loss: 4.087616
Epoch: 7 	Batch: 280 	Training Loss: 4.074337
Epoch: 7 	Batch: 320 	Training Loss: 4.080192
Epoch: 7 	Batch: 40 	Validation Loss: 3.860693
Epoch: 7 	Training Loss: 4.078263 	Validation Loss: 3.884382
Validation loss decreased (3.945810 --> 3.884382).  Saving model ...
Epoch: 8 	Batch: 40 	Training Loss: 3.960585
Epoch: 8 	Batch: 80 	Training Loss: 3.983979
Epoch: 8 	Batch: 120 	Training Loss: 3.965129
Epoch: 8 	Batch: 160 	Training Loss: 3.965021
Epoch: 8 	Batch: 200 	Training Loss: 3.965830
Epoch: 8 	Batch: 240 	Training Loss: 3.976013
Epoch: 8 	Batch: 280 	Training Loss: 3.975547
Epoch: 8 	Batch: 320 	Training Loss: 3.978744
Epoch: 8 	Batch: 40 	Validation Loss: 3.784086
Epoch: 8 	Training Loss: 3.980776 	Validation Loss: 3.779312
Validation loss decreased (3.884382 --> 3.779312).  Saving model ...
Epoch: 9 	Batch: 40 	Training Loss: 3.917738
Epoch: 9 	Batch: 80 	Training Loss: 3.967938
Epoch: 9 	Batch: 120 	Training Loss: 3.934165
Epoch: 9 	Batch: 160 	Training Loss: 3.917138
Epoch: 9 	Batch: 200 	Training Loss: 3.910391
Epoch: 9 	Batch: 240 	Training Loss: 3.909857
Epoch: 9 	Batch: 280 	Training Loss: 3.907439
Epoch: 9 	Batch: 320 	Training Loss: 3.901893
Epoch: 9 	Batch: 40 	Validation Loss: 3.826410
Epoch: 9 	Training Loss: 3.903304 	Validation Loss: 3.824970
Epoch: 10 	Batch: 40 	Training Loss: 3.910845
Epoch: 10 	Batch: 80 	Training Loss: 3.910709
Epoch: 10 	Batch: 120 	Training Loss: 3.915924
Epoch: 10 	Batch: 160 	Training Loss: 3.900949
Epoch: 10 	Batch: 200 	Training Loss: 3.883792
Epoch: 10 	Batch: 240 	Training Loss: 3.882242
Epoch: 10 	Batch: 280 	Training Loss: 3.875963
Epoch: 10 	Batch: 320 	Training Loss: 3.858594
Epoch: 10 	Batch: 40 	Validation Loss: 3.638186
Epoch: 10 	Training Loss: 3.861175 	Validation Loss: 3.647465
Validation loss decreased (3.779312 --> 3.647465).  Saving model ...
<All keys matched successfully>

测试模型

在狗图片的测试数据集中试用你的模型。使用下面的代码单元计算和打印测试loss和准确性。确保您的测试精度大于10%。

步骤 4: 使用CNN迁移学习来区分狗的品种

使用 迁移学习（Transfer Learning）的方法，能帮助我们在不损失准确率的情况下大大减少训练时间。在以下步骤中，你可以尝试使用迁移学习来训练你自己的CNN。

模型架构

指定损失函数和优化器

训练和验证模型

# train the model
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True

def train(n_epochs, loaders, model, optimizer, criterion, use_cuda, save_path):
    """returns trained model"""
    # initialize tracker for minimum validation loss
    valid_loss_min = np.Inf 
    
    for epoch in range(1, n_epochs+1):
        # initialize variables to monitor training and validation loss
        train_loss = 0.0
        valid_loss = 0.0
        
        ###################
        # train the model #
        ###################
        model.train()
        for batch_idx, (data, target) in enumerate(loaders['train']):
            # move to GPU
            if use_cuda:
                data, target = data.cuda(), target.cuda()
                
            optimizer.zero_grad()    
            ## find the loss and update the model parameters accordingly
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            ## record the average training loss, using something like
            ## train_loss = train_loss + ((1 / (batch_idx + 1)) * (loss.data - train_loss))
            train_loss += ((1 / (batch_idx + 1)) * (loss.data - train_loss))
            
             # print training/validation statistics 
            if (batch_idx+1) % 40 == 0:
                print('Epoch: {} \tBatch: {} \tTraining Loss: {:.6f}'.format(epoch, batch_idx + 1, train_loss))
        ######################    
        # validate the model #
        ######################
        model.eval()
        for batch_idx, (data, target) in enumerate(loaders['valid']):
            # move to GPU
            if use_cuda:
                data, target = data.cuda(), target.cuda()
            ## update the average validation loss
            output = model(data)
            loss = criterion(output, target)
            valid_loss += ((1 / (batch_idx + 1)) * (loss.data - valid_loss))
            # print training/validation statistics 
            if (batch_idx+1) % 40 == 0:
                print('Epoch: {} \tBatch: {} \tValidation Loss: {:.6f}'.format(epoch, batch_idx + 1, valid_loss))
           
        # print training/validation statistics 
        print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
            epoch, 
            train_loss,
            valid_loss
            ))
        
        ## TODO: save the model if validation loss has decreased
        if valid_loss <= valid_loss_min:
            print('Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...'.format(
                    valid_loss_min,
                    valid_loss))
            torch.save(model.state_dict(), save_path)
            valid_loss_min = valid_loss    
    # return trained model
    return model


n_epochs = 2
model_transfer = train(n_epochs, loaders_transfer, model_transfer, optimizer_transfer, criterion_transfer, use_cuda, 'model_transfer.pt')

# load the model that got the best validation accuracy (uncomment the line below)
model_transfer.load_state_dict(torch.load('model_transfer.pt'))

结果：

测试模型

用模型预测狗的品种

编写一个函数，以图像路径作为输入，并返回您的模型预测的狗的品种

步骤 5: 完成你的算法

实现一个算法，它的输入为图像的路径，它能够区分图像是否包含一个人、狗或两者都不包含，然后：

  • 如果从图像中检测到一只狗，返回被预测的品种。
  • 如果从图像中检测到人，返回最相像的狗品种。
  • 如果两者都不能在图像中检测到，输出错误提示。

我们非常欢迎你来自己编写检测图像中人类与狗的函数，你可以随意地使用上方完成的 face_detector 和 dog_detector 函数。你需要在步骤5使用你的CNN来预测狗品种。

下面提供了算法的示例输出，但你可以自由地设计自己的模型！

步骤 6: 测试你的算法

在这个部分中，你将尝试一下你的新算法！算法认为你看起来像什么类型的狗？如果你有一只狗，它可以准确地预测你的狗的品种吗？如果你有一只猫，它会将你的猫误判为一只狗吗？

结果：

This is a human picture who looks like Norwich terrier

This is a human picture who looks like Curly-coated retriever

This is a human picture who looks like Curly-coated retriever

This is a dog picture and it's English cocker spaniel

This is a dog picture and it's Bloodhound

This is a dog picture and it's Lowchen

⊙月
关注
专栏目录
使用深度学习识别狗的品种
TensorFlowNews
09-13 6238
作者|Nouman 编译|VK 来源|Towards Data Science 在这篇文章中，我将教你建立你自己的网页应用程序，它将接受你的狗的图片，并输出其品种。准确率超过80%！ 我们将使用深度学习来训练一个模型的数据集的狗图像与他们的品种，以学习的特征来区分每一个品种。 数据分析 数据集可以从这里下载（https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/dogImages.zip）。在成功加载和浏览数据集后，以下是关于数据的一些介
基于深度学习的犬种识别软件（YOLOv5清新界面版，Python代码）
热门推荐
思绪无限的博客
03-19 1万+
基于深度学习的犬种识别软件用于识别常见多个犬品种，基于YOLOv5算法检测犬种，并通过界面显示记录和管理，智能辅助人们辨别犬种。本文详细介绍博主自主开发的犬种检测系统，在介绍算法原理的同时，给出Python的实现代码、PyQt的UI界面及训练数据集。本系统在界面中可以选择各种图片、视频进行检测识别；可对图像中存在的多个目标进行识别分类，检测速度快、识别精度高。博文提供了完整的Python代码和使用教程，适合新入门的朋友参考，完整代码资源文件请转至文末的下载链接。
基于深度学习的犬种识别系统详解（网页版+YOLOv8/v7/v6/v5代码+训练数据集）
逗逗班学Python
04-07 7970
本文深入研究了基于YOLOv8/v7/v6/v5等深度学习模型的犬种识别技术，核心采用YOLOv8并整合了YOLOv7、YOLOv6、YOLOv5算法，进行性能指标对比；详述了国内外研究现状、数据集处理、算法原理、模型构建与训练代码，及基于Streamlit的交互式Web应用界面设计。在Web网页中可以支持图像、视频和实时摄像头进行犬种识别，可上传不同训练模型（YOLOv8/v7/v6/v5）进行推理预测，界面可方便修改。本文附带了完整的网页设计、深度学习模型代码和训练数据集的下载链接。
m基于深度学习网络的宠物狗种类识别系统matlab仿真,带GUI界面
fpga/matlab/simulink算法仿真工程
09-21 790
总的来说，基于深度学习网络的宠物狗种类识别系统是一种利用深度学习技术进行图像分类的方法，具有自动化程度高、高准确率和泛化能力强、可扩展性好等优点。深度神经网络模型：在宠物狗种类识别系统中，使用深度神经网络模型来学习图像中的特征。基于深度学习网络的宠物狗种类识别系统是一种利用深度学习技术进行图像分类的方法，可以自动学习图像中的特征，并根据这些特征对图像进行分类。高准确率和泛化能力：通过训练深度神经网络模型和分类器，可以使该系统具有高准确率和泛化能力，能够适应各种不同的图像分类任务。
毕业设计选题：基于深度学习狗狗品种识别系统 人工智能 机器学习 python 目标检测
2301_79555157的博客
01-05 1620
毕业设计选题-基于深度学习的犬类识别系统。融合深度学习和计算机视觉技术，能准确识别和分类犬类图像。通过大规模犬类图像数据的训练和优化，系统能够高精度地识别不同品种的犬类。。对即将毕业的计算机专业学生来说，提供了有意义的研究课题。不论你对深度学习、机器学习、算法或人工智能感兴趣，该设计为你提供了丰富的选题资源和灵感。通过学习相关资料，你将获得实用的指导和启发，助你成功完成毕业设计。将锻炼你的研究和技术能力，为未来毕业工作打下坚实基础。无论你寻找学习资源或灵感，都将成为你的有力指南。
优达学城数据分析项目：使用机器学习从安然公司邮件中发现欺诈证据.zip
最新发布
04-18
机器学习是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。它专门研究计算机如何模拟或实现人类的学习行为，以获取新的知识或技能，并重新组织已有的知识结构，从而不断改善...
android_SunshineApp:优达学城安卓课堂项目
06-25
【Android_SunshineApp: 优达学城安卓课堂项目详解】 优达学城（Udacity）的“安卓课堂项目”是为学习者提供的一种实践性教学资源，旨在帮助学员掌握Android应用开发的核心技能。在这个名为“Android_SunshineApp”...
MovieTrailer:优达学城项目1
07-17
这包括用于查看和运行 python 文件的空闲编辑器。 在 IDLE 中打开文件 Entertainment.py 并运行它。 它将打开您的网络浏览器并显示 12 部电影。 单击电影海报会在弹出的模式窗口中启动电影预告片。 将光标悬停在...
UdacityP2:优达学城前端开发者纳米学位项目#2
06-06
【标题】"UdacityP2:优达学城前端开发者纳米学位项目#2"是优达学城（Udacity）提供的一项专门针对前端开发者的教育课程，旨在帮助学员掌握构建交互式网页应用的核心技能。这个项目是纳米学位课程的一部分，通过实际...
london:优达学城街区地图项目
06-12
优达学城街区地图项目 任务 水疗中心设有一个社区 突出显示的位置 有关这些位置的第三方数据 浏览内容的多种方式 第三方JS库的使用 计划 AngularJS 作为 3rd 方库。 （我最了解它，它非常适合此目的。） 纽约时报...
吴恩达deeplearning.ai项目前两课程的全部编程作业（含解答）
12-05
吴恩达deeplearning.ai项目的前两部分编程实现，从网上获取，共享给大家学习！
狗品种分类器
02-14
项目概况 欢迎来到AI Nanodegree中的卷积神经网络（CNN）项目！ 在此项目中，您将学习如何构建可在Web或移动应用程序中使用的管道，以处理用户提供的真实图像。 给定狗的图像，您的算法将识别出犬的品种的估计值。 如果提供了人像，则代码将识别出类似狗的品种。 在探索用于分类和本地化的最新CNN模型的同时，您将做出有关应用程序用户体验的重要设计决策。 我们的目标是，通过完成本实验，您将了解将旨在在数据处理管道中执行各种任务的一系列模型拼接在一起所面临的挑战。 每个模型都有其优点和缺点，设计一个实际应用程序常常涉及解决许多问题而没有一个完美的答案。 尽管如此，您不完善的解决方案仍会带来有趣的用户体验！ 项目说明 指示 克隆存储库并导航到下载的文件夹。 git clone https://github.com/udacity/deep-learning-v2-pytorch.git
dogs-vs-cats:优达学城-机器学习-毕业项目-猫狗大战
05-01
dogs-vs-cats 是kaggle比赛中的经典题目，也是Udacity的机器学习学位的毕业课题。要求在最终在测试集的结果排在Public Leaderboard的前10%，具体要求为。 项目资料 数据集下载： ，kaggle一共提供了两个数据集train与test。其中train set包含25000个样本，cat和dog各12500个。 test set包含12500张图片，但没有分类。 神经网络模型 本次项目采用经典的ResNet模型，ResNet在2015年提出以来，曾在ImageNet比赛classification任务上获得第一名，因为它“简单与实用”并存，之后很多方法都建立在ResNet50或者ResNet101的基础上完成的，检测，分割，识别等领域都有着广泛的运用[2]。 文件结构 file3.csv 测试集结果 model.png 神经网络模型结构图 test.ip
120种犬类图像数据集
06-19
犬数据集包含来自世界各地的120种犬类的图像。该数据集是使用ImageNet中的图像和注释方法构建的，常用于细粒度图像分类任务 犬数据集(Stanford Dogs)包含来自世界各地的120种犬类的图像。该数据集是使用ImageNet中的图像和注释方法构建的，常用于细粒度图像分类任务。数据集包括： 类别数量：120 图像数量：20,580 注释：类标签，边界框
深度学习课程项目Deeplearning.ai正式发布
zchang81的博客
08-09 1247
今早，吴恩达在 Medium 上发布了一篇博客，宣布 Deeplearning.ai 项目正式启动。同时表示今天发布的项目仅仅是他正在发布的三大项目中的第一个。吴恩达表示：Deepleanring.ai 是一套教育课程。
基于迁移学习的狗狗分类器
小白学视觉
01-20 554
点击上方“小白学视觉”，选择加"星标"或“置顶” 重磅干货，第一时间送达 你以前听说过深度学习这个词吗? 或者你刚刚开始学习它？在本文中，我将引导您构建自己的狗狗分类器。...
图像分类算法_深度学习图像分类初学者项目：编写一个狗类识别的算法
weixin_39529914的博客
11-24 761
项目:编写一个狗类识别的算法项目描述图像分类是计算机视觉中最简单的任务。自从卷积网络开始在计算机视觉研究人员和从业者中引起关注以来，开发了许多用于克服分类任务的卷积体系结构。现在，在许多情况下，最先进的架构可能达到90％的准确率。但是，在实际应用中，许多开发人员/从业者构建适合其任务的模型，而不是依赖于预先训练的体系结构。因此，理解使体系结构优于其他体系结构的思想和关键结构更改是至关重要的。在这个...
训练代码_实战代码 | fastai训练一个小狗分类器
weixin_42297444的博客
01-15 220
机器学习算法与自然语言处理推荐来源：AI科技大本营作者：一杯奶茶的功夫翻译：Vincents 【机器学习算法与自然语言处理导读】这篇文章会讲解如何制作能够分类120种小狗的图像分类器。这篇文章中所讲述的内容都是基于colab notebook和fastai技术的深度学习的应用。为什么使用colab？使用colab的好处是，你不需要有任何显卡GPU，colab中提供了一块免费的...
【狗狗分类项目】（3）扩展数据集：斯坦福kaggle数据库
山中有石为玉
07-13 2824
扩展数据集：斯坦福kaggle数据库 计算扩展训练后，优达学城数据库/斯坦福数据库分别的测试准确率。 1、优达学成数据库狗狗种类有133种，斯坦福数据库狗狗种类有120种 其中2种数据库重合品种为80种，因此，将斯坦福这80种图像加到优达学成数据库中，扩充原来的数据库。 这样，有大学城数据库有53种没有扩充到，而斯坦福还有40种没有被加进来。 2、直接提取优达学成+斯坦福总的特征，电脑内...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值