【计算机视觉基础CV-图像分类】05 - 深入解析ResNet与GoogLeNet:从基础理论到实际应用

引言

在上一篇文章中,我们详细介绍了ResNet与GoogLeNet的网络结构、设计理念及其在图像分类中的应用。本文将继续深入探讨如何在实际项目中应用这些模型,特别是如何保存训练好的模型、加载模型以及使用模型进行新图像的预测。通过这些步骤,读者将能够完整地掌握从模型训练到部署的全过程。

ps:数据集已经发布~

目录:

  1. ResNet简介

  2. ResNet的网络结构

    • 残差块

    • ResNet模型架构

  3. GoogLeNet简介

  4. GoogLeNet的网络结构

    • Inception模块

    • GoogLeNet模型架构

  5. ResNet与GoogLeNet的对比

  6. 实际应用:利用ResNet进行图像分类

    • 数据准备与预处理

    • 模型实例化与参数设置

    • 模型训练与评估

    • 模型保存与加载

    • 新图像预测

    • 完整代码实现详解

  7. 总结与展望

  8. 参考文献


ResNet简介

随着深度神经网络层数的增加,模型的表达能力显著提升。然而,网络越深,训练过程中面临的梯度消失、梯度爆炸等问题也愈加严重,导致模型性能难以进一步提升。2015年,何凯明等人提出了残差网络(ResNet),通过引入“跳跃连接”(Shortcut Connections)有效缓解了深层网络训练中的退化问题,使得训练超过百层的深度网络成为可能。ResNet在2015年的ImageNet图像识别挑战赛中取得了显著成绩,极大地影响了后续深度神经网络的设计。

ResNet的网络结构

残差块

 

在传统的深层神经网络中,随着网络深度的增加,模型的训练误差往往呈现上升趋势,这被称为“退化问题”。ResNet通过引入残差块(Residual Block)解决了这一问题。

这种结构被称为“跳跃连接”(Shortcut Connection),它允许梯度直接在网络中传播,缓解了梯度消失的问题。基础残差块

输入 x
 |
 Conv3x3
 |
 BatchNorm
 |
 ReLU
 |
 Conv3x3
 |
 BatchNorm
 |
 +-----+
 |     |
 x     |
 |     |
 +-----+
 |
 ReLU
 |
 输出 H(x) = F(x) + x
瓶颈残差块

输入 x
 |
 Conv1x1
 |
 BatchNorm
 |
 ReLU
 |
 Conv3x3
 |
 BatchNorm
 |
 ReLU
 |
 Conv1x1
 |
 BatchNorm
 |
 +-----+
 |     |
 x     |
 |     |
 +-----+
 |
 ReLU
 |
 输出 H(x) = F(x) + x

ResNet模型架构

ResNet的整体架构由多个残差块堆叠而成,不同的ResNet版本(如ResNet-18、ResNet-34、ResNet-50、ResNet-101、ResNet-152)主要区别在于残差块的类型及其数量。以ResNet-50为例,其结构如下:

图2:ResNet-34架构图 来源

下图:ResNet 的常见版本架构

GoogLeNet简介

GoogLeNet,又称为Inception v1,是Google在2014年提出的一种深度卷积神经网络模型。与ResNet不同,GoogLeNet主要通过Inception模块的设计,实现了网络结构的深度和宽度的有效扩展,同时控制了计算复杂度。GoogLeNet在2014年的ImageNet挑战赛中取得了优异成绩,显著降低了参数数量。

图3:GoogLeNet架构图 来源

GoogLeNet的网络结构

Inception模块

Inception模块是GoogLeNet的核心创新,通过在同一层次上并行应用不同尺寸的卷积核和池化操作,捕捉多尺度的特征信息。具体来说,一个Inception模块通常包括以下几部分:

  1. 1x1卷积:用于减少维度,降低计算量。

  2. 3x3卷积:处理空间信息。

  3. 5x5卷积:处理更大范围的空间信息。

  4. 3x3最大池化:用于下采样,后接1x1卷积。

