基于卷积的图像分类识别(一):AlexNet

news2025/1/11 5:39:42

本专栏介绍基于深度学习进行图像识别的经典和前沿模型,将持续更新,包括不仅限于:AlexNet, ZFNet,VGG,GoogLeNet,ResNet,DenseNet,SENet,MobileNet,ShuffleNet,EifficientNet,Vision Transformer,Swin Transformer,Visual Attention Network,ConvNeXt, MLP-Mixer,As-MLP,ConvMixer,MetaFormer


AlexNet 文章目录

  • 前言
  • 一、AlexNet理论
    • 1. 激活函数:ReLU
    • 2. 随机失活:Dropout
    • 3. 数据扩充:Data augmentation
    • 4. 多GPU实现 : Distributed training
    • 5. 局部响应归一化 : LRN
  • 二、 AlexNet代码
    • 2.1 Introduction
    • 2.2 Dataset And Project
    • 2.3 基于pytorch的模型搭建代码
    • 2.4 基于pytorch的模型训练代码
    • 2.5 基于pytorch的模型推理代码
  • 小结


前言

2012年,Alex Krizhevsky、Ilya Sutskever在多伦多大学Geoff Hinton带领的实验室设计出了一个深层的卷积神经网络,即AlexNet。该网络在2012年的ImageNet LSVRC比赛中获得冠军,准确率远超第二名(错误率为15.3%,第二名为26.2%),引起了巨大轰动。AlexNet模型可以说是一个具有历史意义的网络结构,在此之前,深度学习已经沉寂了将近20年。自2012年AlexNet问世以来,后续的ImageNet冠军都是通过使用卷积神经网络(CNN)获得的,并且网络结构也越来越深,使得CNN成为计算机视觉领域的核心算法模型。在未来的20年中,CNN在计算机视觉领域的地位始终是统治性的,可以说AlexNet引发了深度学习的大爆发。
由于Alex Krizhevsky团队并没有为自己的网络命名,后人为了方便将这个网络模型称为AlexNet。同学们如果不想让别人随意给自己的网络取名字,在写论文时应该为自己的网络取个名字。


论文名称:Imagenet classification with deep convolutional neural networks
论文下载链接:https://proceedings.neurips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdf
pytorch代码实现:https://github.com/Arwin-Yu/Deep-Learning-Classification-Models-Based-CNN-or-Attention
创作不易,引用或转载请标明出处。

一、AlexNet理论

AlexNet其实跟LeNet很像很像(LeNet传送门),几乎可以说是LeNet的升级版,都是有卷积和全连接组成。AlexNet之所以能够成功,跟这个模型设计的特点有关,主要有:

  • 使用了非线性激活函数:ReLU
  • 随机失活:Dropout
  • 数据扩充:Data augmentation
  • 其他:多GPU实现,LRN归一化层的使用

1. 激活函数:ReLU

传统的神经网络普遍使用Sigmoid或者tanh等非线性函数作为激励函数,然而它们容易出现梯度弥散或梯度饱和的情况。以Sigmoid函数为例,如下图所示,当输入的值非常大或者非常小的时候,值域的变化范围非常小,使得这些神经元的梯度值接近于0(梯度饱和现象)。由于神经网络的计算本质上是矩阵的连乘,一些近乎于0的值在连乘计算中会越来越小,导致网络训练中梯度更新的弥散现象,即梯度消失。

但是relu不存在这个缺陷,它在第一象限近似函数:y=x,不会出现值域变化小的问题。relu函数直到现在也是学术界和工业界公认的最好用的激活函数之一,在各个不同领域不同模型下的使用非常之多。

relu & sigmoid

其实,对于relu函数的设计思想我们可以寻求一个生物学解释,大家回忆一下初中的一个生物实验:生物学家们用电流刺激青蛙的大腿肌肉,当电流强度不够强时,肌肉组织不反应(即relu函数在x<0时,输出恒等于0的表现);当电流强度到达一定的阈值,肌肉组织开始抽搐,且电流强度越大,抽搐反应越强(即relu函数在x>0时,输出为y=x的表现)。本质上,这是一种非线性的体现

