​​​​【动手学深度学习】残差网络(ResNet)的研究详情

目录

🌊1. 研究目的

🌊2. 研究准备

🌊3. 研究内容

🌍3.1 残差网络

🌍3.2 练习

🌊4. 研究体会


🌊1. 研究目的

  • 了解残差网络(ResNet)的原理和架构;
  • 探究残差网络的优势;
  • 分析残差网络的深度对模型性能的影响;
  • 实践应用残差网络解决实际问题。

🌊2. 研究准备

  • 根据GPU安装pytorch版本实现GPU运行研究代码;
  • 配置环境用来运行 Python、Jupyter Notebook和相关库等相关库。

🌊3. 研究内容

启动jupyter notebook,使用新增的pytorch环境新建ipynb文件,为了检查环境配置是否合理,输入import torch以及torch.cuda.is_available() ,若返回TRUE则说明研究环境配置正确,若返回False但可以正确导入torch则说明pytorch配置成功,但研究运行是在CPU进行的,结果如下:


🌍3.1 残差网络

(1)使用jupyter notebook新增的pytorch环境新建ipynb文件,完成基本数据操作的研究代码与练习结果如下:

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


class Residual(nn.Module):  #@save
    def __init__(self, input_channels, num_channels,
                 use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,
                               kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,
                               kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)

blk = Residual(3,3)
X = torch.rand(4, 3, 6, 6)
Y = blk(X)
Y.shape

blk = Residual(3,6, use_1x1conv=True, strides=2)
blk(X).shape

ResNet模型

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

def resnet_block(input_channels, num_channels, num_residuals,
                 first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels,
                                use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk

b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

net = nn.Sequential(b1, b2, b3, b4, b5,
                    nn.AdaptiveAvgPool2d((1,1)),
                    nn.Flatten(), nn.Linear(512, 10))

X = torch.rand(size=(1, 1, 224, 224))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape:\t', X.shape)

训练模型

lr, num_epochs, batch_size = 0.05, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())


🌍3.2 练习

1.图7.4.1中的Inception块与残差块之间的主要区别是什么?在删除了Inception块中的一些路径之后,它们是如何相互关联的?
Inception块和残差块(Residual block)是两种不同的网络模块,其主要区别在于它们的结构和连接方式。

Inception块是由多个不同大小的卷积核和池化操作组成的,它们在不同的分支中并行进行操作,然后将它们的输出在通道维度上进行拼接。这种设计可以捕捉不同尺度和层次的特征,并且具有较大的感受野,从而提高网络的表达能力。

残差块(Residual block)是通过引入跳跃连接(skip connection)来解决梯度消失问题的一种方式。在残差块中,输入通过一个或多个卷积层后,与原始输入进行相加操作。这种设计允许信息在网络中直接跳过一些层级,使得网络能够更容易地学习残差(原始输入与输出之间的差异),从而加速训练和改善模型的收敛性。

当从Inception块中删除一些路径时,它们仍然与其他路径相互关联。删除路径后,剩下的路径仍然可以在Inception块中共享信息,并通过拼接或连接操作将它们的输出合并起来。这样可以减少模型的计算复杂度和参数量,并且有助于防止过拟合。

在残差网络(ResNet)中,每个残差块通过跳跃连接将输入直接添加到输出中,确保了信息的流动。这种结构使得残差网络能够更深地堆叠层级,并且可以训练非常深的神经网络而不会导致梯度消失或退化问题。

2.参考ResNet论文 (He et al., 2016)中的表1,以实现不同的变体。
根据ResNet论文中的表1,我们可以实现ResNet的不同变体,如ResNet-18、ResNet-34、ResNet-50、ResNet-101和ResNet-152。以下是这些变体的具体实现代码:

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


class Residual(nn.Module):
    def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels, kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)


