基于轻量级神经网络GhostNet开发构建CIFAR100数据集场景下的图像识别分析系统,对比不同分辨路尺度下模型的性能情况

news2024/11/14 18:27:40

Cifar100数据集是一个经典的图像分类数据集,常用于计算机视觉领域的研究和算法测试。以下是关于Cifar100数据集的详细介绍:

  1. 数据集构成:Cifar100数据集包含60000张训练图像和10000张测试图像。其中,训练图像分为100个类别,每个类别有600张图像;测试图像也分为100个类别,每个类别有100张图像。这些图像都是32x32像素的彩色图像,包含RGB三个通道。
  2. 类别划分:Cifar100数据集的100个类别被划分为20个大类别,每个大类别包含5个小类别。这些类别涵盖了动物、植物、交通工具、日常生活用品、自然景观、人物、体育、食物、艺术等多个领域。例如,动物类别包括鸟类、鱼类、爬行动物、哺乳动物等;植物类别包括树木、花卉、农作物等;交通工具类别包括汽车、火车、飞机、船等。
  3. 层次结构:Cifar100数据集的层次结构使得数据集更加丰富,包含了各种各样的对象和场景。这种层次结构有助于研究人员更好地理解数据集,并设计出更有效的算法来处理图像分类任务。
  4. 应用场景:Cifar100数据集常用于评估和比较各种图像分类算法的性能。研究人员可以使用该数据集来训练图像分类器,并测试其在不同类别上的识别准确率。此外,Cifar100数据集还可以用于开展图像生成和图像翻译等任务,如训练生成对抗网络(GAN)来生成逼真的图像。
  5. 数据集下载与预处理:Cifar100数据集可以通过官方渠道进行下载。下载后,需要对数据集进行预处理,包括加载图像、划分训练集和测试集、数据增强等操作。在Python中,可以使用pickle模块来加载Cifar100数据集,并使用numpy等库来处理图像数据。

Cifar100数据集是一个非常重要的图像分类数据集,具有广泛的应用场景和丰富的类别划分。通过使用Cifar100数据集,研究人员可以开发出更准确、更强大的图像分类算法,从而推动计算机视觉技术的发展。本文的主要目的就是想要基于Cifar100数据集来应用实践分析轻量级网络模型的性能。

首先看下实例效果:

由于CIFAR-100的完整类别列表较长,这里只给出部分类别实例,如下所示:

label_dict = {  
    'aquatic mammals': '水生哺乳动物',  # 超类示例  
    'beaver': '河狸',                   # 水生哺乳动物超类下的类别  
    'dolphin': '海豚',                  # 水生哺乳动物超类下的类别  
      
    'fish': '鱼',                       # 超类示例(直接作为类别)  
    'shark': '鲨鱼',                    # 鱼类超类(或作为独立类别)下的类别  
      
    'flowers': '花',                    # 超类示例  
    'tulip': '郁金香',                  # 花卉超类下的类别  
    'sunflower': '向日葵',              # 花卉超类下的类别  
      
    'food containers': '食物容器',      # 超类示例  
    'bowl': '碗',                       # 食物容器超类下的类别  
    'cup': '杯子',                      # 食物容器超类下的类别  
      
    'household electrical devices': '家用电气设备',  # 超类示例  
    'keyboard': '键盘',                 # 家用电气设备超类下的类别  
    'mouse': '鼠标',                    # 注意:这里的“mouse”指的是计算机鼠标,而非动物  
      
    'insect': '昆虫',                   # 超类(或作为独立类别)示例  
    'bee': '蜜蜂',                      # 昆虫超类下的类别  
    'butterfly': '蝴蝶',                # 昆虫超类下的类别  
      
    # ...(其他类别)  
}

数据集官方网站在这里,如下所示:

这里给出来CIFAR-10-dataset和CIFAR-100-dataset两个数据集的下载地址。

CIFAR-10-dataset,如下所示:

CIFAR-100-dataset,如下所示:

官方提供的数据集不是图像形式的,这里可以直接加载使用,实例实现如下所示:

CIFAR_PATH = "自己的路径"
mean = [0.5070751592371323, 0.48654887331495095, 0.4409178433670343]
std = [0.2673342858792401, 0.2564384629170883, 0.27615047132568404]
num_workers= 2
 
