深度学习的应用

無量空所

已于 2025-02-01 16:49:40 修改

阅读量1.3k

点赞数 31

分类专栏：深度学习文章标签：深度学习人工智能

于 2025-01-31 10:08:33 首次发布

本文链接：https://blog.youkuaiyun.com/m0_67804957/article/details/145403705

版权

深度学习专栏收录该内容

8 篇文章

订阅专栏

深度学习的应用领域广泛且多样，涵盖了计算机视觉、自然语言处理、推荐系统等多个领域。

一、机器视觉

1.1 应用场景

计算机视觉（Computer Vision）又称机器视觉（Machine Vision），是一门让机器学会如何去“看”的学科，是深度学习技术的一个重要应用领域，被广泛应用于安防、工业质检和自动驾驶等场景。具体来说，就是让机器去识别摄像机拍摄的图片或视频中的物体，检测出物体所在的位置，并对目标物体进行跟踪，从而理解并描述出图片或视频里的场景和故事，以此来模拟人脑视觉系统。因此，计算机视觉也通常被叫做机器视觉，其目的是建立能够从图像或者视频中“感知”信息的人工系统。

计算机视觉技术经过几十年的发展，已经在交通（车牌识别、道路违章抓拍）、安防（人脸闸机、小区监控）、金融（刷脸支付、柜台的自动票据识别）、医疗（医疗影像诊断）、工业生产（产品缺陷自动检测）等多个领域应用，影响或正在改变人们的日常生活和工业生产方式。未来，随着技术的不断演进，必将涌现出更多的产品和应用，为我们的生活创造更大的便利和更广阔的机会。

1.2 常见的计算机视觉任务

1.2.1 图像分类

图像分类利用计算机对图像进行定量分析，把图像或图像中的像元或区域划分为若干个类别中的某一种。以下是一些常见的图像分类算法：

1.2.2 目标检测

对计算机而言，能够“看到”的是图像被编码之后的数字，但它很难理解高层语义概念，比如图像或者视频帧中出现的目标是人还是物体，更无法定位目标出现在图像中哪个区域。目标检测的主要目的是让计算机可以自动识别图片或者视频帧中所有目标的类别，并在该目标周围绘制边界框，标示出每个目标的位置。目标检测应用场景覆盖广泛，如安全帽检测、火灾烟雾检测、人员摔倒检测、电瓶车进电梯检测等。

以下是一些常见的目标检测算法：

1.2.3 图像分割

图像分割指的是将数字图像细分为多个图像子区域的过程，即对图像中的每个像素加标签，这一过程使得具有相同标签的像素具有某种共同视觉特性。图像分割的目的是简化或改变图像的表示形式，使得图像更容易理解和分析。图像分割通常用于定位图像中的物体和边界（线、曲线等）。图像分割的领域非常多，如人像分割、车道线分割、无人车、地块检测、表计识别等。

以下是一些常见的图像分割算法：

U-Net

DeepLabv3+

PSPNet

GSCNN

HRNet

PP-LiteSeg

PP-HumanSeg

PP-Matting

二、自然语言处理

自然语言处理（Natural Language Processing，简称 NLP）是计算机科学和人工智能领域的一个重要方向。它主要研究人与计算机之间，使用自然语言进行有效通信的各种理论和方法。简单来说，计算机以用户的自然语言数据作为输入，在其内部通过定义的算法进行加工、计算等系列操作后（用以模拟人类对自然语言的理解），再返回用户所期望的结果。

随着计算机和互联网技术的发展，自然语言处理技术在各领域广泛应用，我们平时常用的搜索引擎、新闻推荐、智能音箱等产品，都是以自然语言处理技术为核心的互联网和人工智能产品。

三、推荐系统

互联网和信息计算的快速发展，衍生了海量的数据，我们已经进入了一个信息爆炸的时代，每时每刻都有海量信息产生，然而这些信息并不全是个人所关心的，用户从大量的信息中寻找对自己有用的信息也变得越来越困难。另一方面，信息的生产方也在绞尽脑汁地把用户感兴趣的信息送到用户面前，每个人的兴趣又不尽相同，所以可以实现千人千面的推荐系统应运而生。简单来说，推荐系统是根据用户的浏览习惯，确定用户的兴趣，通过发掘用户的行为，将合适的信息推荐给用户，满足用户的个性化需求，帮助用户找到对他胃口但不易找到的信息或商品。

推荐系统在互联网和传统行业中都有着大量的应用。在互联网行业，几乎所有互联网平台都应用了推荐系统，如资讯新闻、影视剧、知识社区的内容推荐、电商平台的商品推荐等；在传统行业中，有些用于企业的营销环节，如银行的金融产品推荐、保险公司的保险产品推荐等。

3.1 常用的推荐系统算法实现方案

协同过滤推荐（Collaborative Filtering Recommendation）

基于用户的协同过滤：根据用户的历史喜好分析出相似兴趣的人，然后给用户推荐其他人喜欢的物品。例如，小李和小张对物品 A、B 都给了十分好评，那么可以认为小李和小张具有相似的兴趣爱好，如果小李给物品 C 十分好评，那么可以把 C 推荐给小张。