2. 随机失活:Dropout

引入Dropout主要是为了防止网络在训练过程中出现的过拟合现象。过拟合现象出现的原因有两方面:1.数据集太小。 2.模型太复杂。至于产生过拟合的原因我们可以类别生活中的一个场景去解释:

高三的时候,老师出了一套题库给大家做联系,并说期末考试的题就是从题库中抽出来的。但是,这个题库的题量非常少,且都是选择题,那么这时候想要期末考高分的最快捷方法是什么呢?其实并不是把每道题都理解,都学会,而是单纯的背答案!

所以模型也是一样的,当数据太小时,模型就不会去学习数据中的相关性,不会尝试去理解数据,提取特征。最便捷的一种方式是把数据集中的所有数据强行记忆下来,这就叫过拟合。可以想象,一个过拟合的模型是没有举一反三的能力的,即对数据的泛化能力太差,只能对训练数据集中的数据做很好的处理,一旦换一批新的类似数据,模型的处理能力会很差。

那如何解决呢?两个方案:1.提升数据集容量,让模型难以记忆所有的数据,这时候它就会尝试学习数据,理解数据了,因为相较于记忆所有数据,这是种更容易的解决方案。 2.把模型变的简单些,我们想:之所以高三的学生会选择背答案,其实是因为高三的学生比较聪明,如果换个小学生来,他八成是想不到背答案的。因此模型也是一样的,模型会选择记忆数据一方面是因为模型太复杂,他有能力去记忆所有数据。当我们降低模型的复杂度时,他就不会出现过拟合现象。总之,过拟合的本质是数据集与模型在复杂度上不匹配。

在神经网络中Dropout是通过降低模型复杂度来防止过拟合现象的,对于某一层的神经元,通过一定的概率将某些神经元的计算结果乘0,这个神经元就不参与前向和后向传播,就如同在网络中被删除了一样,同时保持输入层与输出层神经元的个数不变,然后按照神经网络的学习方法进行参数更新。在下一次迭代中,又重新随机删除一些神经元(置为0),直至训练结束。

dropout

3. 数据扩充:Data augmentation

由于神经网络算法是基于数据驱动的,因此,有一种观点认为神经网络是靠数据喂出来的,如果能够增加训练数据,提供海量数据进行训练,则能够有效提升算法的准确率,因为这样可以避免过拟合,从而可以进一步增大、加深网络结构。而当训练数据有限时,可以通过一些变换从已有的训练数据集中生成一些新的数据,以快速地扩充训练数据。
其中,最简单、通用的图像数据变形的方式:水平翻转图像,从原始图像中随机裁剪、平移变换,颜色、光照变换,如下图所示:

data augumentation

数据增广确实是提升模型的有效手段,而且最近的增广方式也不仅限于这种随即裁剪,也可以使用生成对抗网络进行图像生成来达到图像增广的目的。

4. 多GPU实现 : Distributed training

AlexNet当时使用了GTX580的GPU进行训练,由于单个GTX 580 GPU只有3GB内存,这限制了在其上训练的网络的最大规模,因此他们将模型拆成两部分,分别放进两个GPU硬件中进行训练,在训练过程中会通过交换feature maps进行两个硬件中子网络的信息交流,大大加快了AlexNet的训练速度。当时其实纯属硬件设备限制的无奈之举,但是,现在看来,这种拆成两组的训练方式跟现代的一种卷积变体非常非常类似:组卷积(group convolution)。个人认为,这也AelxNet效果好的一个主要原因,不过作者当时并没有发现,也算是无心插柳柳成荫了。

5. 局部响应归一化 : LRN

全局响应归一化(Local Response Normalization,LRN)技术主要用于提高深度学习训练的准确性。一般来说,LRN是在激活和池化之后进行的一种处理方法。这个归一化技术最早是在AlexNet模型中被提出的。通过实验确实证明它可以提高模型的泛化能力,但是提升的能力有限。后来这种方法逐渐被弃用,有些人甚至认为它是一个“伪命题”,因此备受争议。如今,Batch Normalization已经成为了局部归一化的主流替代方法。