def cifar100_dataset(args):
    transform_train = transforms.Compose([
        transforms.RandomCrop(32, padding=4),
        transforms.RandomHorizontalFlip(),
        transforms.RandomRotation(15),  # 数据增强
        transforms.ToTensor(),
        transforms.Normalize(mean, std)
    ])
    transform_test = transforms.Compose(
        [transforms.ToTensor(),
        transforms.Normalize(mean, std)])
 
    cifar100_training = torchvision.datasets.CIFAR100(root=CIFAR_PATH, train=True, download=True, transform=transform_train)
    trainloader = torch.utils.data.DataLoader(cifar100_training, batch_size=args.bs, shuffle=True, num_workers=num_workers)
         
    cifar100_testing = torchvision.datasets.CIFAR100(root=CIFAR_PATH, train=False, download=True, transform=transform_test)
    testloader = torch.utils.data.DataLoader(cifar100_testing, batch_size=100, shuffle=False, num_workers=num_workers)
     
    return trainloader,testloader
  

也可以选择将官方的数据集转化为图像的形式,之后再按照图像分类模型的标准做法来进行模型的开发训练。代码实现如下所示:



import os
import pickle
import numpy as np
from tqdm import trange
from os.path import join
from PIL import Image

def createDir(path):
    if not os.path.exists(path):
        os.makedirs(path)


def unpickle(file):
    with open(file, "rb") as fo:
        dict = pickle.load(fo, encoding="latin1")
    return dict


# settings
src_dir = "./cifar-100-python"
dst_dir = "./cifar100"


if __name__ == "__main__":
    meta = unpickle(join(src_dir, "meta"))
    createDir(dst_dir)
    for data_set in ["train", "test"]:
        print("Unpickling {} dataset......".format(data_set))
        data_dict = unpickle(join(src_dir, data_set))
        createDir(join(dst_dir, data_set))
        for fine_label_name in meta["fine_label_names"]:
            createDir(join(dst_dir, data_set, fine_label_name))
        for i in trange(data_dict["data"].shape[0]):
            img = np.reshape(data_dict["data"][i], (3, 32, 32))
            i0 = Image.fromarray(img[0])
            i1 = Image.fromarray(img[1])
            i2 = Image.fromarray(img[2])
            img = Image.merge("RGB", (i0, i1, i2))
            img.save(
                join(
                    dst_dir,
                    data_set,
                    meta["fine_label_names"][data_dict["fine_labels"][i]],
                    data_dict["filenames"][i],
                )
            )

处理完成之后我们就得到了可用的图像数据集了,实例数据如下所示:

可以看到:官方的数据集都是标准的32x32的尺寸,整体来说分辨率还是比较小的:

以下是一些常用的轻量级卷积神经网络模型:

MobileNet:MobileNet是一种基于深度可分离卷积的轻量级模型,通过Depthwise Separable Convolution减少参数量和计算量,适用于移动设备上的图像分类和目标检测。

ShuffleNet:ShuffleNet通过使用通道洗牌操作来减少参数量和计算量。它采用逐点卷积和组卷积,将通道分为组并进行特征图的混洗,以增加特征的多样性。

EfficientNet:EfficientNet是一系列模型,通过使用复合缩放方法在深度、宽度和分辨率上进行均衡扩展。它在减少参数和计算量的同时,保持高准确性。

MobileNetV3:MobileNetV3是MobileNet的改进版本,引入了候选网络和网络搜索方法,通过优化模型结构和激活函数,进一步提升了轻量级模型的性能。

ProxylessNAS:ProxylessNAS是使用神经网络搜索算法来自动搜索轻量级模型结构的方法。它通过替代器生成网络中的每个操作,以有效地搜索高效的模型结构。

SqueezeNet:SqueezeNet是一种极小化的卷积神经网络模型,使用Fire模块将降维卷积和扩展卷积组合在一起,以减少参数量和计算量。

这些轻量级模型在参数量和计算量上相对较少,适用于资源受限的设备或场景。然而,每个模型都有不同的性能和特点,根据应用需求和资源限制,选择合适的模型进行使用。同时,还可以根据具体任务的要求进行模型的调整和优化。

GhostNet是一种轻量级的卷积神经网络模型,旨在在计算资源有限的设备上实现高效的图像分类和目标检测。其主要原理是通过使用Ghost Module来减少参数量和计算量,并提高模型在资源受限条件下的性能。