通过这些并行的操作,Inception模块能够同时捕捉到不同尺度的特征,提高了模型的表达能力。

GoogLeNet模型架构

图4:Inception模块示意图 来源

ResNet与GoogLeNet的对比

特性ResNetGoogLeNet
核心创新残差学习(Residual Learning)Inception模块
网络深度可扩展至超过100层22层,后续版本如Inception v2、v3更深
参数数量随层数增加显著通过Inception模块有效控制参数数量
训练难度残差块设计缓解深层网络的训练难题多路径结构复杂,需精心设计和训练
应用场景图像分类、目标检测、语义分割等多种任务主要用于图像分类,后续版本扩展至其他任务
计算效率残差块结构相对简单,计算效率高Inception模块复杂,但通过1x1卷积降低计算量

实际应用:利用ResNet进行图像分类

本文将以ResNet-18为例,演示如何在PyTorch框架下构建、训练和评估一个图像分类模型。以鲜花种类识别为案例,读者可以通过本文的步骤,掌握从数据准备到模型训练、保存、加载及预测的完整流程。

数据准备与预处理

首先,确保已下载并整理好鲜花数据集。数据集通常分为训练集和测试集,分别存放在不同的文件夹中。为了适应ResNet-18的输入要求,需要将图像尺寸调整为224x224。

from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
​
# 指定批次大小
batch_size = 16
​
# 指定数据集路径
flower_train_path = './dataset/flower_datas/train/'
flower_test_path = './dataset/flower_datas/val/'
​
# 数据预处理:调整图像大小并转换为Tensor
dataset_transform = transforms.Compose([
    transforms.Resize((224, 224)),  # 调整图像大小为224x224
    transforms.ToTensor()           # 将图像转换为Tensor
])
​
# 加载训练集和测试集
flower_train = ImageFolder(flower_train_path, transform=dataset_transform)
flower_test = ImageFolder(flower_test_path, transform=dataset_transform)
​
# 创建数据加载器
train_loader = DataLoader(dataset=flower_train, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=flower_test, batch_size=batch_size, shuffle=False)

说明

  • 使用transforms.Resize将图像调整为224x224,以匹配ResNet的输入要求。

  • 使用ImageFolder加载数据集,确保数据集目录结构符合PyTorch的要求(每个类别一个文件夹)。

  • 使用DataLoader创建训练和测试数据加载器,设置批次大小和是否打乱数据。

模型实例化与参数设置

使用PyTorch内置的ResNet-18模型,并根据任务需要调整输出类别数。

import torch
import torchvision.models as models
​
# 实例化ResNet-18模型,调整输出类别数为5
model = models.resnet18(num_classes=5)
​
# 设置训练设备为GPU(如果可用)否则为CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
​
# 定义优化器(Adam)和损失函数(交叉熵损失)
learning_rate = 1e-3
num_epochs = 25
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
loss_fn = torch.nn.CrossEntropyLoss()

说明

  • models.resnet18(num_classes=5):加载ResNet-18模型,并将最后的全连接层调整为输出5个类别。

  • device:自动检测是否有GPU可用,并将模型移动到对应设备以加速训练。

  • optimizer:选择Adam优化器,并设置学习率。

  • loss_fn:使用交叉熵损失函数,适用于多分类任务。

模型训练与评估

定义训练和评估函数,逐步训练模型并监控其性能。

import matplotlib.pyplot as plt
​
# 评估模型准确率
def evaluate_accuracy(data_iter, model):
    model.eval()  # 设置模型为评估模式
    correct = 0
    total = 0
    with torch.no_grad():  # 不计算梯度
        for images, labels in data_iter:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    return correct / total