下面简要介绍一下局部归一化的灵感来源:LRN 的基本思想是模拟侧抑制效应,该效应是生物神经系统的一种现象,即一个活跃的神经元会抑制其邻近神经元的活跃度。在 CNN 中,这通常通过在每个小批量样本上沿深度维度进行归一化实现。也就是说,一个特定的神经元的输出将被它的 “邻居” 神经元的活跃度所规范化。

具体地,LRN 层会考虑每个神经元的 n 个相邻神经元,并计算其平方和。然后,原始神经元的激活值将被规范化,即除以一个值,这个值等于(常数 k 加上原始平方和乘以常数 α)的 β 次幂。在这里,k、n、α 和 β 是 LRN 层的超参数。

实验总结:由于LRN模仿生物神经系统的侧抑制机制,对局部神经元的活动创建竞争机制,从而使响应较大的值更大,提高了模型的泛化能力。在ImageNet实验中,深度学习之父Hinton等人使用LRN技术分别提升了模型1.4%和1.2%的准确率。然而,随后的研究并不太认可这项技术,以至于它至今仍然是一个争议性的技术,很少被使用。

二、 AlexNet代码

2.1 Introduction

完整的项目代码详见我的GitHub: 完整代码链接,完整的项目包含了自AelxNet以来经典的深度学习分类模型,大部分模型是基于卷积神经网络的,也有一部分是基于注意力机制的。 在项目目录中,模型的搭建代码在classic_models文件夹中;所有的模型训练代码是共用的,有三个版本:

  • train_sample.py是最简单的实现,必须掌握,以下版本看个人能力和需求。
  • train.py是升级版的实现,具体改进的地方见train.py脚本中的注释。
  • train_distrubuted.py支持多gpu分布式训练。

最后,test.py是推理脚本,用于使用训练好的模型。dataload中是数据集加载代码;utils是封装的功能包,包括学习策略,训练和验证,分布式初始化,可视化等等。建议先学习掌握classic_models,train_sample.py和test.py这三部分。

2.2 Dataset And Project

本项目是使用python语言基于pytorch深度学习框架编写的。

默认的数据集是花朵数据集,此数据集包含五种不同种类的花朵图像,用于训练的图像有3306张,用于验证的图像有364张。下载链接如下:https://pan.baidu.com/s/1EhPMVLOQlLNN55ndrLbh4Q
提取码:7799 。

下载完成后,记得在训练和推理代码中,将数据集加载的路径修改成自己电脑中下载存储的路径。

数据集图像展示如下:

Dataset show

开启模型的训练只需要在IDE中执行train_sample.py脚本即可;或者在终端执行命令行python train_sample.py 训练的log打印示例如下:

training log

将训练好的模型用于推理,给一张向日葵的图像,模型的输出结果示例结果如下:

infer show

2.3 基于pytorch的模型搭建代码

import torch.nn as nn
import torch 

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000, init_weights=False):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),  # input[3, 224, 224]  output[96, 55, 55]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[96, 27, 27]

            nn.Conv2d(96, 256, kernel_size=5, padding=2),           # output[256, 27, 27]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[256, 13, 13]

            nn.Conv2d(256, 384, kernel_size=3, padding=1),          # output[384, 13, 13]
            nn.ReLU(inplace=True),

            nn.Conv2d(384, 384, kernel_size=3, padding=1),          # output[384, 13, 13]
            nn.ReLU(inplace=True),

            nn.Conv2d(384, 256, kernel_size=3, padding=1),          # output[256, 13, 13]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[256, 6, 6]
        )
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),

            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            
            nn.Linear(4096, num_classes),
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        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):
                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):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)

def alexnet(num_classes): 
    model = AlexNet(num_classes=num_classes)
    return model

    

2.4 基于pytorch的模型训练代码

完整的项目代码详见我的GitHub: 完整代码链接

import os 
import sys
import json 
import torch
import torch.nn as nn
from torchvision import transforms, datasets 
import torch.optim as optim 
from tqdm import tqdm  
from classic_models.alexnet import AlexNet
 