Ghost Module是GhostNet的关键组成部分,其主要思想是通过将一个普通的卷积层分解为两个部分:主要卷积(或称为Ghost指示器)和辅助卷积。具体构建原理如下:

主要卷积(Ghost指示器):该部分包含少量的输出通道数(称为精简通道),可以看作是对原始卷积的一种降维表示。它对输入进行低维特征提取,并通过学习有效的过滤器来减少参数量和计算量。

辅助卷积:该部分包含更多的输出通道数(称为扩展通道),用于捕捉更丰富的特征表达。这种设计有助于模型在较少的参数量下保持较高的表示能力,提高对复杂图像的判别能力。

GhostNet模型的优点如下:

轻量高效:GhostNet通过使用Ghost Module,减少了模型的参数量和计算量,使得它在计算资源受限的设备上运行速度更快,能够满足更多应用的需求。

参数效率:Ghost Module通过以较少的参数产生较多的特征图,提高了参数的利用效率。这使得模型更具可扩展性,并能够更好地适应低功耗的设备和移动端应用需求。

准确性保持:尽管GhostNet是为了追求高效而设计的,但经过实证研究表明,在一些图像分类和目标检测任务中,它的准确性能够与一些常用的大型模型相媲美,或接近。

GhostNet模型的缺点如下:

空间复杂性:尽管GhostNet在参数和计算量上显著减少,但由于采用了辅助卷积来提取更丰富的特征,其空间复杂性相对较高。这可能使得在计算资源极度有限的设备上推理速度较慢。

特定任务的局限性:GhostNet主要用于图像分类和目标检测任务。对于其他类型的任务,如语义分割或实例分割等,GhostNet可能需要额外的定制和改进来适应任务的需求。

总之,GhostNet作为一种轻量级的模型设计,通过Ghost Module降低了模型的参数量和计算量,提高了在计算资源有限的设备上的性能。尽管存在一些局限性,但它在保持一定准确性的同时,能够在资源受限情况下提供高效的图像分类和目标检测能力。

在以往的项目中使用Mobilenet模型居多,较少使用GhostNet,所以这里以实地项目开发的方式也是想进一步熟悉GhostNet模型,这里模型搭建实现代码如下所示:

# encoding:utf-8
from __future__ import division
 
 
"""
__Author__:沂水寒城
功能:  GhostNet
"""
 
 
import torch
import torch.nn as nn
import math
import numpy as np
from torch.hub import load_state_dict_from_url
from utils.utils import load_weights_from_state_dict
 
 
 
def _make_divisible(v, divisor, min_value=None):
    """
    参考
    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
    """
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v
 
 
class SELayer(nn.Module):
    """
    SE Layer
    """
    def __init__(self, channel, reduction=4):
        super(SELayer, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel),
        )
 
    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        y = torch.clamp(y, 0, 1)
        return x * y
 
 
def depthwise_conv(inp, oup, kernel_size=3, stride=1, relu=False):
    """
    DW
    """
    return nn.Sequential(
        nn.Conv2d(
            inp, oup, kernel_size, stride, kernel_size // 2, groups=inp, bias=False
        ),
        nn.BatchNorm2d(oup),
        nn.ReLU(inplace=True) if relu else nn.Sequential(),
    )
 
 
class GhostModule(nn.Module):
    """
    Ghost
    """
    def __init__(
        self, inp, oup, kernel_size=1, ratio=2, dw_size=3, stride=1, relu=True
    ):
        super(GhostModule, self).__init__()
        self.oup = oup
        init_channels = math.ceil(oup / ratio)
        new_channels = init_channels * (ratio - 1)
 
        self.primary_conv = nn.Sequential(
            nn.Conv2d(
                inp, init_channels, kernel_size, stride, kernel_size // 2, bias=False
            ),
            nn.BatchNorm2d(init_channels),
            nn.ReLU(inplace=True) if relu else nn.Sequential(),
        )
 
        self.cheap_operation = nn.Sequential(
            nn.Conv2d(
                init_channels,
                new_channels,
                dw_size,
                1,
                dw_size // 2,
                groups=init_channels,
                bias=False,
            ),
            nn.BatchNorm2d(new_channels),
            nn.ReLU(inplace=True) if relu else nn.Sequential(),
        )
 
    def forward(self, x):
        x1 = self.primary_conv(x)
        x2 = self.cheap_operation(x1)
        out = torch.cat([x1, x2], dim=1)
        return out[:, : self.oup, :, :]
 
 
