深度学习 - CNN

news2024/11/29 0:50:35

第一部分：基础知识

1. 什么是卷积神经网络（CNN）

定义和基本概念
卷积神经网络（CNN）是一种专门用于处理具有网格结构数据（如图像）的深度学习模型。它们在图像识别和计算机视觉领域表现尤为突出。与传统的全连接神经网络不同，CNN利用局部连接和共享权重的方式，能够有效减少参数数量，提高计算效率。

CNN在图像处理中的优势

  • 局部连接：只处理图像的局部区域，减少参数量。
  • 共享权重：同一个滤波器在图像不同位置扫描，进一步减少参数量。
  • 池化操作：通过降采样减少数据维度，提取重要特征。
2. CNN的基本结构

输入层
处理输入数据，比如一张图片，通常用三维数组表示（宽度，高度，颜色通道数）。

卷积层
通过应用不同的滤波器来提取特征。滤波器滑过输入图像，生成特征映射。

池化层
进行降采样，减少数据维度，提高计算效率，同时保留重要特征。

全连接层
将卷积层和池化层提取的特征展开成一维向量，并通过多个全连接层进行分类。

输出层
根据具体任务（如分类、回归）输出最终结果。
在这里插入图片描述

第二部分：深入理解

卷积操作（Convolution Operation）

实例：
假设有一个3x3的输入图像和一个2x2的滤波器：

输入图像：

1 2 3
4 5 6
7 8 9

滤波器：

1 0
0 -1

卷积操作是将滤波器应用于图像的每个局部区域，计算它们的点积和：

1*1 + 2*0 + 4*0 + 5*(-1) = 1 - 5 = -4
2*1 + 3*0 + 5*0 + 6*(-1) = 2 - 6 = -4
4*1 + 5*0 + 7*0 + 8*(-1) = 4 - 8 = -4
5*1 + 6*0 + 8*0 + 9*(-1) = 5 - 9 = -4

最终得到的特征映射：

-4 -4
-4 -4
激活函数（ReLU, Sigmoid, Tanh等）

实例：
ReLU（Rectified Linear Unit）：f(x) = max(0, x)
假设输入为[-1, 2, -3, 4]，经过ReLU后：

ReLU([-1, 2, -3, 4]) = [0, 2, 0, 4]
池化操作（Max Pooling, Average Pooling）

实例：
Max Pooling：
输入：

1 2
3 4

最大池化结果：

4

Average Pooling：
输入：

1 2
3 4

平均池化结果：

(1+2+3+4)/4 = 2.5
损失函数（Cross-Entropy Loss等）

实例：
假设有两个类别，实际标签为[1, 0]（表示第一类），预测概率为[0.8, 0.2]。
交叉熵损失计算：

Loss = - (1 * log(0.8) + 0 * log(0.2)) = - log(0.8) = 0.223

第三部分：实战应用

1. 使用PyTorch实现CNN

安装和配置PyTorch

pip install torch torchvision

构建简单的CNN模型

import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, 1)  # 3个输入通道，16个输出通道，3x3的卷积核，步长1
        self.conv2 = nn.Conv2d(16, 32, 3, 1)
        self.fc1 = nn.Linear(32 * 6 * 6, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2, 2)
        x = x.view(-1, 32 * 6 * 6)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)

数据预处理

import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)

训练和评估模型

import torch.optim as optim

model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

for epoch in range(10):  # 训练10个epoch
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 100 == 99:    # 每100个批次打印一次
            print(f'Epoch {epoch + 1}, Batch {i + 1}, Loss: {running_loss / 100:.3f}')
            running_loss = 0.0

print('Finished Training')
2. 经典CNN架构

LeNet
由Yann LeCun提出，适用于手写数字识别。

AlexNet
由Alex Krizhevsky提出，首次在ImageNet竞赛中大放异彩。

VGGNet
由Oxford大学Visual Geometry Group提出，使用多个小卷积核代替大卷积核。

GoogLeNet/Inception
由Google提出，使用Inception模块提高模型性能。

ResNet
由Microsoft提出，引入残差连接解决深层网络训练困难问题。

