CV(8)--图像识别

最新推荐文章于 2025-03-28 08:48:50 发布
最新推荐文章于 2025-03-28 08:48:50 发布
阅读量1.1k 收藏 31
点赞数 9
CC 4.0 BY-SA版权
分类专栏： CV 文章标签： 深度学习 计算机视觉 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/njh1147394013/article/details/144976731

前言

仅记录学习过程，有问题欢迎讨论

cifar 数据集

可以使用图片增强增加训练的样本数据

图像识别：

图像识别技术的过程分以下几步：

  1. 信息的获取：是指通过传感器，将光或声音等信息转化为电信息。也就是获取研究对象的基本信息并通
    过某种方法将其转变为机器能够认识的信息。
  2. 预处理：主要是指图像处理中的去噪、平滑、变换等的操作，从而加强图像的重要特征。图像增强。
  3. 特征抽取和选择：是指在模式识别中，需要进行特征的抽取和选择。特征抽取和选择在图像识别过程中
    是非常关键的技术之一。
  4. 分类器设计：是指通过训练而得到一种识别规则，通过此识别规则可以得到一种特征分类，使图像识别
    技术能够得到高识别率。分类决策是指在特征空间中对被识别对象进行分类，从而更好地识别所研究的
    对象具体属于哪一类。

AlexNet：

网络结构：AlexNet 共包含 8 层权重层，其中包括 5 个卷积层和 3 个全连接层，具体如下：

  • 输入层：输入为 RGB 三通道的 224×224×3（或 227×227×3）大小的图像。
  • 卷积层：第一层卷积层使用 96 个 11×11 的卷积核，步长为 4；第二层卷积层使用 256 个 5×5 的卷积核，步长为 1；第三、四、五层卷积层分别使用 384 个和 256 个 3×3 的卷积核，步长为 1。
    每个卷积层后面都跟着一个 ReLU 激活函数层，用于增加网络的非线性表示能力。
  • 池化层：在第二、四、五个卷积层后面都跟着一个最大池化层，使用 3×3 的池化窗口和 2 的步长。
  • 全连接层：三个全连接层分别有 4096 个神经元，其中前两个全连接层采用了 Dropout 正则化技术，以减少过拟合。最后一个全连接层有 1000 个神经元，对应于 ImageNet 数据集的 1000 个类别，
    使用 softmax 激活函数输出每个类别的概率。

关键技术：

  • ReLU 激活函数：AlexNet 首次在 CNN 中成功应用了 ReLU 激活函数，相比传统的 sigmoid 和 tanh 函数，ReLU 能够加速训练过程并有效解决梯度消失问题。
  • Dropout 正则化：在训练过程中随机忽略一部分神经元，以减少过拟合。Dropout 技术在 AlexNet 中得到了有效应用，提高了模型的泛化能力。
    重叠池化：池化窗口的步长小于窗口的大小，使得池化层能够更好地提取空间信息，提升特征的丰富性。
  • 局部响应归一化（LRN）：对局部神经元的活动创建竞争机制，增强模型的对比度敏感性。虽然 LRN 在现代 CNN 中已较少使用，但在 AlexNet 中起到了重要作用。
    数据增强：通过随机裁剪、水平翻转和颜色抖动等技术增加训练数据的多样性，进一步提高模型的泛化能力。
  • GPU 加速训练：AlexNet 利用 GPU 强大的并行计算能力进行分布式训练，显著加快了训练速度。

在这里插入图片描述

VGG

  • 使用比较深层次的神经层学习
  • 可以使用卷积模拟全连接层，省略最后一个平铺的操作，卷积核需要设置为输入的大小
  • 可以使用1*1的卷积的数量实现通道的升维和降维

在这里插入图片描述

ResNet(这个最重要)

  • ResNet50有两个基本的块，分别名为Conv Block和Identity Block，其中Conv Block输入和输出的维度是不一样的，所以不能连续串联，它的作用是改变网络的维度；Identity Block输入维度和输出维度相同，可以串联，用于加深网络。
  • 两个块都带有残差机制，在增加深度的同时，保护信息的完整性，只要学习输入输出的差别，简化学习难度。
    在这里插入图片描述

BatchNormalization：

  • 所有输出保证在0~1之间。
  • 所有输出数据的均值接近0，标准差接近1的正太分布。使其落入激活函数的敏感区，避免梯度
    消失，加快收敛。
  • 加快模型收敛速度，并且具有一定的泛化能力。
  • 可以减少dropout的使用

实现AlexNet

"""
实现AlexNet
"""