def main():
    # 判断可用设备
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print("using {} device.".format(device))

    # 注意改成自己的数据集路径
    data_path = 'D:\\Datasets\\flower'
    assert os.path.exists(data_path), "{} path does not exist.".format(data_path) 

    # 数据预处理与增强
    """ 
    ToTensor()能够把灰度范围从0-255变换到0-1之间的张量.
    transform.Normalize()则把0-1变换到(-1,1). 具体地说, 对每个通道而言, Normalize执行以下操作: image=(image-mean)/std
    其中mean和std分别通过(0.5,0.5,0.5)和(0.5,0.5,0.5)进行指定。原来的0-1最小值0则变成(0-0.5)/0.5=-1; 而最大值1则变成(1-0.5)/0.5=1. 
    也就是一个均值为0, 方差为1的正态分布. 这样的数据输入格式可以使神经网络更快收敛。
    """
    data_transform = {
        "train": transforms.Compose([transforms.Resize(224),
                                     transforms.CenterCrop(224),
                                     transforms.ToTensor(),
                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),

        "val": transforms.Compose([transforms.Resize((224, 224)),  # val不需要任何数据增强
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}


    # 使用ImageFlolder加载数据集中的图像,并使用指定的预处理操作来处理图像, ImageFlolder会同时返回图像和对应的标签。 (image path, class_index) tuples
    train_dataset = datasets.ImageFolder(root=os.path.join(data_path, "train"), transform=data_transform["train"])
    validate_dataset = datasets.ImageFolder(root=os.path.join(data_path, "val"), transform=data_transform["val"])
    train_num = len(train_dataset)
    val_num = len(validate_dataset)

    # 使用class_to_idx给类别一个index,作为训练时的标签: {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    flower_list = train_dataset.class_to_idx
    # 创建一个字典,存储index和类别的对应关系,在模型推理阶段会用到。
    cla_dict = dict((val, key) for key, val in flower_list.items())
    # 将字典写成一个json文件
    json_str = json.dumps(cla_dict, indent=4)
    with open( os.path.join(data_path, 'class_indices.json') , 'w') as json_file:
        json_file.write(json_str)

    batch_size = 64 # batch_size大小,是超参,可调,如果模型跑不起来,尝试调小batch_size
    num_workers = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # 用于加载数据集的进程数量
    print('Using {} dataloader workers every process'.format(num_workers))

    # 使用 DataLoader 将 ImageFloder 加载的数据集处理成批量(batch)加载模式
    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=4, shuffle=False,  num_workers=num_workers) # 注意,验证集不需要shuffle
    print("using {} images for training, {} images for validation.".format(train_num, val_num))
    
    # 实例化模型,并送进设备
    net = AlexNet(num_classes=5, init_weights=True)
    net.to(device)

    # 指定损失函数用于计算损失;指定优化器用于更新模型参数;指定训练迭代的轮数,训练权重的存储地址
    loss_function = nn.CrossEntropyLoss() 
    optimizer = optim.Adam(net.parameters(), lr=0.0002)
    epochs = 70
    save_path = os.path.abspath(os.path.join(os.getcwd(), './results/weights/alexnet')) 
    if not os.path.exists(save_path):    
        os.makedirs(save_path)

    best_acc = 0.0 # 初始化验证集上最好的准确率,以便后面用该指标筛选模型最优参数。  
    for epoch in range(epochs):
        ############################################################## train ######################################################
        net.train() 
        acc_num = torch.zeros(1).to(device)    # 初始化,用于计算训练过程中预测正确的数量
        sample_num = 0                         # 初始化,用于记录当前迭代中,已经计算了多少个样本
        # tqdm是一个进度条显示器,可以在终端打印出现在的训练进度
        train_bar = tqdm(train_loader, file=sys.stdout, ncols=100)
        for step, data in enumerate(train_bar):
            images, labels = data
            sample_num += images.shape[0]
            optimizer.zero_grad()
            outputs = net(images.to(device)) # output_shape: [batch_size, num_classes]
            pred_class = torch.max(outputs, dim=1)[1] # torch.max 返回值是一个tuple,第一个元素是max值,第二个元素是max值的索引。
            acc_num += torch.eq(pred_class, labels.to(device)).sum()

            loss = loss_function(outputs, labels.to(device)) # 求损失
            loss.backward() # 自动求导
            optimizer.step() # 梯度下降

            # print statistics 
            train_acc = acc_num.item() / sample_num 
            # .desc是进度条tqdm中的成员变量,作用是描述信息
            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,  epochs, loss)

        # validate
        net.eval()
        acc_num = 0.0  # accumulate accurate number per epoch
        with torch.no_grad(): 
            for val_data in validate_loader:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))
                predict_y = torch.max(outputs, dim=1)[1]
                acc_num += torch.eq(predict_y, val_labels.to(device)).sum().item() 

        val_accurate = acc_num / val_num
        print('[epoch %d] train_loss: %.3f  train_acc: %.3f  val_accuracy: %.3f' %  (epoch + 1, loss, train_acc, val_accurate))   
        # 判断当前验证集的准确率是否是最大的,如果是,则更新之前保存的权重
        if val_accurate > best_acc:
            best_acc = val_accurate
            torch.save(net.state_dict(), os.path.join(save_path, "AlexNet.pth") )

        # 每次迭代后清空这些指标,重新计算 
        train_acc = 0.0
        val_accurate = 0.0

    print('Finished Training')