DenseNet
由Cornell大学提出，通过密集连接提高梯度流动。

3. 转移学习与预训练模型

使用预训练模型

from torchvision import models

resnet = models.resnet18(pretrained=True)

微调（Fine-Tuning）

for param in resnet.parameters():
    param.requires_grad = False

resnet.fc = nn.Linear(resnet.fc.in_features, 10)

第四部分：高级主题

1. 优化与调整

学习率调度

scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)

正则化方法

self.dropout = nn.Dropout(0.5)  # 在网络中使用dropout防止过拟合

批量归一化

self.bn1 = nn.BatchNorm2d(16)  # 在卷积层后添加批量归一化层
2. 增强技术

数据增强

transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

混合精度训练

from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()

for epoch in range(10):
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        with autocast():
            outputs = model(inputs)
            loss = criterion(outputs, labels)
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()
3.模型参数推荐
数据集规模数据集大小推荐的卷积层数量推荐的卷积核数（每层）推荐的全连接层数量推荐的全连接神经元数（每层）说明
小型数据集1,000 - 10,0002 - 332 - 641 - 2128 - 256例如MNIST等简单任务，可以用少量卷积层和全连接层。
中型数据集10,000 - 100,0003 - 564 - 1282 - 3256 - 512例如CIFAR-10等任务，需要更多的卷积层来提取特征。
大型数据集100,000 - 1,000,0005 - 10128 - 2562 - 4512 - 1024例如CIFAR-100、ImageNet子集等任务，复杂特征需要更多的卷积层。
超大型数据集1,000,000+10+256+3 - 51024+例如完整的ImageNet数据集或更大规模的任务，深度网络（如ResNet）通常是必要的。
小型数据集示例（如MNIST）
import torch.nn as nn
import torch.nn.functional as F

class SmallCNN(nn.Module):
    def __init__(self):
        super(SmallCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)  # 假设输入图像大小为28x28
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

在这个示例中：

  • 卷积层数量：2层（conv1 和 conv2）
  • 每层卷积核数：32和64
  • 全连接层数量：2层（fc1 和 fc2）
  • 每层全连接神经元数：128和10
中型数据集示例（如CIFAR-10）
import torch.nn as nn
import torch.nn.functional as F

class MediumCNN(nn.Module):
    def __init__(self):
        super(MediumCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(256 * 4 * 4, 512)  # 假设输入图像大小为32x32
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 256 * 4 * 4)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

在这个示例中：

  • 卷积层数量：3层（conv1, conv2 和 conv3）
  • 每层卷积核数：64, 128和256
  • 全连接层数量：2层（fc1 和 fc2）
  • 每层全连接神经元数：512和10
大型数据集示例（如ImageNet子集）
import torch.nn as nn
import torch.nn.functional as F

class LargeCNN(nn.Module):
    def __init__(self):
        super(LargeCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1)
        self.conv4 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=1)
        self.conv5 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(1024 * 1 * 1, 1024)  # 假设输入图像大小为32x32
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = self.pool(F.relu(self.conv4(x)))
        x = self.pool(F.relu(self.conv5(x)))
        x = x.view(-1, 1024 * 1 * 1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

在这个示例中：

  • 卷积层数量：5层（conv1, conv2, conv3, conv4 和 conv5）
  • 每层卷积核数：64, 128, 256, 512和1024
  • 全连接层数量：3层（fc1, fc2 和 fc3）
  • 每层全连接神经元数：1024, 512和10
4. CNN的其他应用

对抗生成网络（GANs）
生成与判别网络相互竞争，提高生成图像质量。

目标检测（Object Detection）
检测图像中的多个对象并定位它们的边界框。

语义分割（Semantic Segmentation）
将图像中的每个像

素分类到特定类别。

第五部分：项目与实践

1. 手写数字识别（MNIST）

项目介绍
MNIST数据集是一个经典的手写数字识别数据集，包含60,000个训练样本和10,000个测试样本。每个样本是28x28的灰度图像，表示从0到9的数字。

步骤

  1. 数据准备
  2. 模型构建
  3. 模型训练
  4. 模型评估

详细过程

  1. 数据准备
import torch
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)
  1. 模型构建
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.fc1 = nn.Linear(12 * 12 * 64, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(self.conv2(x), 2)
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)
  1. 模型训练
