神经网络—MobileNet系列（pythorch）

已于 2024-08-30 11:58:13 修改
阅读量763 收藏 19
点赞数 16
文章标签： 神经网络 人工智能 深度学习
于 2024-08-30 11:57:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_86447519/article/details/141714296
版权

MobileNet 是一种设计用于资源受限环境中的深度卷积神经网络架构，由 Google 的研究团队提出。其主要目的是在保持高效计算和较小模型体积的同时，提供令人满意的分类性能。MobileNet 特别适合移动设备和嵌入式系统，主要因为其优化了计算资源和内存使用。

MobileNet 的核心特点：

  1. 深度可分离卷积 (Depthwise Separable Convolutions):

    • 深度卷积 (Depthwise Convolution): 这一层对每个输入通道应用一个单独的卷积核，进行空间特征的提取。
    • 逐点卷积 (Pointwise Convolution): 这一层通过 $1 \times 1$ 卷积将深度卷积的输出进行通道整合，生成最终的输出。
    • 优点: 这种卷积方式显著减少了计算量和模型参数，使得网络更为高效。

  2. 轻量级设计:

    • MobileNet 网络设计致力于降低计算和存储需求，使其适用于计算资源有限的设备，如智能手机和嵌入式系统。
    • 模型体积小，推理速度快，但仍能提供较高的准确率。

  3. 可调节的宽度因子 (Width Multiplier):

    • MobileNet 提供了一个可调节的宽度因子（α），可以控制网络的宽度（即每层的卷积核数量）。通过调整 α，用户可以在准确性和计算资源之间进行权衡。
    • 例如，α 值为 1.0 表示原始模型，α 值为 0.5 表示减小模型规模的版本。

  4. 可调节的分辨率因子 (Resolution Multiplier):

    • MobileNet 还允许用户调整输入图像的分辨率（ρ），从而进一步影响计算量和准确性。降低输入图像的分辨率会减少计算量，但可能会影响模型的性能。
MobileNet 的版本：

MobileNetV1:

  • 发布年份: 2017
  • 架构: 使用深度可分离卷积代替标准卷积。模型设计简单，易于实现。
  • 特点: 模型参数和计算量较少，但准确率较高，适合移动设备使用。

MobileNetV2:

  • 发布年份: 2018
  • 架构: 引入了反向残差块（Inverted Residual Blocks）和线性瓶颈（Linear Bottleneck）。这些改进提高了特征提取能力和效率。
    • 反向残差块: 在每个反向残差块中，输入通过一个深度可分离卷积进行变换，然后通过逐点卷积调整通道数，最后通过一个线性瓶颈进行特征整合。
    • 线性瓶颈: 移除了激活函数（如 ReLU）在卷积的最后阶段，保留了线性输出，以减少信息丢失和计算开销。
  • 特点: 在提高计算效率的同时，进一步增强了模型的表示能力和准确性。

MobileNetV3:

  • 发布年份: 2019
  • 架构: 结合了 MobileNetV2 的设计与网络架构搜索（NAS）技术，自动化寻找最优网络结构。
    • 网络架构搜索: 通过搜索算法自动调整卷积核大小、网络深度等超参数，以实现最佳性能。
    • 改进: 包括高效的非线性激活函数（如 Swish），以及使用自适应的神经网络结构优化技术。
  • 版本:
    • MobileNetV3-Large: 针对计算资源较多的场景，如高性能设备。
    • MobileNetV3-Small: 针对计算资源有限的设备，如边缘设备和物联网设备。
模型配置和调整

MobileNet 提供了以下几种调整方式，以适应不同计算资源和应用场景：

  • 宽度因子 (Width Multiplier):

    • 控制网络中每层的卷积核数量。例如，宽度因子 α=1.0 表示标准模型，α=0.5 表示每层卷积核数量减半，从而减少计算量和模型参数。

  • 分辨率因子 (Resolution Multiplier):

    • 控制输入图像的分辨率。例如，分辨率因子 ρ=1.0 表示标准输入分辨率，ρ=0.5 表示输入图像分辨率减半，从而减少计算量。
应用场景