class GhostBottleneck(nn.Module):
    """
    GhostBottleneck
    """
    def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se):
        super(GhostBottleneck, self).__init__()
        assert stride in [1, 2]
        self.conv = nn.Sequential(
            GhostModule(inp, hidden_dim, kernel_size=1, relu=True),
            depthwise_conv(hidden_dim, hidden_dim, kernel_size, stride, relu=False)
            if stride == 2
            else nn.Sequential(),
            SELayer(hidden_dim) if use_se else nn.Sequential(),
            GhostModule(hidden_dim, oup, kernel_size=1, relu=False),
        )
        if stride == 1 and inp == oup:
            self.shortcut = nn.Sequential()
        else:
            self.shortcut = nn.Sequential(
                depthwise_conv(inp, inp, 3, stride, relu=True),
                nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
                nn.BatchNorm2d(oup),
            )
 
    def forward(self, x):
        return self.conv(x) + self.shortcut(x)
 
 
class GhostNet(nn.Module):
    """
    GhostNet
    """
    def __init__(self, cfgs, num_classes=1000, width_mult=1.0):
        super(GhostNet, self).__init__()
        self.cfgs = cfgs
        output_channel = _make_divisible(16 * width_mult, 4)
        layers = [
            nn.Sequential(
                nn.Conv2d(3, output_channel, 3, 2, 1, bias=False),
                nn.BatchNorm2d(output_channel),
                nn.ReLU(inplace=True),
            )
        ]
        input_channel = output_channel
        block = GhostBottleneck
        for k, exp_size, c, use_se, s in self.cfgs:
            output_channel = _make_divisible(c * width_mult, 4)
            hidden_channel = _make_divisible(exp_size * width_mult, 4)
            layers.append(
                block(input_channel, hidden_channel, output_channel, k, s, use_se)
            )
            input_channel = output_channel
        self.features = nn.Sequential(*layers)
        output_channel = _make_divisible(exp_size * width_mult, 4)
        self.squeeze = nn.Sequential(
            nn.Conv2d(input_channel, output_channel, 1, 1, 0, bias=False),
            nn.BatchNorm2d(output_channel),
            nn.ReLU(inplace=True),
            nn.AdaptiveAvgPool2d((1, 1)),
        )
        input_channel = output_channel
        output_channel = 1280
        self.classifier = nn.Sequential(
            nn.Linear(input_channel, output_channel, bias=False),
            nn.BatchNorm1d(output_channel),
            nn.ReLU(inplace=True),
            nn.Dropout(0.2),
            nn.Linear(output_channel, num_classes),
        )
        self._initialize_weights()
 
    def forward(self, x, need_fea=False):
        if need_fea:
            features, features_fc = self.forward_features(x, need_fea)
            x = self.classifier(features_fc)
            return features, features_fc, x
        else:
            x = self.forward_features(x)
            x = self.classifier(x)
            return x
 
    def forward_features(self, x, need_fea=False):
        if need_fea:
            input_size = x.size(2)
            scale = [4, 8, 16, 32]
            features = [None, None, None, None]
            for idx, layer in enumerate(self.features):
                x = layer(x)
                if input_size // x.size(2) in scale:
                    features[scale.index(input_size // x.size(2))] = x
            x = self.squeeze(x)
            return features, x.view(x.size(0), -1)
        else:
            x = self.features(x)
            x = self.squeeze(x)
            return x.view(x.size(0), -1)
 
    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
 
    def cam_layer(self):
        return self.features[-1]

可以直接去华为开源仓库里面或者是开源社区其他的项目里面选择自己喜欢的代码实现即可,不需要自己去重头实现,理解应用即可。这里就不再赘述了,很多项目整体已经是比较完善的了。

这里对模型预测结果也进行了簇群可视化,如下所示:

这里类别比较多,显得比较混乱一些,接下来绘制模型的混淆矩阵,如下所示:

训练过程中,loss走势曲线和acc变化曲线如下所示:

这组实验结果是在224x224的标准尺寸下得到的结果。

前面我们讲到过官方原始的数据集其实是32x32的小尺寸数据集,这里我们做了第二组的实验,就是直接使用官方的尺寸来进行模型的开发训练,得到结果详情如下所示:

可以看到:32x32的尺寸图像精度与224x224的尺寸图像差了40%左右的精度,不难分析出图像的原始分辨率对于最终的分类识别效果的影响是巨大的。

混淆矩阵如下:

详细指标的对比结果如下:

224x224尺度图像结果
+------------+-----------+-----------+----------+
| train_loss | test_loss | train_acc | test_acc | 
+------------+-----------+-----------+----------+
|  0.92347   |  1.33351  |  0.97965  | 0.84315  |
+------------+-----------+-----------+----------+


32x32尺度图像结果
+------------+-----------+-----------+----------+
| train_loss | test_loss | train_acc | test_acc |
+------------+-----------+-----------+----------+
|  1.93752   |  2.35085  |  0.64693  | 0.52852  |   
+------------+-----------+-----------+----------+

感兴趣的话也都可以对应实践尝试下!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1685064.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

肯尼亚大坝决堤反思:强化大坝安全监测的必要性

一、背景介绍 近日&#xff0c;肯尼亚发生了一起严重的大坝决堤事件。当地时间4月29日&#xff0c;肯尼亚内罗毕以北的一座大坝决堤&#xff0c;冲毁房屋和车辆。当地官员称&#xff0c;事故遇难人数已升至71人。这起事件再次提醒我们&#xff0c;大坝安全无小事&#xff0c;监…

SpringMVC源码解读[1] -Spring MVC 环境搭建

源码地址: https://github.com/chen-jiacheng/springmvc-quickstart 一、使用 IDEA 创建 Spring MVC 项目 直接创建项目即可 默认项目结构: springmvc-quickstart ├── pom.xml └── src├── main│ ├── java│ │ └── com│ │ └── chenjiache…

微软开发者大会:编程进入自然语言时代、“AI员工”闪亮登场

当地时间周二&#xff0c;美国科技公司微软召开年度Build开发者大会。在CEO纳德拉的带领下&#xff0c;微软各个产品团队再一次展现出惊人的执行力&#xff0c;在发布会上又拿出了接近50个新产品或功能更新。 整场发布会持续了接近两个小时&#xff0c;在这里挑选了一些投资者…

深度学习之基于YoloV5入侵检测系统

欢迎大家点赞、收藏、关注、评论啦 &#xff0c;由于篇幅有限&#xff0c;只展示了部分核心代码。 文章目录 一项目简介 二、功能三、系统四. 总结 一项目简介 一、项目背景 随着信息技术的飞速发展&#xff0c;网络安全问题日益凸显。入侵检测系统&#xff08;IDS&#xff0…

[图解]产品经理创新模式01物流变成信息流

1 00:00:01,570 --> 00:00:04,120 有了现状的业务序列图 2 00:00:04,960 --> 00:00:08,490 我们就来改进我们的业务序列图了 3 00:00:08,580 --> 00:00:11,010 把我们要做的系统放进去&#xff0c;改进它 4 00:00:13,470 --> 00:00:15,260 怎么改进&#xff1f;…

第五节 Starter 的加载全貌

tips&#xff1a;下载源码&#xff0c;再结合本章内容&#xff0c;学习整个加载过程。 上一章&#xff0c;我们理解了 spring.factories 的触发时机&#xff0c;但放在 SpringBoot 的整个加载过程来讲&#xff0c;只能算部分。 而这一章&#xff0c;将从 SpringBoot 的加载全貌…

Day 60 84.柱状图中最大的矩形

柱状图中最大的矩形 给定 n 个非负整数&#xff0c;用来表示柱状图中各个柱子的高度。每个柱子彼此相邻&#xff0c;且宽度为 1 。 求在该柱状图中&#xff0c;能够勾勒出来的矩形的最大面积。 1 < heights.length <10^50 < heights[i] < 10^4 ​ 这道题很明显&…

x264码率控制基础

x264码率控制模型 x264码率控制也是基于率失真模型即,D为失真,R为码率,为拉格朗日因子,当取值较大时,倾向于低码率高失真的情况;当取值较小时,倾向于高码率低失真的情况。由拉格朗日乘数法知, 参考[1], x264采用的是高码率下码率和失真之间的关系

数据结构和算法|排序算法系列(一)|选择排序

首先需要你对排序算法的评价维度和一个理想排序算法应该是什么样的有一个基本的认知&#xff1a; 《Hello算法之排序算法》 主要内容来自&#xff1a;Hello算法11.2 选择排序 选择排序是明显的基于比较的排序。下文开始阐述选择排序的整个算法流程 算法流程 选择排序应该已…

x264 码率控制原理:x264_ratecontrol_start 函数

x264_ratecontrol_start 函数 函数原理 函数功能:编码一帧之前,为当前帧选择一个量化 QP,属于帧级别码率控制;这对于控制视频质量和文件大小至关重要。通过调整QP,编码器可以在保持视频质量的同时,尽可能减小输出文件的大小。函数参数:x264_t *h: 编码器上下文结构体指…

贴片 RS8752XK 封装SOP-8 250MHz,2通道高速运放

传感器信号放大&#xff1a;在传感器应用中&#xff0c;RS8752XK可以用于放大微弱的传感信号&#xff0c;如压力、温度、光强等传感器的信号。 数据采集系统&#xff1a;在数据采集设备中&#xff0c;RS8752XK可以用于放大和调理模拟信号&#xff0c;以供模数转换器&#xff0…

abs(-2147483648) == 2147483648?

从数学意义上&#xff0c;这是对的。但是&#xff0c;就怕但是。 #include int main() {long long v;v abs(-2147483648);printf("%lld\n", v);return 0; } 输出: -2147483648 我们从source code中一一解开. /* Return the absolute value of I. */ int abs (…

Mist-开源macOS系统版本安装包管理工具

Mist 用于下载 macOS 系统安装包的工具&#xff0c;可下载macOS 固件 / 安装程序。 需要经常下载macOS的可以体验一下。 可以在底部选择显示 macOS 的 Beta 版本 筛选出与当前 Mac 兼容的 macOS 版本 想了解更多可访问项目地址&#xff1a; https://github.com/ninxsoft/Mis…

一文了解微服务

微服务架构是一种将应用程序划分为一组小型、独立的服务的方法&#xff0c;这些服务运行在自己的进程中&#xff0c;通常通过网络进行通信。微服务架构的主要优点是可以提高应用程序的灵活性和可扩展性&#xff0c;同时也使得开发、部署和维护更加容易。本文将介绍微服务架构的…

Redis实践—全国地址信息缓存

一、背景 在涉及全国地址的应用中&#xff0c;地址信息通常被频繁地查询和使用&#xff0c;例如电商平台、物流系统等。为了提高系统性能和减少对数据库的访问压力&#xff0c;可以使用缓存来存储常用的地址信息&#xff0c;其中 Redis 是一个非常流行的选择。 本次在一个企业入…

【Text2SQL 经典模型】SQLNet

论文&#xff1a;SQLNet: Generating Structured Queries From Natural Language Without Reinforcement Learning ⭐⭐⭐⭐ Code: SQLNet | paperwithcodeSQLNet| GitHub 一、论文速读 这篇论文强调了一个问题&#xff1a;order-matters problem —— 意思是说&#xff0c;对…

【机器学习】—机器学习和NLP预训练模型探索之旅

目录 一.预训练模型的基本概念 1.BERT模型 2 .GPT模型 二、预训练模型的应用 1.文本分类 使用BERT进行文本分类 2. 问答系统 使用BERT进行问答 三、预训练模型的优化 1.模型压缩 1.1 剪枝 权重剪枝 2.模型量化 2.1 定点量化 使用PyTorch进行定点量化 3. 知识蒸馏…

HQL面试题练习 —— 品牌营销活动天数

题目来源&#xff1a;小红书 目录 1 题目2 建表语句3 题解 1 题目 有营销活动记录表&#xff0c;记录了每个品牌每次营销活动的开始日期和营销活动的结束日期&#xff0c;现需要统计出每个品牌的总营销天数。 注意&#xff1a; 1:苹果第一行数据的营销结束日期比第二行数据的营…

系统思考—跳出症状看全局

今年的《系统思考—跳出症状看全局》课程不断进行了迭代优化。通过一个企业的真实案例&#xff0c;我们与学员共同探讨了线性思考与系统思考的区别&#xff0c;并学习了如何从全局角度做出更加明智的决策&#xff0c;一切就绪&#xff0c;期待学员的共创。