​
# 训练模型
def train_model(model, train_loader, test_loader, optimizer, loss_fn, num_epochs):
    train_losses = []
    train_accuracies = []
    test_accuracies = []
    
    for epoch in range(num_epochs):
        model.train()  # 设置模型为训练模式
        running_loss = 0.0
        correct = 0
        total = 0
        
        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)
            
            # 前向传播
            outputs = model(images)
            loss = loss_fn(outputs, labels)
            
            # 反向传播和优化
            optimizer.zero_grad()  # 清除之前的梯度
            loss.backward()        # 反向传播计算梯度
            optimizer.step()       # 更新参数
            
            # 统计损失和准确率
            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        
        # 计算平均损失和准确率
        epoch_loss = running_loss / len(train_loader)
        epoch_acc = correct / total
        test_acc = evaluate_accuracy(test_loader, model)
        
        train_losses.append(epoch_loss)
        train_accuracies.append(epoch_acc)
        test_accuracies.append(test_acc)
        
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.4f}, '
              f'Train Acc: {epoch_acc:.3f}, Test Acc: {test_acc:.3f}')
    
    print('训练完成')
    
    # 绘制损失和准确率曲线
    epochs = range(1, num_epochs+1)
    plt.figure(figsize=(12,5))
    
    # 绘制训练损失曲线
    plt.subplot(1,2,1)
    plt.plot(epochs, train_losses, 'r', label='训练损失')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.title('训练损失曲线')
    plt.legend()
    
    # 绘制训练和测试准确率曲线
    plt.subplot(1,2,2)
    plt.plot(epochs, train_accuracies, 'g', label='训练准确率')
    plt.plot(epochs, test_accuracies, 'b', label='测试准确率')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.title('准确率曲线')
    plt.legend()
    
    plt.show()

说明

  • evaluate_accuracy函数用于评估模型在测试集上的准确率,设置模型为评估模式,避免梯度计算。

  • train_model函数负责整个训练过程,包括前向传播、计算损失、反向传播、优化参数,以及记录和绘制损失与准确率曲线。

  • 在每个epoch结束后,输出当前epoch的损失、训练准确率和测试准确率。

输出:​ 

模型保存与加载

在完成模型训练后,保存训练好的模型是非常重要的步骤。保存模型不仅可以避免重复训练,还可以在需要时加载模型进行预测或进一步训练。

1. 保存模型

使用PyTorch的torch.save函数可以方便地保存模型的参数(state_dict)或整个模型。

# 保存模型参数
torch.save(model.state_dict(), 'resnet18_flower.pth')
print("模型已保存为 resnet18_flower.pth")

说明

  • model.state_dict():获取模型的所有参数。

  • torch.save:将参数保存到指定路径。

  • 推荐保存模型的参数而不是整个模型,因为保存参数更加灵活,适用于不同的应用场景。

2. 加载模型

在需要使用保存的模型时,可以通过加载模型参数来恢复模型。

# 实例化模型结构
model_loaded = models.resnet18(num_classes=5)
​
# 加载模型参数
model_loaded.load_state_dict(torch.load('resnet18_flower.pth'))
​
# 设置模型为评估模式
model_loaded.eval()
​
# 将模型移动到对应设备
model_loaded = model_loaded.to(device)
print("模型已加载并准备就绪")

说明

  • 实例化与保存时相同结构的模型。

  • 使用load_state_dict加载保存的参数。

  • 设置模型为评估模式,避免在推理时启用训练模式的行为(如Dropout)。

  • 将模型移动到相应设备(GPU或CPU)。

新图像预测

完成模型的加载后,可以使用模型对新图像进行预测。以下步骤展示了如何加载新图像、进行预处理、并使用模型进行预测。

from PIL import Image
import numpy as np
​
# 定义类别标签(根据实际数据集调整)
class_names = ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']
​
# 图像预处理函数
def preprocess_image(image_path):
    # 定义与训练时相同的预处理步骤
    transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor()
    ])
    # 打开图像
    image = Image.open(image_path).convert('RGB')
    # 应用预处理
    image = transform(image)
    # 增加批次维度
    image = image.unsqueeze(0)
    return image