基于物品的协同过滤：根据用户的历史喜好分析出相似物品，然后给用户推荐同类物品。例如，小李对物品 A、B、C 给了十分好评，小王对物品 A、C 给了十分好评，从这些用户的喜好中分析出喜欢 A 的人都喜欢 C，物品 A 和 C 是相似的，如果小张给了 A 好评，那么可以把 C 也推荐给小张。

基于内容过滤推荐（Content-based Filtering Recommendation）

核心是衡量出两个物品的相似度。首先对物品或内容的特征作出描述，发现其相关性，然后基于用户以往的喜好记录，推荐给用户相似的物品。例如，小张对物品 A 感兴趣，而物品 A 和物品 C 是同类物品（从物品的内容描述上判断），可以把物品 C 也推荐给小张。

组合推荐（Hybrid Recommendation）

实际应用中往往不只采用某一种推荐方法，而是通过一定的组合方法将多个算法混合在一起，以实现更好的推荐效果，比如加权混合、分层混合等。具体选择哪种方式和应用场景有很大关系。

四、图像分类实验补充

4.1 CIFAR-100 数据集实验

CIFAR-100 数据集有 100 个类别，每个类别有 600 张大小为 32×32 的彩色图像，其中 500 张作为训练集，100 张作为测试集。对于每一张图像，它有 fine_labels 和 coarse_labels 两个标签，分别代表图像的细粒度和粗粒度标签。对应下图中的 classes 和 superclass。也就是说， CIFAR100 数据集是层次的。

实验代码

# python --version     3.8.10
# PyTorch --version   2.3.1
# torchvision --version 0.18.1
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR100


# 定义超参数
num_epochs = 5
batch_size = 64
learning_rate = 0.001

kernel_size = 5
image = 32

# 数据增强
# transform_train = transforms.Compose([
#     transforms.RandomHorizontalFlip(),
#     transforms.RandomCrop(32, padding=4),
#     transforms.ToTensor(),
#     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
# ])
#
# transform_test = transforms.Compose([
#     transforms.ToTensor(),
#     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
# ])
# # 加载和预处理数据
# train_dataset = CIFAR100(root='./', train=True, transform=transform_train, download=False)
# test_dataset = CIFAR100(root='./', train=False, transform=transform_test, download=False)

# 加载和预处理数据
train_dataset = CIFAR100(root='./', train=True, transform=transforms.ToTensor(), download=False)
test_dataset = CIFAR100(root='./', train=False, transform=transforms.ToTensor(), download=False)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)


# 定义CNN模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=5, padding=2, stride=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(in_features=16*6*6, out_features=100)

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = x.view(-1, 16*6*6)  # Flatten
        x = self.fc1(x)
        return x


# 训练模型
def train(model, train_loader, optimizer, criterion, epochs):
    model.train()
    for epoch in range(epochs):
        for i, (images, labels) in enumerate(train_loader):
            optimizer.zero_grad()
            outputs = model.forward(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            if i % 100 == 0:
                print(f"Epoch [{epoch + 1}/{epochs}], step {i + 1}/{len(train_loader)}, Loss: {loss.item()}")


# 测试模型
def predict(model, test_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            outputs = model.forward(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print(f'Accuracy on test set: {100 * correct / total:.2f}%')


# 初始化模型、损失函数和优化器
model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练并测试模型
train(model, train_loader, optimizer, criterion, epochs=num_epochs)

# 模型保存并测试
torch.save(model.state_dict(), 'cnn_state_dict.pth')

# 加载模型
model = CNN()
model.load_state_dict(torch.load('cnn_state_dict.pth'))
predict(model, test_loader)

4.2 CIFAR-10

CIFAR-10 数据集是一个用于普适物体识别的计算机视觉数据集，包含 60000张 32x32 的 RGB 彩色图片，总共分为 10 个类别。每个类别包含 6000 张图像，其中 50000 张用于训练集， 10000 张用于测试集。

实验代码

# python --version     3.8.10
# PyTorch --version   2.3.1
# torchvision --version 0.18.1
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10


# 定义超参数
num_epochs = 1
batch_size = 64
learning_rate = 0.001

# 加载和预处理数据
train_dataset = CIFAR10(root='./', train=True, transform=transforms.ToTensor(), download=False)
test_dataset = CIFAR10(root='./', train=False, transform=transforms.ToTensor(), download=False)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)


# 定义CNN模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=5, padding=2, stride=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(in_features=16*6*6, out_features=10)

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = x.view(-1, 16*6*6)  # Flatten
        x = self.fc1(x) #会自动加softmax
        return x


# 训练模型
def train(model, train_loader, optimizer, criterion, epochs):
    model.train()
    for epoch in range(epochs):
        for i, (images, labels) in enumerate(train_loader):
            optimizer.zero_grad()
            outputs = model.forward(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            if i % 100 == 0:
                print(f"Epoch [{epoch + 1}/{epochs}], step {i + 1}/{len(train_loader)}, Loss: {loss.item()}")


# 测试模型
def predict(model, test_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            outputs = model.forward(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print(f'Accuracy on test set: {100 * correct / total:.2f}%')


# 初始化模型、损失函数和优化器
model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练并测试模型
train(model, train_loader, optimizer, criterion, epochs=num_epochs)

# 模型保存并测试
torch.save(model.state_dict(), 'cnn_state_dict.pth')

# 加载模型
model = CNN()
model.load_state_dict(torch.load('cnn_state_dict.pth'))
predict(model, test_loader)