import torch.optim as optim

model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(5):  # 训练5个epoch
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')
  1. 模型评估
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total:.2f}%')
2. 图像分类（CIFAR-10）

项目介绍
CIFAR-10数据集包含60,000张32x32的彩色图像，分为10个类别。每个类别有6,000张图像。

步骤

  1. 数据准备
  2. 模型构建
  3. 模型训练
  4. 模型评估

详细过程

  1. 数据准备
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)
  1. 模型构建
class CIFAR10CNN(nn.Module):
    def __init__(self):
        super(ImprovedImageClassifier, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.conv2 = nn.Conv2d(32, 64, 3, stride=1, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv3 = nn.Conv2d(64, 128, 3, stride=1, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.dropout = nn.Dropout(0.1)  # 加入Dropout层
        self.fc1 = nn.Linear(128 * 4 * 4, 256)
        self.fc2 = nn.Linear(256, 128)
        self.out = nn.Linear(128, 10)
        
    def forward(self, x):
        x = self.pool(torch.relu(self.bn1(self.conv1(x))))
        x = self.pool(torch.relu(self.bn2(self.conv2(x))))
        x = self.pool(torch.relu(self.bn3(self.conv3(x))))
        x = x.view(-1, 128 * 4 * 4)
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)
        x = torch.relu(self.fc2(x))
        x = self.out(x)
        return x
  1. 模型训练
model = CIFAR10CNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):  # 训练10个epoch
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')
  1. 模型评估
# 构建数据加载器
dataloader = DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=True)
model.eval()

# 计算精度和其他评估指标
y_true = []
y_pred = []
with torch.no_grad():
    for x, y in dataloader:
        x = x.to(device)
        y = y.to(device)
        output = model(x)
        y_pred.extend(torch.argmax(output, dim=-1).cpu().numpy())
        y_true.extend(y.cpu().numpy())

# 混淆矩阵和分类报告
conf_mat = confusion_matrix(y_true, y_pred)
class_report = classification_report(y_true, y_pred, target_names=train_dataset.classes)

# 打印分类报告
print("Classification Report:\n", class_report)

# 绘制混淆矩阵
plt.figure(figsize=(10, 8))
sns.heatmap(conf_mat, annot=True, fmt='d', cmap='Blues', xticklabels=train_dataset.classes, yticklabels=train_dataset.classes)
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()
3. 自然图像识别（ImageNet）

项目介绍
ImageNet数据集包含超过100万张带标签的高分辨率图像，分为1000个类别。它是深度学习和计算机视觉领域的标准数据集。

步骤

  1. 使用预训练模型
  2. 微调模型
  3. 模型评估

详细过程

  1. 使用预训练模型
from torchvision import models

model = models.resnet18(pretrained=True)
  1. 微调模型
# 冻结除最后一层外的所有层
for param in model.parameters():
    param.requires_grad = False

# 替换最后一层
model.fc = nn.Linear(model.fc.in_features, 1000)

# 仅训练最后一层
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
  1. 模型训练
for epoch in range(5):  # 训练5个epoch
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')
  1. 模型评估
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total:.2f}%')

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

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

相关文章

【操作与配置】Pytorch环境搭建

【操作与配置】Pytorch环境搭建

安装显卡驱动 显卡驱动是一种软件程序，用于控制显卡硬件与操作系统之间的通信和交互。显卡驱动负责向操作系统提供有关显卡硬件的信息，以及使操作系统能够正确地控制和管理显卡的各种功能和性能。显卡驱动还包含了针对不同应用程序和游戏的优化&#xff…
阅读更多...
非关系型数据库NoSQL数据层解决方案 之 Mongodb 简介 下载安装 springboot整合与读写操作

非关系型数据库NoSQL数据层解决方案 之 Mongodb 简介 下载安装 springboot整合与读写操作