​
# 预测函数
def predict(image_path, model, class_names):
    # 预处理图像
    image = preprocess_image(image_path)
    image = image.to(device)
    
    # 进行预测
    model.eval()
    with torch.no_grad():
        outputs = model(image)
        _, predicted = torch.max(outputs.data, 1)
    
    # 获取预测结果
    predicted_class = class_names[predicted.item()]
    return predicted_class
​
# 示例:预测新图像
new_image_path = './dataset/flower_datas/test/daisy/daisy_001.jpg'  # 替换为实际图像路径
predicted_label = predict(new_image_path, model_loaded, class_names)
print(f"预测结果:{predicted_label}")

说明

  • preprocess_image函数:加载并预处理新图像,使其符合模型输入要求。

  • predict函数:加载预处理后的图像,使用模型进行前向传播,获取预测结果。

  • class_names:根据实际数据集定义类别标签。

  • 示例中替换new_image_path为实际需要预测的图像路径。

完整代码实现详解

以下是完整的代码实现,包括数据准备、模型定义、训练、保存、加载及新图像预测。代码中包含详细注释,帮助您理解每一步的具体操作。

# 导入相关的工具包
import torch
import torchvision.models as models
from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np
​
# 指定批次大小
batch_size = 16
​
# 指定数据集路径
flower_train_path = './dataset/flower_datas/train/'
flower_test_path = './dataset/flower_datas/val/'
​
# 数据预处理:调整图像大小并转换为Tensor
dataset_transform = transforms.Compose([
    transforms.Resize((224, 224)),  # 调整图像大小为224x224
    transforms.ToTensor()           # 将图像转换为Tensor
])
​
# 加载训练集和测试集
flower_train = ImageFolder(flower_train_path, transform=dataset_transform)
flower_test = ImageFolder(flower_test_path, transform=dataset_transform)
​
# 创建数据加载器
train_loader = DataLoader(dataset=flower_train, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=flower_test, batch_size=batch_size, shuffle=False)
​
# 实例化ResNet-18模型,调整输出类别数为5
model = models.resnet18(num_classes=5)
​
# 设置训练设备为GPU(如果可用)否则为CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
​
# 定义优化器(Adam)和损失函数(交叉熵损失)
learning_rate = 1e-3
num_epochs = 25
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
loss_fn = torch.nn.CrossEntropyLoss()
​
# 评估模型准确率
def evaluate_accuracy(data_iter, model):
    model.eval()  # 设置模型为评估模式
    correct = 0
    total = 0
    with torch.no_grad():  # 不计算梯度
        for images, labels in data_iter:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    return correct / total
​
# 训练模型
def train_model(model, train_loader, test_loader, optimizer, loss_fn, num_epochs):
    train_losses = []
    train_accuracies = []
    test_accuracies = []
    
    for epoch in range(num_epochs):
        model.train()  # 设置模型为训练模式
        running_loss = 0.0
        correct = 0
        total = 0
        
        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)
            
            # 前向传播
            outputs = model(images)
            loss = loss_fn(outputs, labels)
            
            # 反向传播和优化
            optimizer.zero_grad()  # 清除之前的梯度
            loss.backward()        # 反向传播计算梯度
            optimizer.step()       # 更新参数
            
            # 统计损失和准确率
            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        
        # 计算平均损失和准确率
        epoch_loss = running_loss / len(train_loader)
        epoch_acc = correct / total
        test_acc = evaluate_accuracy(test_loader, model)
        
        train_losses.append(epoch_loss)
        train_accuracies.append(epoch_acc)
        test_accuracies.append(test_acc)
        
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.4f}, '
              f'Train Acc: {epoch_acc:.3f}, Test Acc: {test_acc:.3f}')
    
    print('训练完成')
    
    # 绘制损失和准确率曲线
    epochs = range(1, num_epochs+1)
    plt.figure(figsize=(12,5))
    
    # 绘制训练损失曲线
    plt.subplot(1,2,1)
    plt.plot(epochs, train_losses, 'r', label='训练损失')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.title('训练损失曲线')
    plt.legend()
    
    # 绘制训练和测试准确率曲线
    plt.subplot(1,2,2)
    plt.plot(epochs, train_accuracies, 'g', label='训练准确率')
    plt.plot(epochs, test_accuracies, 'b', label='测试准确率')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.title('准确率曲线')
    plt.legend()
    
    plt.show()