MobileNet 由于其高效的计算能力和较小的模型体积，适合于各种计算资源受限的应用场景：

  • 图像分类:

    • 在移动设备上进行实时图像分类，例如照片分类或相册管理。

  • 目标检测:

    • 结合 MobileNet 与目标检测框架（如 SSD），进行移动设备上的目标检测和识别。

  • 语义分割:

    • 在嵌入式设备上进行图像分割任务，例如道路场景分析或医疗图像分析。

  • 实时视频处理:

    • 在智能手机和无人机等设备上进行实时视频处理和分析。

MobileNet 的高效设计使得其成为深度学习模型在资源受限环境中的一个理想选择，同时提供了多种可调节参数以平衡准确性和计算效率。

MobileNetV1实现：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. 定义模型
class DepthwiseSeparableConv(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1, padding=1):
        super(DepthwiseSeparableConv, self).__init__()
        self.depthwise = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=stride, padding=padding, groups=in_channels, bias=False)
        self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.depthwise(x)
        x = self.bn(x)
        x = self.relu(x)
        x = self.pointwise(x)
        x = self.bn(x)
        x = self.relu(x)
        return x

class MobileNetV1(nn.Module):
    def __init__(self, num_classes=10):
        super(MobileNetV1, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            DepthwiseSeparableConv(32, 64, stride=1),
            DepthwiseSeparableConv(64, 128, stride=2),
            DepthwiseSeparableConv(128, 128, stride=1),
            DepthwiseSeparableConv(128, 256, stride=2),
            DepthwiseSeparableConv(256, 256, stride=1),
            DepthwiseSeparableConv(256, 512, stride=2),
            DepthwiseSeparableConv(512, 512, stride=1),
            DepthwiseSeparableConv(512, 512, stride=1),
            DepthwiseSeparableConv(512, 512, stride=1),
            DepthwiseSeparableConv(512, 512, stride=1),
            DepthwiseSeparableConv(512, 1024, stride=2),
            DepthwiseSeparableConv(1024, 1024, stride=1),
            nn.AdaptiveAvgPool2d(1),
        )
        self.fc = nn.Linear(1024, num_classes)

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

# 2. 设置数据加载器
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
])