if __name__ == '__main__':
    main()

2.5 基于pytorch的模型推理代码

import os
import json

import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt
# 将创建AlexNet模型的python脚本导入进来
from classic_models.alexnet import AlexNet 

def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    data_transform = transforms.Compose(
        [transforms.Resize((224, 224)),
         transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    # 加载一种图片用于推理
    img_path = "/data/haowen_yu/code/dataset/flowers/val/daisy/3640845041_80a92c4205_n.jpg"
    assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    img = Image.open(img_path)

    plt.imshow(img)
    # [N, C, H, W]
    img = data_transform(img)
    # 扩张一个batch维度,因为训练模型时使用的小批量随机梯度下降有batch维度,所以推理时也需要有
    img = torch.unsqueeze(img, dim=0)

    # 加载模型预测值与真实类别的对应关系,json文件详见我的github代码
    json_path = '/data/haowen_yu/code/dataset/flowers/class_indices.json'
    assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)

    json_file = open(json_path, "r")
    class_indict = json.load(json_file)

    # 实例化模型
    model = AlexNet(num_classes=5).to(device)

    # 加载模型的权重
    weights_path = "/data/haowen_yu/code/results/weights/alexnet/AlexNet.pth"
    assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    model.load_state_dict(torch.load(weights_path))

    model.eval()
    with torch.no_grad():
        output = torch.squeeze(model(img.to(device))).cpu()
        predict = torch.softmax(output, dim=0)
        # 取分类可能性最大的类别作为模型的识别结果
        predict_cla = torch.argmax(predict).numpy()

    # 以图片的方式输出识别结果
    print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)], predict[predict_cla].numpy())
    plt.title(print_res)
    for i in range(len(predict)):
        print("class: {:10}   prob: {:.3}".format(class_indict[str(i)], predict[i].numpy()))
    plt.show()


if __name__ == '__main__':
    main()

小结

AlexNet模型是一个开创性的卷积神经网络模型,该模型在ImageNet图像分类竞赛中获得了显著的优势,引起了深度学习技术的广泛关注,开启了人工智能的第三次浪潮:深度学习时代。
AlexNet模型共包含8层,其中前5层为卷积层(Convolutional Layer),后3层为全连接层(Fully Connected Layer)。在卷积层中,AlexNet采用了大量的卷积核(Filter),并且使用ReLU作为激活函数,可以加速网络的训练过程并提高分类准确率。此外,AlexNet在全连接层中使用了Dropout技术,可以有效减少过拟合现象。
另外,AlexNet采用还采用了如数据增强、局部响应归一化、并行计算等先进技术,使得其在当时的图像分类竞赛中表现出色。
总的来说,AlexNet为深度学习技术在计算机视觉领域的应用奠定了重要基础,并对深度学习的发展产生了深远的影响。

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

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

相关文章