def resnet_block(input_channels, num_channels, num_residuals, first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels, use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk


class ResNet(nn.Module):
    def __init__(self, num_classes, block_sizes):
        super().__init__()
        self.b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                                nn.BatchNorm2d(64),
                                nn.ReLU(),
                                nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

        self.b2 = nn.Sequential(*resnet_block(64, 64, block_sizes[0], first_block=True))
        self.b3 = nn.Sequential(*resnet_block(64, 128, block_sizes[1]))
        self.b4 = nn.Sequential(*resnet_block(128, 256, block_sizes[2]))
        self.b5 = nn.Sequential(*resnet_block(256, 512, block_sizes[3]))

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.flatten = nn.Flatten()
        self.fc = nn.Linear(512, num_classes)

    def forward(self, X):
        X = self.b1(X)
        X = self.b2(X)
        X = self.b3(X)
        X = self.b4(X)
        X = self.b5(X)
        X = self.avgpool(X)
        X = self.flatten(X)
        X = self.fc(X)
        return X


def resnet18(num_classes):
    return ResNet(num_classes, [2, 2, 2, 2])


def resnet34(num_classes):
    return ResNet(num_classes, [3, 4, 6, 3])


def resnet50(num_classes):
    return ResNet(num_classes, [3, 4, 6, 3])


def resnet101(num_classes):
    return ResNet(num_classes, [3, 4, 23, 3])

# Usage example
num_classes = 10  # Number of output classes
net = resnet18(num_classes)  # Choose the ResNet variant

# Training
lr, num_epochs, batch_size = 0.1, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

3.对于更深层次的网络,ResNet引入了“bottleneck”架构来降低模型复杂性。请试着去实现它。
ResNet引入了“bottleneck”架构。在这个架构中,每个残差块由一个1x1卷积层、一个3x3卷积层和一个1x1卷积层组成,其中1x1卷积层用于减少维度和恢复维度。这样可以显著减少参数数量和计算量。

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


class Bottleneck(nn.Module):
    def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=1)
        self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3, padding=1, stride=strides)
        self.conv3 = nn.Conv2d(num_channels, num_channels * 4, kernel_size=1)
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)
        self.bn3 = nn.BatchNorm2d(num_channels * 4)
        if use_1x1conv:
            self.conv4 = nn.Conv2d(input_channels, num_channels * 4, kernel_size=1, stride=strides)
        else:
            self.conv4 = None

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = F.relu(self.bn2(self.conv2(Y)))
        Y = self.bn3(self.conv3(Y))
        if self.conv4:
            X = self.conv4(X)
        Y += X
        return F.relu(Y)


def bottleneck_block(input_channels, num_channels, num_residuals, first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Bottleneck(input_channels, num_channels, use_1x1conv=True, strides=2))
        else:
            blk.append(Bottleneck(num_channels * 4, num_channels))
    return blk


class ResNet(nn.Module):
    def __init__(self, num_classes, block_sizes):
        super().__init__()
        self.b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                                nn.BatchNorm2d(64),
                                nn.ReLU(),
                                nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

        self.b2 = nn.Sequential(*bottleneck_block(64, 64, block_sizes[0], first_block=True))
        self.b3 = nn.Sequential(*bottleneck_block(256, 128, block_sizes[1]))
        self.b4 = nn.Sequential(*bottleneck_block(512, 256, block_sizes[2]))
        self.b5 = nn.Sequential(*bottleneck_block(1024, 512, block_sizes[3]))

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

    def forward(self, X):
        X = self.b1(X)
        X = self.b2(X)
        X = self.b3(X)
        X = self.b4(X)
        X = self.b5(X)
        X = self.avgpool(X)
        X = self.flatten(X)
        X = self.fc(X)
        return X


def resnet50(num_classes):
    return ResNet(num_classes, [3, 4, 6, 3])


def resnet101(num_classes):
    return ResNet(num_classes, [3, 4, 23, 3])


def resnet152(num_classes):
    return ResNet(num_classes, [3, 8, 36, 3])


# Usage example
num_classes = 10  # Number of output classes
net = resnet50(num_classes)  # Choose the ResNet variant

# Training
lr, num_epochs, batch_size = 0.1, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

4.在ResNet的后续版本中,作者将“卷积层、批量规范化层和激活层”架构更改为“批量规范化层、激活层和卷积层”架构。请尝试做这个改进。详见 (He et al., 2016)中的图1
在ResNet的后续版本中,作者将“卷积层、批量规范化层和激活层”架构更改为“批量规范化层、激活层和卷积层”架构。这种改进可以提高训练的稳定性和收敛速度。