train_dataset = datasets.FakeData(transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 3. 实例化模型、损失函数和优化器
model = MobileNetV1(num_classes=10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 4. 训练模型
def train_model(model, criterion, optimizer, dataloader, num_epochs=1):
    model.train()
    for epoch in range(num_epochs):
        running_loss = 0.0
        for inputs, labels in dataloader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item() * inputs.size(0)
        epoch_loss = running_loss / len(dataloader.dataset)
        print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}')

# 5. 训练
train_model(model, criterion, optimizer, train_loader, num_epochs=5)

MobileNetV2实现：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. 定义倒残差块
class InvertedResidual(nn.Module):
    def __init__(self, in_channels, out_channels, stride, expand_ratio):
        super(InvertedResidual, self).__init__()
        hidden_channels = in_channels * expand_ratio
        self.use_res_connect = stride == 1 and in_channels == out_channels

        layers = []
        if expand_ratio != 1:
            layers.append(nn.Conv2d(in_channels, hidden_channels, kernel_size=1, stride=1, padding=0, bias=False))
            layers.append(nn.BatchNorm2d(hidden_channels))
            layers.append(nn.ReLU6(inplace=True))

        layers.extend([
            nn.Conv2d(hidden_channels, hidden_channels, kernel_size=3, stride=stride, padding=1, groups=hidden_channels, bias=False),
            nn.BatchNorm2d(hidden_channels),
            nn.ReLU6(inplace=True),
            nn.Conv2d(hidden_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(out_channels),
        ])
        self.block = nn.Sequential(*layers)

    def forward(self, x):
        if self.use_res_connect:
            return x + self.block(x)
        else:
            return self.block(x)

# 2. 定义 MobileNetV2 模型
class MobileNetV2(nn.Module):
    def __init__(self, num_classes=10):
        super(MobileNetV2, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(32),
            nn.ReLU6(inplace=True),
            InvertedResidual(32, 16, stride=1, expand_ratio=1),
            InvertedResidual(16, 24, stride=2, expand_ratio=6),
            InvertedResidual(24, 24, stride=1, expand_ratio=6),
            InvertedResidual(24, 32, stride=2, expand_ratio=6),
            InvertedResidual(32, 32, stride=1, expand_ratio=6),
            InvertedResidual(32, 64, stride=2, expand_ratio=6),
            InvertedResidual(64, 64, stride=1, expand_ratio=6),
            InvertedResidual(64, 64, stride=1, expand_ratio=6),
            InvertedResidual(64, 64, stride=1, expand_ratio=6),
            InvertedResidual(64, 96, stride=1, expand_ratio=6),
            InvertedResidual(96, 96, stride=1, expand_ratio=6),
            InvertedResidual(96, 160, stride=2, expand_ratio=6),
            InvertedResidual(160, 160, stride=1, expand_ratio=6),
            InvertedResidual(160, 320, stride=1, expand_ratio=6),
            nn.Conv2d(320, 1280, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(1280),
            nn.ReLU6(inplace=True),
            nn.AdaptiveAvgPool2d(1),
        )
        self.fc = nn.Linear(1280, num_classes)

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

# 3. 设置数据加载器
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
])

train_dataset = datasets.FakeData(transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 4. 实例化模型、损失函数和优化器
model = MobileNetV2(num_classes=10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 5. 训练模型
def train_model(model, criterion, optimizer, dataloader, num_epochs=1):
    model.train()
    for epoch in range(num_epochs):
        running_loss = 0.0
        for inputs, labels in dataloader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item() * inputs.size(0)
        epoch_loss = running_loss / len(dataloader.dataset)
        print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}')

# 6. 训练
train_model(model, criterion, optimizer, train_loader, num_epochs=5)

MobileNetV3实现：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. 定义 SE 模块
class SqueezeAndExcitation(nn.Module):
    def __init__(self, in_channels, reduction=4):
        super(SqueezeAndExcitation, self).__init__()
        hidden_channels = max(1, in_channels // reduction)
        self.fc1 = nn.Conv2d(in_channels, hidden_channels, kernel_size=1)
        self.relu = nn.ReLU(inplace=True)
        self.fc2 = nn.Conv2d(hidden_channels, in_channels, kernel_size=1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        b, c, _, _ = x.size()
        se = nn.functional.adaptive_avg_pool2d(x, 1)
        se = self.fc1(se)
        se = self.relu(se)
        se = self.fc2(se)
        se = self.sigmoid(se)
        return x * se

# 2. 定义倒残差块
class InvertedResidualV3(nn.Module):
    def __init__(self, in_channels, out_channels, stride, expansion, use_se):
        super(InvertedResidualV3, self).__init__()
        hidden_channels = in_channels * expansion
        self.use_residual = stride == 1 and in_channels == out_channels

        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, hidden_channels, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(hidden_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(hidden_channels, hidden_channels, kernel_size=3, stride=stride, padding=1, groups=hidden_channels, bias=False),
            nn.BatchNorm2d(hidden_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(hidden_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(out_channels)
        )
        if use_se:
            self.se = SqueezeAndExcitation(out_channels)
        else:
            self.se = None

    def forward(self, x):
        identity = x
        x = self.conv(x)
        if self.se:
            x = self.se(x)
        if self.use_residual:
            return x + identity
        else:
            return x

# 3. 定义 MobileNetV3 模型
class MobileNetV3(nn.Module):
    def __init__(self, num_classes=10):
        super(MobileNetV3, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(16),
            nn.ReLU(inplace=True),
            InvertedResidualV3(16, 16, stride=1, expansion=1, use_se=False),
            InvertedResidualV3(16, 24, stride=2, expansion=4, use_se=False),
            InvertedResidualV3(24, 24, stride=1, expansion=3, use_se=False),
            InvertedResidualV3(24, 40, stride=2, expansion=3, use_se=True),
            InvertedResidualV3(40, 40, stride=1, expansion=3, use_se=True),
            InvertedResidualV3(40, 80, stride=2, expansion=6, use_se=False),
            InvertedResidualV3(80, 80, stride=1, expansion=6, use_se=False),
            InvertedResidualV3(80, 80, stride=1, expansion=6, use_se=False),
            InvertedResidualV3(80, 112, stride=1, expansion=6, use_se=True),
            InvertedResidualV3(112, 112, stride=1, expansion=6, use_se=True),
            InvertedResidualV3(112, 160, stride=2, expansion=6, use_se=True),
            InvertedResidualV3(160, 160, stride=1, expansion=6, use_se=True),
            nn.Conv2d(160, 960, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(960),
            nn.ReLU(inplace=True),
            nn.AdaptiveAvgPool2d(1),
        )
        self.fc = nn.Linear(960, num_classes)

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

# 4. 设置数据加载器
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
])

train_dataset = datasets.FakeData(transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 5. 实例化模型、损失函数和优化器
model = MobileNetV3(num_classes=10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 6. 训练模型
def train_model(model, criterion, optimizer, dataloader, num_epochs=1):
    model.train()
    for epoch in range(num_epochs):
        running_loss = 0.0
        for inputs, labels in dataloader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item() * inputs.size(0)
        epoch_loss = running_loss / len(dataloader.dataset)
        print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}')

# 7. 训练
train_model(model, criterion, optimizer, train_loader, num_epochs=5)

辽逸
关注
PyTorch深度学习实战（3）——使用PyTorch构建神经网络
盼小辉丶的博客
06-13 6万+
PyTorch 是一个用于构建深度神经网络的库，具有灵活性和可扩展性，可以轻松自定义模型。在本节中，我们将使用 PyTorch 库构建神经网络，利用张量对象操作和梯度值计算更新网络权重，并利用 Sequential 类简化网络构建过程，最后还介绍了如何使用 save、load 方法保存和加载模型，以节省模型训练时间。
特征提取网络之mobilenet
weixin_41311686的博客
07-26 1642
MobileNet网络是由google团队在2017年提出的，专注于移动端或者嵌入式设备中的轻量级CNN网络。相比传统卷积神经网络，在准确率小幅降低的前提下大大减少模型参数与运算量。(相比VGG16准确率减少了0.9%，但模型参数只有VGG的1/32)。主要创新点在于深度可分离卷积，而整个网络实际上也是深度可分离模块的堆叠。...
机器学习： 利用 Tensorflow 和预训练模型提取特征-- Mobilenet V1
Matrix-11
03-24 8039
传统的 CV 问题，一般把特征提取和分类模型的构建训练分成两个步骤，CNN 可以把这两者合在一个网络里，目前很多实验证明，利用大量数据训练过的 CNN 可以用作很好的特征提取器，类似一种特征迁移。 今天介绍一下，如何利用 Tensorflow 和 预先训练好的模型，做特征提取，我们可以用 TensorFlow GitHub 官网上的预训练模型来做特征提取： https://github.com/t...
机器学习： 利用 Tensorflow 和预训练模型提取特征-- Mobilenet V2
Matrix-11
04-04 5351
之前介绍了利用 Mobinet V1 做特征提取，从 Tensorflow 的官网上看， Mobilenet V2 的性能比 V1 要更好，今天介绍用 V2 的预训练模型提取特征的方式，基本和 V1 是一样的，只是有一个地方需要注意一下，就是加载网络结构的时候： with tf.contrib.slim.arg_scope(mobilenet_v2.training_scope(is_traini...
利用 Tensorflow 和预训练模型提取特征-- Mobilenet V1
qq_43631789的博客
06-04 575
https://blog.csdn.net/matrix_space/article/details/88776253
mobielnet提取特征图片比对
xiexiecn的专栏
07-25 732
平时pytorch用得多，tf的代码还是弄了半天，网上的code不靠谱太多。当然得先down模型，clone tensorflow models，然后执行下代码里的export。 # encoding: utf-8 import os import sys import cv2 import glob import numpy as np import tensorflow as tf im...
基于Pytorch框架深度学习神经网络LightWeight的人体姿态检测系统源码
修行之路
04-09 685
基于深度学习神经网络LightWeight的人体姿态检测系统源码
基于卷积神经网络MobileNet 的情感识别源码.7z
06-20
综上所述，这个项目主要探讨了如何利用MobileNet这一高效的卷积神经网络模型进行情感识别，涉及到的关键技术包括深度可分离卷积、特征提取、模型训练、数据预处理和数据集构建。对于想要深入理解和实践深度学习在...
移动端使用的卷积神经网络MobileNet
qq_24305433的博客
05-12 2475
一、简介 深度学习虽然在近期得到快速的发展，但是由于深度学习网络过于复杂，往往像一些知名的大型卷积神经网络的参数都会在数百M，此外深度学习需要较大的计算量，这些给深度学习在移动端的使用带来了困难。本文针对这一问题设计的MobileNet可以大大的减少网络的参数，同时能够减少网络的计算量，使网络可以适用于移动端，这也是为何称它为MobileNet的原因。 二、MobileNet网络结构 1、D...
mobilenet系列V1-V3
06-05
MobileNet系列是由Google团队开发的一系列轻量级卷积神经网络（CNN），旨在优化移动设备和嵌入式系统的性能。这个系列始于MobileNetV1，随后演化为MobileNetV2和MobileNetV3，每一代都在提高准确率和减少模型大小...
图像识别：基于mobilenet轻量级神经网络识别
03-20
在众多的神经网络模型中，Mobilenet系列因其轻量化、高效的特点，成为移动设备和资源受限环境下的首选模型。本文将详细介绍基于Mobilenet的图像识别技术。 一、Mobilenet简介 Mobilenet是一种专门为移动设备设计的...
MobileNet学习笔记
huang_nansen的博客
11-05 567
MobileNet v1 论文中提到，MobileNet的创新点在于使用深度可分离卷积代替传统卷积用于提取特征，达到减少计算资源损耗和减小模型大小的目的。 传统卷积中,G为下一层特征图，F为输入的特征图，K为kernel，M为输入通道数，N为输出通道数。                                                                所需要的计...
神经网络（五）：U2Net图像分割网络
悟兰因的博客
09-25 1066
这篇文章基于显著目标检测任务提出，显著目标检测是指将图像中最吸引人的目标或者区域分割出来，因此只有前景和背景两个类别，相当于语义分割中的二分类任务。例如，下图中展示了三张图片进行显著目标检测后的结果：其中，白色区域代表前景 ，即最吸引人的目标或区域，而黑色区域代表背景。在U2NetAlexNetVGGResNetResNeXt为解决上述问题，提出了U2Net。
故障诊断 | 基于双路神经网络的滚动轴承故障诊断
关注并私信文章链接，获取对应文章源码和数据，机器学习之心的博客。
09-23 245
故障诊断 | 基于双路神经网络的滚动轴承故障诊断
深入探讨AI 神经网络：类型、特点与创新应用
梵心白莲的博客
09-26 1014
深入剖析不同类型神经网络的特点及在 AI 中的创新应用是本论文的主要目的。通过对各种神经网络的结构、原理、特点进行分析，我们可以更好地理解它们在人工智能中的作用。同时，结合实际应用案例，探讨不同类型神经网络在图像识别、语音识别、自然语言处理等领域的创新应用，为人工智能的发展提供理论支持和实践指导。
CNN-LSTM预测 | MATLAB实现CNN-LSTM卷积长短期记忆神经网络时间序列预测
关注并私信文章链接，获取对应文章源码和数据，机器学习之心的博客。
09-25 304
CNN-LSTM预测 | MATLAB实现CNN-LSTM卷积长短期记忆神经网络时间序列预测
一起了解计算机神经网络
最新发布
梵心白莲的博客
09-26 750
本文简单介绍计算机神经网络的基本原理、主要类型及其在各个领域的应用。我们将从神经网络的基础概念出发，逐步深入探讨各种类型的神经网络架构，以及它们在解决实际问题中的具体应用。此外，我们还将讨论当前面临的挑战和未来的发展趋势，帮助读者更好地理解这一前沿技术。
神经网络介绍及其在Python中的应用（一）
小高~的博客
09-26 854
LR类继承自nn.Module，其中self.linear定义了一个线性层，输入和输出特征均为1。神经网络通过层叠多个非线性变换，能够学习到复杂的模式和特征。在实际应用中，通过选择合适的架构、激活函数和优化算法，可以实现高效的模型训练和预测。随着深度学习技术的不断发展，神经网络将在更广泛的领域发挥作用。码字艰辛，本篇内容就分享至此，如果渴望深入了解更多Python机器学习方面的应用，别忘了点击关注博主，引导你从零开始探索Python在统计分析上的奥秘。《Python之机器学习》
侯媛彬神经网络概论
"神经网络（侯媛彬）" 神经网络是一种机器学习算法，能够模拟人类大脑神经网络的工作方式，通过训练和学习来实现模式识别、分类、回归等功能。神经网络的应用非常广泛，包括图像识别、语音识别、自然语言处理、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值