import torch
import torch.nn as nn


class AlexNet(nn.Module):
    def __init__(self, num_classes=1000, init_weights=False):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            # 输入(3, 224, 224)，输出(48, 55, 55) (224-11+2*2)/4+1=55
            nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            # 输出(48, 27, 27)
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(48, 128, kernel_size=5, padding=2),  # 输出(128, 27, 27)
            nn.ReLU(inplace=True),
            # 输出(128, 13, 13)
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(128, 192, kernel_size=3, padding=1),  # 输出(192, 13, 13)
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 192, kernel_size=3, padding=1),  # 输出(192, 13, 13)
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 128, kernel_size=3, padding=1),  # 输出(128, 13, 13)
            nn.ReLU(inplace=True),
            # 输出(128, 6, 6)
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        # 全连接层
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128 * 6 * 6, 2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(inplace=True),
            nn.Linear(2048, num_classes),
        )
        # 初始化权重
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        # flatten展平处理，start_dim=1从索引1开始
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

    # 权重初始化
    def _initialize_weights(self):
        # 每个层都需要初始化权重
        for m in self.modules():
            # 判断是否为卷积层
            if isinstance(m, nn.Conv2d):
                # 用凯明初始化对权重w进行初始化
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            # 全连接层
            elif isinstance(m, nn.Linear):
                # 通过正态分布给权重赋值，0表示正态分布的均值，0.01表示方差
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)


if __name__ == '__main__':
    # 模型实例化
    model = AlexNet(num_classes=1000, init_weights=True)
    print(model)
    # 输出模型参数
    input = torch.randn(1, 3, 224, 224)
    output = model(input)
    print(output.shape)

实现VGG16

"""
实现VGG16网络
1、一张原始图片被resize到(224,224,3)。
2、conv1两次[3,3]卷积网络，输出的特征层为64，输出为(224,224,64)，再2X2最大池化，输出net为
(112,112,64)。
3、conv2两次[3,3]卷积网络，输出的特征层为128，输出net为(112,112,128)，再2X2最大池化，输出
net为(56,56,128)。
4、conv3三次[3,3]卷积网络，输出的特征层为256，输出net为(56,56,256)，再2X2最大池化，输出net
为(28,28,256)。
5、conv3三次[3,3]卷积网络，输出的特征层为256，输出net为(28,28,512)，再2X2最大池化，输出net
为(14,14,512)。
6、conv3三次[3,3]卷积网络，输出的特征层为256，输出net为(14,14,512)，再2X2最大池化，输出net
为(7,7,512)。
7、利用卷积的方式模拟全连接层，效果等同，输出net为(1,1,4096)。共进行两次。
8、利用卷积的方式模拟全连接层，效果等同，输出net为(1,1,1000)
"""
from torch import nn


class Vgg16(nn.Module):
    def __init__(self):
        super(Vgg16, self).__init__()
        self.conv1 = nn.Sequential(
            # 输入为224*224*3,输出为224*224*64
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            # 输出为112*112*64
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            # 输出为56*56*128
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            # 输出为28*28*256
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            # 输出为14*14*512
            nn.MaxPool2d(kernel_size=2, stride=2),

            # 第五个卷积块
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            # 输出为7*7*512
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        self.fc = nn.Sequential(
            # 映射为4096维度
            nn.Linear(512 * 7 * 7, 4096),  # 输入为512*7*7
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 1000),
        )

        def forward(self, x):
            x = self.conv1(x)
            x = x.view(x.size(0), -1)
            x = self.fc(x)
            return x


if __name__ == '__main__':
    vgg16 = Vgg16()
    print(vgg16)

实现ResNet50

"""
实现Resnet50！！！（important）
"""
import torchvision
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from PIL import Image