以下是将ResNet的层结构改为“批量规范化层、激活层和卷积层”架构的代码实现:

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


class Bottleneck(nn.Module):
    def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1):
        super().__init__()
        self.bn1 = nn.BatchNorm2d(input_channels)
        self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=1)
        self.bn2 = nn.BatchNorm2d(num_channels)
        self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3, padding=1, stride=strides)
        self.bn3 = nn.BatchNorm2d(num_channels)
        self.conv3 = nn.Conv2d(num_channels, num_channels * 4, kernel_size=1)
        if use_1x1conv:
            self.conv4 = nn.Conv2d(input_channels, num_channels * 4, kernel_size=1, stride=strides)
        else:
            self.conv4 = None

    def forward(self, X):
        Y = F.relu(self.bn1(X))
        Y = self.conv1(Y)
        Y = F.relu(self.bn2(Y))
        Y = self.conv2(Y)
        Y = F.relu(self.bn3(Y))
        Y = self.conv3(Y)
        if self.conv4:
            X = self.conv4(X)
        Y += X
        return Y


def bottleneck_block(input_channels, num_channels, num_residuals, first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Bottleneck(input_channels, num_channels, use_1x1conv=True, strides=2))
        else:
            blk.append(Bottleneck(num_channels * 4, num_channels))
    return blk


class ResNet(nn.Module):
    def __init__(self, num_classes, block_sizes):
        super().__init__()
        self.b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                                nn.BatchNorm2d(64),
                                nn.ReLU(),
                                nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

        self.b2 = nn.Sequential(*bottleneck_block(64, 64, block_sizes[0], first_block=True))
        self.b3 = nn.Sequential(*bottleneck_block(256, 128, block_sizes[1]))
        self.b4 = nn.Sequential(*bottleneck_block(512, 256, block_sizes[2]))
        self.b5 = nn.Sequential(*bottleneck_block(1024, 512, block_sizes[3]))

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

    def forward(self, X):
        X = self.b1(X)
        X = self.b2(X)
        X = self.b3(X)
        X = self.b4(X)
        X = self.b5(X)
        X = self.avgpool(X)
        X = self.flatten(X)
        X = self.fc(X)
        return X


def resnet50(num_classes):
    return ResNet(num_classes, [3, 4, 6, 3])


def resnet101(num_classes):
    return ResNet(num_classes, [3, 4, 23, 3])


def resnet152(num_classes):
    return ResNet(num_classes, [3, 8, 36, 3])


# Usage example
num_classes = 10  # Number of output classes
net = resnet50(num_classes)  # Choose the ResNet variant

# Training
lr, num_epochs, batch_size = 0.1, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

5.为什么即使函数类是嵌套的,我们仍然要限制增加函数的复杂性呢?

限制函数的复杂性有几个原因:

  • 可读性和可维护性:随着函数的复杂性增加,函数的代码可能变得冗长、难以理解和难以维护。函数的目标是封装特定的功能,使代码更具可读性和可维护性。如果一个函数过于复杂,它可能会变得难以理解,导致困惑和错误。
  • 可重用性:函数的目标之一是促进代码的重用。通过将代码封装在函数中,可以在不同的上下文中多次使用。然而,当函数变得过于复杂时,其可重用性可能会下降。复杂的函数可能包含过多的逻辑和依赖关系,使其难以在其他上下文中重用。
  • 可测试性:函数的复杂性会增加测试的难度。当函数包含大量的逻辑和依赖关系时,编写相应的测试用例和确保代码的正确性变得更加困难。通过限制函数的复杂性,可以使函数更容易进行单元测试,并提高代码的可靠性。


🌊4. 研究体会

在本次实验中,我对残差网络(ResNet)进行了深入研究和实践。通过这个实验,我对残差网络的原理、优势以及深度对模型性能的影响有了更深入的理解。

首先,对残差网络的原理和架构有了清晰的认识。残差网络通过引入跳跃连接和残差块的方式解决了深度神经网络中的梯度消失和梯度爆炸问题。跳跃连接允许信息直接传递到后续层,使得网络可以学习残差映射,从而更好地优化模型。残差块的设计也使得网络可以学习到非线性映射,提高了模型的表达能力。