​
# 保存模型参数
def save_model(model, path='resnet18_flower.pth'):
    torch.save(model.state_dict(), path)
    print(f"模型已保存为 {path}")
​
# 加载模型参数
def load_model(path='resnet18_flower.pth'):
    model_loaded = models.resnet18(num_classes=5)
    model_loaded.load_state_dict(torch.load(path))
    model_loaded = model_loaded.to(device)
    model_loaded.eval()
    print("模型已加载并准备就绪")
    return model_loaded
​
# 图像预处理函数
def preprocess_image(image_path):
    # 定义与训练时相同的预处理步骤
    transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor()
    ])
    # 打开图像
    image = Image.open(image_path).convert('RGB')
    # 应用预处理
    image = transform(image)
    # 增加批次维度
    image = image.unsqueeze(0)
    return image
​
# 预测函数
def predict(image_path, model, class_names):
    # 预处理图像
    image = preprocess_image(image_path)
    image = image.to(device)
    
    # 进行预测
    model.eval()
    with torch.no_grad():
        outputs = model(image)
        _, predicted = torch.max(outputs.data, 1)
    
    # 获取预测结果
    predicted_class = class_names[predicted.item()]
    return predicted_class
​
# 定义类别标签(根据实际数据集调整)
class_names = ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']
​
# 开始训练
train_model(model, train_loader, test_loader, optimizer, loss_fn, num_epochs)
​
# 保存训练好的模型
save_model(model, 'resnet18_flower.pth')
​
# 加载保存的模型
model_loaded = load_model('resnet18_flower.pth')
​
# 示例:预测新图像
new_image_path = './dataset/flower_datas/test/daisy/daisy_001.jpg'  # 替换为实际图像路径
predicted_label = predict(new_image_path, model_loaded, class_names)
print(f"预测结果:{predicted_label}")

代码注释详解

  1. 数据准备

    • 使用transforms.Resize将图像调整为224x224,以匹配ResNet的输入要求。

    • 使用ImageFolder加载数据集,确保每个类别的图像存放在单独的文件夹中。

    • 使用DataLoader创建训练和测试数据加载器,设置批次大小和是否打乱数据。

  2. 模型实例化与参数设置

    • 使用models.resnet18加载ResNet-18模型,并将最后的全连接层调整为5个输出类别。

    • 检测是否有GPU可用,并将模型移动到对应设备以加速训练。

    • 定义优化器(Adam)和损失函数(交叉熵损失),设置学习率和训练轮数。

  3. 训练与评估

    • 定义evaluate_accuracy函数,用于在测试集上评估模型的准确率,设置模型为评估模式,避免梯度计算。

    • 定义

      train_model

      函数,包含整个训练过程:

      • 设置模型为训练模式。

      • 遍历每个epoch和每个batch,进行前向传播、计算损失、反向传播和优化参数。

      • 记录每个epoch的损失和准确率。

      • 在每个epoch结束后,评估模型在测试集上的准确率。

      • 绘制训练损失和准确率曲线,直观展示模型的训练过程。

  4. 模型保存与加载

    • 定义save_model函数,使用torch.save将模型的参数保存到指定路径。

    • 定义load_model函数,实例化相同结构的模型,并使用load_state_dict加载保存的参数。设置模型为评估模式,并移动到对应设备。

  5. 新图像预测

    • 定义preprocess_image函数,加载并预处理新图像,使其符合模型输入要求。

    • 定义predict函数,加载预处理后的图像,使用模型进行前向传播,获取预测结果。

    • 示例中替换new_image_path为实际需要预测的图像路径,打印预测结果。