class ResNet50(nn.Module):
    def __init__(self, num_classes=1000):
        super(ResNet50, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))

        self.conv_block1 = ConvBlock(64, [64, 64, 256], kernel_size=(3, 3), strides=(1, 1))
        self.identity_block1 = IdentityBlock(256, [64, 64, 256], kernel_size=(3, 3))
        self.identity_block2 = IdentityBlock(256, [64, 64, 256], kernel_size=(3, 3))

        self.conv_block2 = ConvBlock(256, [128, 128, 512], kernel_size=(3, 3))
        self.identity_block3 = IdentityBlock(512, [128, 128, 512], kernel_size=(3, 3))
        self.identity_block4 = IdentityBlock(512, [128, 128, 512], kernel_size=(3, 3))
        self.identity_block5 = IdentityBlock(512, [128, 128, 512], kernel_size=(3, 3))

        self.conv_block3 = ConvBlock(512, [256, 256, 1024], kernel_size=(3, 3))
        self.identity_block6 = IdentityBlock(1024, [256, 256, 1024], kernel_size=(3, 3))
        self.identity_block7 = IdentityBlock(1024, [256, 256, 1024], kernel_size=(3, 3))
        self.identity_block8 = IdentityBlock(1024, [256, 256, 1024], kernel_size=(3, 3))
        self.identity_block9 = IdentityBlock(1024, [256, 256, 1024], kernel_size=(3, 3))
        self.identity_block10 = IdentityBlock(1024, [256, 256, 1024], kernel_size=(3, 3))
        self.identity_block11 = IdentityBlock(1024, [256, 256, 1024], kernel_size=(3, 3))

        self.conv_block4 = ConvBlock(1024, [512, 512, 2048], kernel_size=(3, 3))
        self.identity_block12 = IdentityBlock(2048, [512, 512, 2048], kernel_size=(3, 3))
        self.identity_block13 = IdentityBlock(2048, [512, 512, 2048], kernel_size=(3, 3))

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(2048, num_classes)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.conv_block1(x)
        x = self.identity_block1(x)
        x = self.identity_block2(x)

        x = self.conv_block2(x)
        x = self.identity_block3(x)
        x = self.identity_block4(x)
        x = self.identity_block5(x)

        x = self.conv_block3(x)
        x = self.identity_block6(x)
        x = self.identity_block7(x)
        x = self.identity_block8(x)
        x = self.identity_block9(x)
        x = self.identity_block10(x)
        x = self.identity_block11(x)

        x = self.conv_block4(x)
        x = self.identity_block12(x)
        x = self.identity_block13(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return x





class IdentityBlock(nn.Module):
    def __init__(self, in_channels, filters, kernel_size):
        super(IdentityBlock, self).__init__()
        filters1, filters2, filters3 = filters
        self.conv1 = nn.Conv2d(in_channels, filters1, kernel_size=(1, 1), bias=False)
        self.bn1 = nn.BatchNorm2d(filters1)
        self.relu1 = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(filters1, filters2, kernel_size=kernel_size, padding='same', bias=False)
        self.bn2 = nn.BatchNorm2d(filters2)
        self.relu2 = nn.ReLU(inplace=True)

        self.conv3 = nn.Conv2d(filters2, filters3, kernel_size=(1, 1), bias=False)
        self.bn3 = nn.BatchNorm2d(filters3)

    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu1(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu2(out)

        out = self.conv3(out)
        out = self.bn3(out)
        # 残差！
        out += identity
        out = nn.ReLU(inplace=True)(out)
        return out


class ConvBlock(nn.Module):
    def __init__(self, in_channels, filters, kernel_size, strides=(2, 2)):
        super(ConvBlock, self).__init__()
        filters1, filters2, filters3 = filters
        self.conv1 = nn.Conv2d(in_channels, filters1, kernel_size=(1, 1), bias=False)
        # 输入数据进行归一化处理，使得数据在进入下一层之前具有稳定的分布
        self.bn1 = nn.BatchNorm2d(filters1)
        self.relu1 = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(filters1, filters2, kernel_size=kernel_size, padding='same', bias=False)
        self.bn2 = nn.BatchNorm2d(filters2)
        self.relu2 = nn.ReLU(inplace=True)

        self.conv3 = nn.Conv2d(filters2, filters3, kernel_size=(1, 1), bias=False)
        self.bn3 = nn.BatchNorm2d(filters3)

        self.shortcut = nn.Sequential(
            nn.Conv2d(in_channels, filters3, kernel_size=(1, 1), bias=False),
            nn.BatchNorm2d(filters3)
        )

    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu1(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu2(out)

        out = self.conv3(out)
        out = self.bn3(out)

        # 多处理了一层
        identity = self.shortcut(identity)
        out += identity
        out = nn.ReLU(inplace=True)(out)
        return out




# if __name__ == '__main__':
#     # 这里使用官方预训练权重的加载方式
#     model = torchvision.models.resnet50(pretrained=True)
#     # 如果要使用自己的权重文件，需要按照PyTorch的权重格式和加载方式进行调整
#
#     model.eval()
#     img_path = 'elephant.jpg'
#     img = Image.open(img_path).convert('RGB')
#     transform = transforms.Compose([
#         transforms.Resize((224, 224)),
#         transforms.ToTensor(),
#         transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
#     ])
#     img = transform(img).unsqueeze(0)
#
#     with torch.no_grad():
#         output = model(img)
#     probabilities = torch.nn.functional.softmax(output, dim = 1)
#     top_p, top_class = probabilities.topk(5, dim = 1)
#     print('Predicted top 5 classes:')
#     for i in range(5):
#         print(f'Class {top_class[0][i].item()}: probability {top_p[0][i].item()}')
CV学习：传统（机器学习）图像识别（分类）
m0_51485946的博客
08-04 1万+
本文代码全部可运行，笔者运行环境：python3.7+pycharm+opencv4.6。此文是学习记录，记录实现图像识别所需知识，对各知识点并不做深入探究，但笔者提供了相关链接以便读者进行深入学习。 传统图像识别技术是指利用机器学习进行特征提取与图像分类。图像识别的过程包括信息获取、预处理、特征提取、图像分类。
人工智能之Opencv图像识别
guanyuyouxiu_的博客
11-05 1636
本文学习图像预处理具体的内容可以分为图像翻转，图像仿射变换，图像色彩空间转换，图像二值化处理，图像掩模，图像位与操作，图像检测轮廓下一篇笔记会对OpenCV图片处理过程与方法有更进一步的讲解，本篇笔记对于单个知识点和混合使用有了初步的了解。
Cv模式识别
lionzl的专栏
02-09 898
Cv模式识别 目录 [隐藏] 1 目标检测 1.1 CvHaarFeature, CvHaarClassifier, CvHaarStageClassifier, CvHaarClassifierCascade1.2 cvLoadHaarClassifierCascade1.3 cvReleaseHaarClassifierCascade1.4 cvH
JavaCV与图像识别：从基础到高级
qq_38334677的博客
12-01 4375
图像识别是计算机视觉的一个重要分支，它使计算机能够识别和处理图像中的物体。这一技术在医学、安全、游戏开发等多个领域有着广泛应用。JavaCV提供了Java接口，用于访问开源计算机视觉库，如OpenCV。JavaCV使得Java开发者能够在不牺牲性能的情况下，使用这些强大的计算机视觉工具。
CV学习：图像识别简述
m0_51485946的博客
08-04 1101
图像识别技术是信息时代的一门重要的技术，其产生目的是为了让计算机代替人类去处理大量的物理信息。图像识别技术的过程分为信息的获取、预处理、特征抽取和选择、分类器设计和分类决策。
计算机视觉大作业-卫星云层图像的理解与识别python源码+实验报告（高分项目）
11-30
计算机视觉大作业-卫星云层图像的理解与识别python源码+实验报告（高分项目）计算机视觉大作业-卫星云层图像的理解与识别python源码+实验报告（高分项目）计算机视觉大作业-卫星云层图像的理解与识别python源码+实验...
cifar-10图像识别训练集
10-31
CIFAR-10图像识别训练集是一个广泛使用的机器学习数据集，专门用于训练和评估图像识别算法。这个数据集由10个类别组成，每个类别包含了6000张32x32像素的彩色图像。这十个类别分别是：飞机、汽车、鸟、猫、鹿、狗、...
人工智能YOLO-V2-图像识别实验报告
10-15
### 人工智能YOLO-V2-图像识别实验报告：深度学习视角下的目标检测 #### 一、计算机视觉的历史与挑战 自20世纪60年代计算机视觉作为一门独立学科诞生以来，经历了从初步探索到深入研究的过程。特别是到了80年代，...
2017-2018年度图像识别与分类工程实践项目-pgj-zip
03-14
项目中提到的“图像识别与分类技术”，是指利用计算机技术对数字图像进行处理，通过提取图像中的关键信息，自动识别和分类图像中的对象或场景。这种技术需要依赖于强大的算法模型，比如卷积神经网络（CNN），它们...
人工智能-图像识别-matlab-基于MATLAB的车牌识别系统
07-03
【标题】"人工智能-图像识别-matlab-基于MATLAB的车牌识别系统"涉及的核心技术是人工智能中的图像处理和模式识别，主要工具是MATLAB。MATLAB是一款强大的数学计算和编程环境，尤其在信号处理、图像分析和机器学习等...
CV万能验证码识别填写软件 v2019
10-28
在以前的互联网是没有验证码的，后来随着一些自动程序的出现（如自动注册邮箱、自动发布信息等），对网络的正常使用产生越来越严重的影响，便产生了验证码。使用验证码的目的是通过一定的检测方式将自动程序和真正的用户区分出来，从而区别对待，保证真正用户的正常使用。验证码区别自动程序和真正用户的标准，是基于程序不具备人工智能（AI）这个条件之上的，基于这个思路，验证码可以有很多形式，比如根据照片说出动物的名字、看图识字（数字、字母、汉字）、听声音进行输入、对句子进行语意分析等等，都可在一定程度上实现验证码的作用，但综合考虑实现的成本、用户体验、破解的难度这些因素，目前使用最广泛的是看图识字这种形式，即图形验证码，就是根据图片上的数字、字母，用户再重新输入一遍，这种方式实现较为简单、用户使用方便、破解的难度相对较大。现在在一些重要些的环节大多都有图形验证码进行保护，以前的自动程序由于验证码的保护而无法实现全自动化，这样就有了验证码识别的研究——图形验证码的识别。 1、识别程序以dll或exe的方式提供使用，通过简单的函数调用即可识别复杂的验证码图片，也可以自动在屏幕上识别和填写。 2、自动识别； 智能
计算机视觉CV实战：图像识别与物体检测
最新发布
shejizuopin的博客
03-28 547
本文详细介绍了计算机视觉在图像识别与物体检测中的实战应用，并通过代码示例进行了深入分析。图像识别涉及图像预处理、特征提取与分类等步骤，而物体检测则主要依赖于深度学习模型。随着计算机视觉技术的不断发展，图像识别与物体检测的准确性和效率将进一步提高，为人工智能领域的应用提供更加强大的支持。希望本文的内容能够帮助您更好地理解和应用计算机视觉技术，为您的项目开发提供有力支持。
【cv智能检测】图像识别对产品中形状不合格的残次品的智能检测
和德天老师一起踏上学习Python之旅
11-17 1512
【代码】【cv智能检测】图像识别对产品中形状不合格的残次品的智能检测。
一个简单的人物图片相似对比程序
weixin_30409849的博客
02-17 224
程序是参考了两部分的别人的代码，一个是找出照片中的人头，另一个是对两个人头照片做对比。 # -*- coding: utf-8 -*- # feimengjuan # 利用python实现多种方法来实现图像识别 import cv2 import numpy as np from matplotlib import pyplot as plt, image # 最简单...
CV - 人脸识别（完结）
weixin_46398446的博客
10-05 7523
近期辞了前端实习，开始考虑考研了。考研就不走开发，选个专业相关的方向大概还轻松点吧( 计算机视觉感觉挺好玩的，一定要学下去！！ 文章目录一、前置条件安装opencv二、开始学习1.图片处理相关操作2.视频检测3.信息录入4.数据训练5.人脸识别 一、前置条件 安装opencv opencv官网 pip install opencv-python 二、开始学习 1.图片处理相关操作 别着急，这里只是学习基本操作 # 导入cv模块 import cv2 as cv # 读取图片 img = cv.
人脸识别 | AI产品经理需要了解的CV通识（二）
hanniman
01-04 2037
前言：本文作者@jasmine，是我们“AI产品经理大本营”成员，下面是她分享的第4篇文章，欢迎更多有兴趣“主动输出”的朋友们一起加入、共同进步：） 最近整理了CV方向的一些产品基础知识，我上一篇文章《看AI产品经理如何介绍“计算机视觉”（基于实战经验和案例）》算是这个系列的第一篇；本文是本系列下的第二篇，主要针对人脸识别进行梳理。后续还会有多目标跟踪、OCR等方向的内容。希望大家能从这个系列收获
计算机视觉（CV）知识图谱
Stefan的博客
01-25 3169
计算机视觉（CV）知识图谱 完整的思维导图
CV《物体识别与检测2 - 多目标识别基本算法》
qq_29367075的博客
10-25 2726
本文是根据Andrew Ng的深度学习视频学习，自己总结的。这一系列先只学习关键技术和设计，具体的实例等下一期进行。 一：多object的识别与检测 现在我们来个复杂一些的，在一副图像中我们存在多个不同的检测目标体，比如在自动驾驶中，在一幅图像中存在行人，汽车，摩托车各个若干，如下图所示。 这时候，单object检测的算法就失去了作用，必须得做出一些改变出来。 二：基于滑动窗口的检测技术 一个比较朴素的思路就是，我们上一文章中，既然已经训练好了单个图像识别的模型，何不充分利用整个思路呢。 思路如下：我们
CV基础-字符识别模型
evenson1的博客
05-28 324
CNN 学习网站： CNN历史和强化学习（强推）：https://blog.csdn.net/jiaoyangwm/article/details/80011656?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值