其次,深入探究了残差网络的优势。相比传统的卷积神经网络,残差网络具有更深的网络结构,可以利用更多的层次特征来提取和表达数据的复杂特征。这使得残差网络在处理大规模数据集和复杂任务时表现出更强的性能。此外,我还观察到残差网络在训练过程中具有更快的收敛速度,这是由于跳跃连接的存在减少了梯度传播的路径长度,加速了模型的训练过程。

在实验中,对残差网络的深度对模型性能的影响进行了分析。通过调整网络的深度,我发现随着网络深度的增加,模型的性能在一定程度上得到了提升。然而,当网络过深时,出现了退化问题,即模型的性能开始下降。这表明在构建残差网络时,需要适当平衡网络的深度和性能之间的关系,避免过深的网络导致性能下降。

最后,在实践中应用残差网络解决实际问题的过程中,深刻体会到了残差网络的强大能力。将残差网络应用于图像分类任务,发现相比传统网络,残差网络在处理复杂图像数据时具有更好的分类性能。此外,我还尝试了在目标检测和语音识别等领域应用残差网络,也取得了较好的效果。这进一步加深了我对残差网络的理解,并使我对深度学习的实际应用能力有了更深入的认识。

在实验中,我也遇到了一些困难。首先是网络的训练时间较长,尤其是在增加网络深度的情况下。为了节省时间,我尝试了使用预训练模型和批量归一化等技术,以加快训练速度并提高模型的性能。其次,调整网络深度时需要进行多次实验和分析,以找到最佳的深度配置。这要求我具备耐心和细致的科研态度,不断地进行试验和调整。

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【Vue】声明式导航-导航链接

文章目录 一、引入二、解决方案三、代码示例四、声明式导航-两个类名1)router-link-active2)router-link-exact-active 一、引入 但凡说到声明式导航,都需要想到router-link 需求 实现导航高亮效果 如果使用a标签进行跳转的话,需要…

JSONPath使用指南(掌握JSON数据提取)

大家好,在处理 JSON(JavaScript Object Notation)数据时,有时需要从复杂的结构中提取特定部分。JSONPath 就是一个非常有用的工具,它提供了一种简洁而强大的方式来定位和提取 JSON 数据中的元素。无论是在 Web 开发中处…

【C++ | 析构函数】类的析构函数详解

😁博客主页😁:🚀https://blog.csdn.net/wkd_007🚀 🤑博客内容🤑:🍭嵌入式开发、Linux、C语言、C、数据结构、音视频🍭 ⏰发布时间⏰:2024-06-06 1…

上海亚商投顾:微盘股指数大跌超6% 全市场仅500余只个股上涨

上海亚商投顾前言:无惧大盘涨跌,解密龙虎榜资金,跟踪一线游资和机构资金动向,识别短期热点和强势个股。 一.市场情绪 沪指昨日震荡调整,创业板指午后一度跌超1%,微盘股指数盘中跌逾7%,小市值个…

YOLO系列模型 pt文件转化为ONNX导出

文章目录 啥是onnx怎么导出导出之后 啥是onnx Microsoft 和合作伙伴社区创建了 ONNX 作为表示机器学习模型的开放标准。许多框架(包括 TensorFlow、PyTorch、scikit-learn、Keras、Chainer、MXNet 和 MATLAB)的模型都可以导出或转换为标准 ONNX 格式。 在…

09.0手工制作docker镜像-单服务ssh

手动将容器保存为镜像-单服务ssh 本页测试内容,将centos6.9镜像安装ssh服务并提交新的镜像并可使用。 docker commit 容器id或者容器的名字 新的镜像名字[:版本号可选] docker commit test centos6.9-ssh:v11)基于容器制作镜像,首先创建一个…

DP:子序列模型

子数组vs子数列 1、子数组(n^2) 子序列(2^n) 2、子数组是子序列的一个子集 3、子数组必须连续,子序列可以不连续 一、最长递增子序列 . - 力扣(LeetCode) 算法原理: 1、状态表示&#xff…