机器学习中的监督学习、无监督学习、半监督学习和强化学习,这四种学习方式到底有啥区别?

监督学习、无监督学习、半监督学习和强化学习 人工智能中的机器学习是指让计算机通过学习数据的方式改善性能。在机器学习中&#xff0c;有四种主要的学习方式&#xff1a;监督学习、无监督学习、半监督学习和强化学习。本文将详细介绍这四种学习方式的概念、应用和优缺点。 …

[GXYCTF2019]BabyUpload1

上传文件后提示后缀名不能有ph 那估计都是黑名单过滤&#xff0c;大小写绕过也不行&#xff0c;尝试一下上传.htaccess文件 将文件名称为abc的当做php文件执行 上传后提示上传类型露骨&#xff0c;说明绕过了黑名单但是还有content_type类型坐镇 那就利用burp抓包修改content—…

msvcp140.dll丢失怎样修复,总结4个msvcp140.dll丢失的修复方法

今天早上打开photoshop的时候&#xff0c;电脑突然提示由于找不到msvcp140.dll&#xff0c;无法继续执行此代码&#xff0c;一时间都懵了&#xff0c;不知道怎么处理。在网上找了一上午的资料及修复方法&#xff0c;MSVCP140.dll是一个非常重要的Windows系统文件&#xff0c;它…

win10 平台搭建react native 并在 Android模拟器上运行app

目录 1 安装npm 1.1 nodejs官网下载 安装程序&#xff0c;双击安装&#xff0c;一路点“是"即可 1.2 增加三个环境变量 NODE_PATH NVM_HOME NVM_SYMLINK 1.3 在PATH中增加 %NVM_HOME% %NVM_SYMLINK% 2 安装yarn 3 安装java 11.0.2 3.1 安装…

Unity 矩阵简介

前言&#xff1a;与向量一样&#xff0c;矩阵也是3D数学的基础。要正确进行物体的位移、旋转和缩放变换&#xff0c;就必须要用到矩阵。 3D游戏中的向量一般只有3个维度&#xff0c;但矩阵要使用44矩阵&#xff0c;主要原因你是要用矩阵实现平移&#xff0c;33矩阵是不够的。4…

C++类和对象下

专栏&#xff1a;C/C 个人主页&#xff1a;HaiFan. 专栏简介&#xff1a;本章为大家带来C类和对象相关内容。 类和对象下 类的默认成员函数构造函数析构函数拷贝构造函数运算符重载 const成员再谈构造函数构造函数体赋值初始值列表 explicit关键字static成员友元内部类匿名对象…

【MySQL】表的操作

目录 一.使用Cmd命令执行操作 1.使用&#xff08;mysql -uroot -p)命令进入数据库 2.创建一个角色表用于操作&#xff08;创建表之前先使用数据库&#xff09; 3.查看表 4.插入数据 5.查看表中内容 6.修改表 1.修改表名 2.修改字段名 3.修改字段的数据类型 ALTER TABL…

Vue3-黑马(十一)

目录&#xff1a; &#xff08;1&#xff09;vue3-router-布局和菜单 &#xff08;2&#xff09;vue3-进阶-router-图标二次封装-单文件组件 &#xff08;3&#xff09;vue3-进阶-router-图标的二次封装-函数式组件 &#xff08;1&#xff09;vue3-router-布局和菜单 主页做…

收藏:如何一步步成为技术领域专家

经常有人问我&#xff0c;为什么有的人工作10年仍然平台无奇&#xff0c;而有的人只用3年时间&#xff0c;就已经脱颖而出&#xff0c;成绩斐然。我说&#xff0c;是呀&#xff0c;有些参加工作多年却仍然只会复制粘贴简单业务代码&#xff0c;有些人在大学就写出Linux操作系统…

英文论文(sci)解读复现【NO.9】基于注意机制的葡萄叶片病害检测

此前出了目标检测算法改进专栏&#xff0c;但是对于应用于什么场景&#xff0c;需要什么改进方法对应与自己的应用场景有效果&#xff0c;并且多少改进点能发什么水平的文章&#xff0c;为解决大家的困惑&#xff0c;此系列文章旨在给大家解读发表高水平学术期刊中的 SCI论文&a…