MongoDB 简介 MongoDB是一个开源的面向文档的NoSQL数据库，它采用了分布式文件存储的数据结构，是当前非常流行的数据库之一。 以下是MongoDB的主要特点和优势： 面向文档的存储： MongoDB是一个面向文档的数据库管理系统&#xff0…
阅读更多...
AI大模型四大技术架构演进选型

AI大模型四大技术架构演进选型

随着人工智能技术的迅猛发展，大模型技术架构也在不断演进和完善。大模型技术架构通过最初的简单交互，逐渐发展为可对已有模型进行能力迁移学习扩展的架构，这个过程包括了四大技术架构的演进，分别为：纯Prompt、Agent F…
阅读更多...
香橙派AIpro测试SPI通信

香橙派AIpro测试SPI通信

香橙派AIpro开发板上有一个SPI接口，如下图红框所示， 系统启动后，其对应的设备是 /dev/spidev0.0 一 硬件回环测试 香橙派AIpro上的系统自带spidev_test工具，非常方便，可以查看其帮助信息，如下&#xff0c…
阅读更多...
这个网站有点意思，可做SPRINGBOOT的启动图

这个网站有点意思，可做SPRINGBOOT的启动图

在 SpringBoot 项目的 resources 目录下新建一个 banner.txt 文本文件，然后将启动 Banner 粘贴到此文本文件中，启动项目，即可在控制台展示对应的内容信息。 下面这个工具很好用，收藏精哦
阅读更多...
MySQL概述——DDL

MySQL概述——DDL

1.SQL通用语法 1.SQL语句可以单行或多行书写，以分号结尾。 2. SQL语句可以使用空格/缩进来增强语句的可读性。 3.MySQL数据库的SQL语句不区分大小写，关键字建议使用大写。 4.注释: （1）单行注释:--注释内容或#注释内容(MySQL特…
阅读更多...
我用AI绘画Stable Diffusion 一个月后，竟然能做出惊艳所有人的效果！

我用AI绘画Stable Diffusion 一个月后，竟然能做出惊艳所有人的效果！

大家好，我是设计师阿威 如今要拍摄一组写真，需要服装、道具、灯光、场地、布景、拍摄、后期等过程。整个过程需要统一才能形成好的写真效果。现在有了AI绘图技术，我们可以实现通过AI绘图，只用计算机计算就得到一组接近真实的写真照…
阅读更多...
P450Rdb: CYP450数据库--地表最强系列--文献精读24

P450Rdb: CYP450数据库--地表最强系列--文献精读24

P450Rdb: A manually curated database of reactions catalyzed by cytochrome P450 enzymes P450Rdb: 一个人工整理的细胞色素P450酶催化反应数据库 http://www.cellknowledge.com.cn/p450rdb/ 还有一篇类似CYP450综述-20年-地表最强系列-文献精读-4 要点： P450…
阅读更多...
Postman简介

Postman简介

目录 1.概述 2.诞生背景 3.历史版本 4.安装和卸载 5.菜单和菜单项 6.使用 7.应用场景 8.示例 8.1.简单的GET请求 8.2.POST请求提交数据 8.3.查询参数 9.未来展望 10.总结 1.概述 Postman是一款用于API开发、测试和文档管理的综合性工具。允许开发者和测试人员创建…
阅读更多...
1.PyQt6库和工具库QTDesigner安装

1.PyQt6库和工具库QTDesigner安装

1.安装PyQT6和pyqt6-tools 1. PyQt6库是PyQt的开发库 2.pyqt6-tool时QTDesigner设计器工具支持库 pip install PyQt6 pip install pyqt6-tools 2.在Pycharm中配置外部工具QTDesigner和PYGIC 配置外部工具QTDesigner 1. QTDesigner是QT界面设计器 2.打开Pycharm->Settin…
阅读更多...
牛客仓鼠的鸡蛋

牛客仓鼠的鸡蛋

分析一下判断语句 如果能放就输出位置 不能放就输出-1 不能放的条件是最大值小于要放的鸡蛋数量，线段树维护最大值 放的位置用线段树二分 每个篮子不能放超过k堆鸡蛋，记录一下每个篮子放的次数，次数等于k后给最大值附上0即可 // Proble…
阅读更多...
Python连接Redis（简单连接、连接池连接、存取数据示例）