使用命令给电脑添加虚拟网卡和IP

目录 1、添加网卡 1-1、windows系统添加网卡 1-2、Linux系统中添加网卡 2、添加IP和DNS 2-1、添加IP 2-2、 设置DNS 3、删除网卡 3-1、Windows: 3-2、Linux 3-3、macOS 4、示例: 首先以管理员方式进入CMD命令行; 点击“开始”->“管理员…

HLA高层体系结构1.0.0版本

名:高层体系结构(High Level Architecture,HLA) 高层体系结构(High Level Architecture,HLA)是从体系结构上建立这样一个框架,它能尽量涵盖M&S领域中所涉及的各种不同类型的仿真…

springboot启动配置文件-bootstrap.yml常用基本配置

4.1.5.配置文件 SpringBoot的配置文件支持多环境配置,基于不同环境有不同配置文件: 说明: 文件说明bootstrap.yml通用配置属性,包含服务名、端口、日志等等各环境通用信息bootstrap-dev.yml线上开发环境配置属性,虚…

微服务开发与实战Day01 - MyBatisPlus

一、微服务 概念:微服务是一种软件架构风格,它是以专注于单一职责的很多小型项目为基础,组合除复杂的大型应用。 课程安排: https://www.bilibili.com/video/BV1S142197x7/?spm_id_from333.1007.top_right_bar_window_history.…

41【Aseprite 作图】粉红宫灯——拆解

1 宫灯轮廓 上面三角,下面3 3 3 (粉色在后面,做轮廓),棕色在外面,看做是灯骨(竖着更长);中间是横着做灯骨 尾部的彩带,下面粉色更浅,上面绿色更浅…

LabVIEW飞机发动机测试与故障诊断系统

LabVIEW飞机发动机测试与故障诊断系统 基于LabVIEW开发了一个飞机发动机测试与故障诊断系统,能够实时监测发动机的运行参数,进行数据采集与分析,并提供故障诊断功能。系统采用高精度传感器和数据采集硬件,适用于发动机的性能测试、…

Kaggle——Deep Learning(使用 TensorFlow 和 Keras 为结构化数据构建和训练神经网络)

1.单个神经元 创建一个具有1个线性单元的网络 #线性单元 from tensorflow import keras from tensorflow.keras import layers #创建一个具有1个线性单元的网络 modelkeras.Sequential([layers.Dense(units1,input_shape[3]) ]) 2.深度神经网络 构建序列模型 #构建序列模型 …

在k8s中部署Logstash多节点示例(超详细讲解)

🐇明明跟你说过:个人主页 🏅个人专栏:《洞察之眼:ELK监控与可视化》🏅 🔖行路有良友,便是天堂🔖 目录 一、引言 1、Logstash简介 2、在K8s中部署Logstash多节点实例…

简单聊聊大数据分析的方法有什么

大数据分析是指对规模巨大的数据集合进行的分析过程。 这些数据集合通常具有以下几个特点,可以概括为5个V: 1.数据量大(Volume):大数据分析处理的数据量巨大,远远超出了传统数据处理软件的能力范围。 2.…

MySQL Shell 使用指南

前言: MySQL Shell 是官方提供的 MySQL 周边适配组件,是新一代的高级客户端,在 MySQL 8.0 及其以后的版本得以慢慢推广应用。之前笔者因为 MySQL 8.0 用得比较少,一直没有详细使用过这个工具,近期在捣鼓 MySQL 8.0&am…

从入门到精通:Java Lambda运算符详解!

哈喽,各位小伙伴们,你们好呀,我是喵手。运营社区:C站/掘金/腾讯云;欢迎大家常来逛逛 今天我要给大家分享一些自己日常学习到的一些知识点,并以文字的形式跟大家一起交流,互相学习,一…

力扣 48.旋转图像

题目描述: 给定一个 n n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。 你必须在 原地 旋转图像,这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。 示例 1: 输入:matrix [[1,2,3],…

Alibbaba RocketMQ笔记

作用场景 异步解耦: 将比较耗时且不需要即时(同步)返回结果 的操作放入消息队列; 流量削峰: 历史简介 基本使用 深入了解\原理