完整流程说明

  1. 数据准备:加载并预处理数据集,包括图像尺寸调整和格式转换。

  2. 模型定义与参数设置:实例化ResNet-18模型,定义优化器和损失函数,并将模型移动到训练设备。

  3. 模型训练与评估:通过训练函数,迭代训练模型,并在每个epoch后评估模型性能。

  4. 模型保存:训练完成后,使用torch.save保存模型的参数。

  5. 模型加载:在需要使用模型时,实例化相同结构的模型,并加载保存的参数。

  6. 新图像预测:加载并预处理新图像,使用加载的模型进行预测,输出预测结果。

示例运行结果

训练过程的输出如下:

Epoch [1/25], Loss: 1.3775, Train Acc: 0.442, Test Acc: 0.516
Epoch [2/25], Loss: 1.1998, Train Acc: 0.528, Test Acc: 0.552
...
Epoch [25/25], Loss: 0.7376, Train Acc: 0.730, Test Acc: 0.684
训练完成
模型已保存为 resnet18_flower.pth
模型已加载并准备就绪
预测结果:daisy

通过绘制的损失和准确率曲线,可以直观地观察模型的训练过程和性能提升情况。

总结与展望

本文详细介绍了ResNet与GoogLeNet两种经典深度卷积神经网络的结构与设计理念,并通过实际案例演示了如何在PyTorch框架下应用ResNet进行图像分类任务。特别是通过增加模型保存、加载和新图像预测的步骤,展示了完整的从训练到部署的流程。

关键总结

  • ResNet通过引入残差块有效解决了深层网络的训练难题,使得训练超过100层的深度网络成为可能。

  • GoogLeNet通过Inception模块实现了网络深度和宽度的有效扩展,同时控制了计算复杂度,适用于计算资源有限的场景。

  • 实际应用中,选择适当的网络结构和参数设置对于提升模型性能至关重要。

  • 模型的保存与加载是深度学习项目中重要的步骤,确保训练成果能够被复用和部署。

未来展望

随着深度学习技术的不断发展,更多高效的网络架构不断涌现,如DenseNet、EfficientNet等。结合更先进的优化算法和硬件加速技术,深度神经网络将在计算机视觉、自然语言处理等领域发挥更大的作用。此外,模型压缩与加速技术的发展,也将推动深度学习模型在移动设备和边缘计算中的广泛应用。

参考文献

  1. He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep Residual Learning for Image Recognition. arXiv preprint arXiv:1512.03385.

  2. Szegedy, C., Liu, W., Jia, Y., Sermanet, P., Reed, S., Anguelov, D., ... & Rabinovich, A. (2015). Going deeper with convolutions. Proceedings of the IEEE conference on computer vision and pattern recognition.

  3. He, K., Zhang, X., Ren, S., & Sun, J. (2016). Identity Mappings in Deep Residual Networks. European Conference on Computer Vision (ECCV).

  4. Ioffe, S., & Szegedy, C. (2015). Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. International Conference on Machine Learning (ICML).


本文内容结合了公开的学术论文与实践经验,旨在为读者提供清晰、系统的ResNet与GoogLeNet解析。如有任何问题或建议,欢迎在评论区交流讨论。

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

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

相关文章

【CDN】快速了解CDN是什么?以及工作原理和应用场景

快速了解CDN是什么?以及工作原理和应用场景 一、什么是CDN?CDN相关的术语解释 二、CDN工作原理三、CDN与传统网站的区别四、CDN的作用和意义五、CDN的应用场景 一、什么是CDN? CDN英文全称Content Delivery Network,中文翻译即为内…