(免费分享)基于微信小程序的旅游系统(带文档)

随着互联网的趋势的到来&#xff0c;各行各业都在考虑利用互联网将自己的信息推广出去&#xff0c;最好方式就是建立自己的平台信息&#xff0c;并对其进行管理&#xff0c;随着现在智能手机的普及&#xff0c;人们对于智能手机里面的应用旅游服务软件也在不断的使用&#xff0…

vue-8:Vuex状态管理模式库 + map辅助函数简写

为什么存&#xff1a;存仓库的多组件可以数据共享 核心api this.$store 每个组件都可以获取$store this.$store.commit("同步方法名", 参数) 调用同步方法&#xff0c;修改store中的数据 this.$store.dispatch("异步方法名", 参数) 调用异步方法&#x…

分布式数据库集成解决方案

分布式数据库集成解决方案 分析访问部署扩展.1 以界面方式创建数据库&#xff08;采用DBCA&#xff09; # 背景 由于公司业务的发展&#xff0c;要求在其它三个城市设立货仓&#xff0c;处理发货业务。公司本部运行着一套用Sybase数据库的MIS系统可以实现发货&#xff0c;该系统…

【多线程】线程池

目录 线程池是什么 标准库中的线程池 描述线程池工作原理 为什么不推荐使用系统自带的线程池 实现线程池 线程池是什么 线程池就是在池子里放的线程本身&#xff0c;当程序启动时就创建出若干个线程&#xff0c;如果有任务就处理&#xff0c;没有任务就阻塞等待。 想象这…

hive集成hbase Bytes.toByte处理字段 隐射为null乱码 加#b为0问题

解决hive集成hbase Bytes.toByte处理字段 隐射为null乱码 为0问题 错误例子&#xff08;一&#xff09; create external table bigdata_student(id string,name string,age int )stored by org.apache.hadoop.hive.hbase.HBaseStorageHandler with SERDEPROPERTIES ("h…

内网渗透(七十二)之域权限维持之伪造域控

伪造域控 2022年1月10日,国外安全研究员Kaido发文称发现了一种新的伪造域控方式,安全研究员只需要新建一个机器账户,然后修改机器账户的UserAccountControl属性为8192。活动目录就会认为这个机器账户就是域控,然后就可以使用这个新建的机器账户进行DCSync操作了。由于修改…

系统开发与运行

系统开发与运行 系统分析与设计 需求分析 需求工程 结构化分析与设计 测试基础知识 系统运行与维护 软件架构介绍 系统分析概述 系统分析是一种问题求解技术&#xff0c;它将一个系统分解成各个组成部分&#xff0c; 目的是研究各个部分如何工作、交互,以实现其系统目标…

Android系统启动全流程分析

当我们买了一个手机或者平板&#xff0c;按下电源键的那一刻&#xff0c;到进入Launcher&#xff0c;选择我们想要使用的某个App进入&#xff0c;这个过程中&#xff0c;系统到底在做了什么事&#xff0c;伙伴们有仔细的研究过吗&#xff1f;可能对于Framework这块晦涩难懂的专…

数据流畅驰骋:探秘Logstash在大数据领域的卓越表现【上进小菜猪大数据系列】

上进小菜猪&#xff0c;沈工大软件工程专业&#xff0c;爱好敲代码&#xff0c;持续输出干货。 摘要&#xff1a;Logstash是大数据领域中常用的数据处理引擎&#xff0c;能够高效地采集、转换和输出数据。本文将深入介绍Logstash的基本概念、工作原理和常见应用场景&#xff0…

科学计算库-Pandas随笔【及网络隐私的方法与策略闲谈】

文章目录 8.2、pandas8.2.1、为什么用 pandas &#xff1f;8.2.2、pandas Series 类型8.2.3、pandas 自定义索引8.2.4、pandas 如何判断数据缺失&#xff1f;8.2.5、pandas DataFrame 类型8.2.6、pandas 筛选8.2.7、pandas 重新索引8.2.8、pandas 算数运算和数据对齐8.2.9、pan…