Python连接Redis（简单连接、连接池连接、存取数据示例）

天行健，君子以自强不息；地势坤，君子以厚德载物。 每个人都有惰性，但不断学习是好好生活的根本，共勉！ 文章均为学习整理笔记，分享记录为主，如有错误请指正，共同学习进步。…
阅读更多...
【2024最新精简版】MyBatis面试篇

【2024最新精简版】MyBatis面试篇

文章目录 mybatis内部实现过程mybatis延迟加载请说说MyBatis的工作原理mybatis接口里的方法,参数不同时能重载吗mybatis分页插件的原理是什么？mybatis的一级、二级缓存👍mybatis如何实现多表查询mybatis如何实现批量插入👍mybatis动态SQL标签…
阅读更多...
【最新鸿蒙应用开发】——关于鸿蒙MVVM模式的理解

【最新鸿蒙应用开发】——关于鸿蒙MVVM模式的理解

MVVM模式 MVVM（Model-View-ViewModel）是一种软件设计模式，主要用于分离应用程序的用户界面（UI）和业务逻辑。这种模式可以帮助开发者更高效地开发和管理复杂的用户界面。 程序的状态数据通常包含了数组、对象&#xff0…
阅读更多...
Linux内存从0到1学习笔记(8.15 MMU/IOMMU/SMMU概览）

Linux内存从0到1学习笔记(8.15 MMU/IOMMU/SMMU概览）

一， 什么是MMU？ MMU（Memory Management Unit 内存管理单元），即内存管理单元，是计算机硬件中的一个重要组件，主要负责处理中央处理器（CPU）的内存访问请求。 其工作原理如下： 当程序发出内存访问请求，包括读取或写入操作以及逻辑地址（虚拟地址）。然后，MMU根据页表…
阅读更多...
自动化测试git的使用

自动化测试git的使用

git是一款分布式的配置管理工具。本文主要讲git如何在自动化测试中安装，上传及拉取下载代码。 1 、git 介绍 每天早上到公司，从公司的git服务器上下载最新的代码，白天在最新的代码基础上，编写新的代码，下班时把“代码…
阅读更多...
[Java基本语法] 异常

[Java基本语法] 异常

🌸个人主页:https://blog.csdn.net/2301_80050796?spm1000.2115.3001.5343 🏵️热门专栏:🍕 Collection与数据结构 (92平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm1001.2014.3001.5482 🧀线程与…
阅读更多...
Linux 内核 (十二)进程间通讯 之 消息队列

Linux 内核 (十二)进程间通讯 之 消息队列

前言 这个系列的上一篇介绍了进程间通讯关于管道相关的内容及代码实例,本章要介绍关于消息队列相关的内容. 消息队列交互图示 函数原型 #include <sys/msg.h> #include <sys/ipc.h> //创建 or 打开队列 成功返回队列ID,失败返回-1 int msgget(key_t key,int fla…
阅读更多...
探索AIGC与3D技术的融合：从图像到可探索的3D动态场景

探索AIGC与3D技术的融合：从图像到可探索的3D动态场景

随着人工智能和计算机图形技术的飞速发展，AIGC（人工智能生成内容）与3D技术的结合正在为我们打开一扇全新的创意之门。最近，我深入研究了几个令人兴奋的AIGC+3D方案，它们不仅展示了从单张图片或文本提示生成3D点云的强大能力，还进一步实现了AI虚拟试穿和生成高保真3D数字人…
阅读更多...
Qt信号槽的回调机制

Qt信号槽的回调机制

问&#xff1a;Qt强大的地方在哪里&#xff1f; 答&#xff1a;跨平台、信号槽。。。 问&#xff1a;信号槽是什么&#xff1f; 答&#xff1a;回调函数 问&#xff1a;怎么个回调法子 答&#xff1a;。。。 成果 信号槽本身实现过程是有些复杂的&#xff0c;所以本人参考…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023