leetcode 2295.替换数组中的元素

1.题目要求: 2.题目代码: class Solution { public:vector<int> arrayChange(vector<int>& nums, vector<vector<int>>& operations){map<int,int> element_index;//创建图存入元素和元素对应的下标for(int i 0;i < nums.size()…

clickhouse-题库

1、clickhouse介绍以及架构 clickhouse一个分布式列式存储数据库&#xff0c;主要用于在线分析查询 2、列式存储和行式存储有什么区别&#xff1f; 行式存储&#xff1a; 1&#xff09;、数据是按行存储的 2&#xff09;、没有建立索引的查询消耗很大的IO 3&#xff09;、建…

记录一个SVR学习

1、为什么使用jupter来做数据预测&#xff1f;而不是传统pycharm编辑器 1、Jupyter Notebook 通过anaconda统一管理环境&#xff0c;可以运行python、R、Sql等数据分析常用语言。 2、做到交互式运行&#xff0c;可以逐步运行代码块&#xff0c;实时查看结果&#xff0c;便于调…

【WRF教程第3.2期】预处理系统 WPS详解:以4.5版本为例

预处理系统 WPS 详解&#xff1a;以4.5版本为例 WPS 嵌套域&#xff08;WPS Nested Domains&#xff09;USGS 和 MODIS 土地利用重力波拖拽方案静态数据&#xff08;Gravity Wave Drag Scheme Static Data&#xff09;1. 什么是重力波拖拽方案&#xff08;GWDO&#xff09;静态…

Stealthy Attack on Large Language Model based Recommendation

传统RS依赖id信息进行推荐&#xff0c;攻击&#xff1a;生成虚假用户&#xff0c;这些用户对特定目标物体给于高评价&#xff0c;从而影响模型的训练。 基于llm的RS&#xff1a;llm利用语义理解&#xff0c;将用户兴趣转化为语义向量&#xff0c;通过计算用户兴趣向量与物品向…

Pytorch | 从零构建EfficientNet对CIFAR10进行分类

Pytorch | 从零构建EfficientNet对CIFAR10进行分类 CIFAR10数据集EfficientNet设计理念网络结构性能特点应用领域发展和改进 EfficientNet结构代码详解结构代码代码详解MBConv 类初始化方法前向传播 forward 方法 EfficientNet 类初始化方法前向传播 forward 方法 训练过程和测…

【Linux 网络 (五)】Tcp/Udp协议

Linux 网络 一前言二、Udp协议1&#xff09;、Udp协议特点2&#xff09;、Udp协议格式3&#xff09;、Udp报文封装和解包过程4&#xff09;、UDP的缓冲区 三、TCP协议1&#xff09;、TCP协议特点2&#xff09;、TCP协议格式1、4位首部长度、源端口、目的端口2、16位窗口大小3、…

重温设计模式--命令模式

文章目录 命令模式的详细介绍C 代码示例C代码示例2 命令模式的详细介绍 定义与概念 命令模式属于行为型设计模式&#xff0c;它旨在将一个请求封装成一个对象&#xff0c;从而让你可以用不同的请求对客户端进行参数化&#xff0c;将请求的发送者和接收者解耦&#xff0c;并且能…

Python langchain ReAct 使用范例

0. 介绍 ReAct: Reasoning Acting &#xff0c;ReAct Prompt 由 few-shot task-solving trajectories 组成&#xff0c;包括人工编写的文本推理过程和动作&#xff0c;以及对动作的环境观察。 1. 范例 langchain version 0.3.7 $ pip show langchain Name: langchain Ver…

Java设计模式 —— 【结构型模式】外观模式详解

文章目录 概述结构案例实现优缺点 概述 外观模式又名门面模式&#xff0c;是一种通过为多个复杂的子系统提供一个一致的接口&#xff0c;而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口&#xff0c;外部应用程序不用关心内部子系统的具体的细节&#xff0c;这…

【自用】通信内网部署rzgxxt项目_01,后端pipeDemo部署(使用nssm.exe仿照nohup)

做完这些工作之后&#xff0c;不要忘记打开 Windows Server 的防火墙端口&#xff0c;8181、8081、8080、22、443、1521 做完这些工作之后&#xff0c;不要忘记打开 Windows Server 的防火墙端口&#xff0c;8181、8081、8080、22、443、1521 做完这些工作之后&#xff0c;不要…

Apache RocketMQ 5.1.3安装部署文档

官方文档不好使&#xff0c;可以说是一坨… 关键词&#xff1a;Apache RocketMQ 5.0 JDK 17 废话少说&#xff0c;开整。 1.版本 官网地址&#xff0c;版本如下。 https://rocketmq.apache.org/download2.配置文件 2.1namesrv端口 在ROCKETMQ_HOME/conf下 新增namesrv.pro…

【网络安全】网站常见安全漏洞—服务端漏洞介绍

文章目录 网站常见安全漏洞—服务端漏洞介绍引言1. 第三方组件漏洞什么是第三方组件漏洞&#xff1f;如何防范&#xff1f; 2. SQL 注入什么是SQL注入&#xff1f;如何防范&#xff1f; 3. 命令执行漏洞什么是命令执行漏洞&#xff1f;如何防范&#xff1f; 4. 越权漏洞什么是越…

【计算机视觉基础CV-图像分类】01- 从历史源头到深度时代:一文读懂计算机视觉的进化脉络、核心任务与产业蓝图

1.计算机视觉定义 计算机视觉&#xff08;Computer Vision&#xff09;是一个多学科交叉的研究领域&#xff0c;它的核心目标是使计算机能够像人类一样“看”并“理解”视觉信息。换句话说&#xff0c;它希望赋予计算机从图像、视频中自动提取、有意义地分析、理解并解释视觉场…

JVM系列(十三) -常用调优工具介绍

最近对 JVM 技术知识进行了重新整理&#xff0c;再次献上 JVM系列文章合集索引&#xff0c;感兴趣的小伙伴可以直接点击如下地址快速阅读。 JVM系列(一) -什么是虚拟机JVM系列(二) -类的加载过程JVM系列(三) -内存布局详解JVM系列(四) -对象的创建过程JVM系列(五) -对象的内存分…

electron-vite【实战】登录/注册页

效果预览 项目搭建 https://blog.csdn.net/weixin_41192489/article/details/144611858 技术要点 路由默认跳转到登录页 src/renderer/src/router/index.ts routes: [// 默认跳转到登录页{path: /,redirect: /login},...routes]登录窗口的必要配置 src/main/index.ts 中 cons…

蓝桥杯嵌入式备赛教程(1、led,2、lcd,3、key)

一、工程模版创建流程 第一步 创建新项目 第二步 选择型号和管脚封装 第三步 RCC使能 外部时钟&#xff0c;高速外部时钟 第四步晶振时钟配置 由数据手册7.1可知外部晶振频率为24MHz 最后一项设置为80 按下回车他会自动配置时钟 第五步&#xff0c;如果不勾选可能程序只会…

C++----------函数的调用机制

栈帧的创建与销毁 栈帧创建过程 当一个函数被调用时&#xff0c;系统会在程序的栈空间中为该函数创建一个栈帧。首先&#xff0c;会将函数的返回地址&#xff08;即调用该函数的下一条指令的地址&#xff09;压入栈中&#xff0c;这确保函数执行完后能回到正确的位置继续执行后…

C语言初阶习题【9】数9的个数

1.编写程序数一下 1到 100 的所有整数中出现多少个数字9 2.思路 循环遍历1到100&#xff0c;需要判断每一位的个位数是否为9&#xff0c;十位数是否为9&#xff0c;每次符合条件就count进行计数&#xff0c;最后输出count&#xff0c;即可 3.code #define _CRT_SECURE_NO_W…