RealESRGAN技术详解(附代码)

一、背景与动机

1.研究背景

1.1 图像超分辨率的挑战

 图像超分辨率是一个长期存在的计算机视觉问题,它旨在从低分辨率(LR)图像中恢复出高分辨率(HR)图像。由于成像系统的局限性、传输过程中的压缩、存储空间的限制以及历史图像资料的保存等,图像超分辨率技术对于提升图像质量具有重要意义。

1.2 传统方法的局限性

 传统的图像超分辨率方法,如插值算法(最近邻、双线性、双三次等)和基于重建的方法(如稀疏编码),虽然在一定程度上能够提高图像的分辨率,但它们往往无法恢复图像的细节信息,特别是在放大倍数较高时,图像会出现模糊和伪影。

1.3 深度学习的发展

 随着深度学习技术的发展,特别是卷积神经网络(CNN)在图像处理领域的成功应用,基于深度学习的超分辨率方法开始受到关注。这些方法能够学习到从低分辨率到高分辨率图像的复杂映射关系,并能够恢复出更多的细节信息。

1.4 ESRGAN的提出

 ESRGAN(Enhanced Super-Resolution Generative Adversarial Networks)是2018年提出的一种基于生成对抗网络(GAN)的超分辨率方法。它通过引入感知损失和特征匹配损失,提高了超分辨率图像的视觉质量。

2.研究动机

2.1 ESRGAN的局限性

尽管ESRGAN在图像超分辨率方面取得了显著的进展,但在实际应用中,它仍然存在一些局限性。例如,ESRGAN在处理真实世界图像时可能会出现过度锐化和伪影的问题,这些问题限制了其在实际图像恢复任务中的应用。

2.2 RealESRGAN的提出

为了解决这些问题,RealESRGAN被提出。RealESRGAN的目标是开发一种新的超分辨率技术,它不仅能够提高图像的分辨率,而且能够减少伪影和过度锐化,提供更自然和真实的图像恢复效果。

2.3 实际图像恢复的需求

在实际的图像恢复任务中,如老旧照片修复、卫星图像增强、医学成像等领域,对图像质量的要求非常高。这些应用不仅需要高分辨率的图像,还需要图像具有真实感和自然感。RealESRGAN正是为了满足这些需求而设计的。

2.4 技术进步的推动

随着计算资源的增加和深度学习技术的进步,开发更复杂、更高效的网络结构成为可能。RealESRGAN利用了这些技术进步,通过改进网络结构和训练策略,提高了超分辨率技术的性能和实用性。

二、技术架构

1. 生成器(Generator)

生成器是RealESRGAN的核心部分,负责将低分辨率(LR)图像转换成高分辨率(HR)图像。生成器的网络结构通常包括以下几个关键部分:

  • 浅层特征抽取网络:这部分网络负责提取输入图像的浅层特征,通常通过一个卷积层加上ReLU激活函数实现,将输入图像的通道数调整为64。

  • RRDB(Residual in Residual Dense Block)网络结构:这是RealESRGAN中的关键创新之一。RRDB结构包含N个RDB(Residual Dense Block)密集残差块和一个残差边。每个RDB包含5个卷积层,通过torch.cat函数将卷积的通道数相叠加,从而实现特征的密集连接。

  • 上采样网络:生成器还包括上采样部分,通过两次上采样,将图像的高宽变为原来的4倍,实现分辨率的提升。

RRDB结构通过两层残差结构实现,主干部分由3个RDB构成,每个RDB块都有5个卷积层,通过残差边将主干网络的输出与输入叠加,实现特征的融合。

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

# 定义残差密集块(RDB)
class RDB(nn.Module):
    def __init__(self, in_channels, growth_rate, n_steps):
        super(RDB, self).__init__()
        self.RDB_layers = nn.Sequential(
            *[Bottleneck(in_channels if i == 0 else growth_rate, growth_rate, n_steps) 
              for i in range(n_steps)]
        )
        
    def forward(self, x):
        return self.RDB_layers(x) + x

# 定义Bottleneck块
class Bottleneck(nn.Module):
    def __init__(self, in_channels, growth_rate, n_steps):
        super(Bottleneck, self).__init__()
        self.layers = nn.Sequential(
            *[nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1), 
              nn.ReLU(inplace=True), 
              nn.Conv2d(growth_rate, growth_rate, kernel_size=3, padding=1), 
              nn.ReLU(inplace=True) for _ in range(n_steps)]
        )
        
    def forward(self, x):
        return self.layers(x)

# 定义生成器
class Generator(nn.Module):
    def __init__(self, in_channels, out_channels, num_blocks, num_rdb_blocks, growth_rate):
        super(Generator, self).__init__()
        self.head = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=9, padding=4),
            nn.PReLU()
        )
        
        self.RDB_trunk = nn.Sequential(
            *[RDB(64 if i == 0 else growth_rate, growth_rate, num_rdb_blocks) 
              for i in range(num_blocks)]
        )
        
        self.up_body = nn.Sequential(
            nn.Conv2d(64 + growth_rate * num_blocks, out_channels, kernel_size=3, padding=1),
            nn.PReLU()
        )
        
    def forward(self, x):
        x = self.head(x)
        res = self.RDB_trunk(x)
        res += x
        res = self.up_body(res)
        return res

# 实例化生成器
in_channels = 3  # 输入通道数,例如RGB图像
out_channels = 3  # 输出通道数,例如RGB图像
num_blocks = 8  # RRDB块的数量
num_rdb_blocks = 5  # 每个RDB中的Bottleneck块数量
growth_rate = 64  # 增长速率

generator = Generator(in_channels, out_channels, num_blocks, num_rdb_blocks, growth_rate)

在这个示例中,我们定义了一个RDB类,它包含多个Bottleneck块,这些块通过残差连接堆叠在一起。Bottleneck块包含两个卷积层,分别用于特征提取和特征转换。Generator类首先使用一个卷积层和一个PReLU激活函数作为头部,然后是RDB_trunk,它包含多个RDB块,最后是一个上采样部分,用于将特征图转换为最终的输出图像。

2. 判别器(Discriminator)

判别器在RealESRGAN中的作用是区分生成的高分辨率图像和真实的高分辨率图像。判别器也是一个卷积神经网络,它接收高分辨率图像作为输入,并输出一个介于0和1之间的分数,表示该图像为真实的概率。以下是一个判别器(Discriminator)的PyTorch代码示例。这个示例展示了一个简单的卷积判别器,它通常用于图像数据的二分类任务,即区分真实图像和生成的假图像。

import torch
import torch.nn as nn

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            # 第一层卷积,输入通道数为3(例如RGB图像),输出通道数为64,卷积核大小为4x4,步长为2,填充为1
            nn.Conv2d(3, 64, 4, stride=2, padding=1),
            nn.LeakyReLU(0.2),  # 使用LeakyReLU激活函数,防止梯度消失问题
            # 可以添加更多的卷积层和激活层,这里只是一个简单的示例
            # ...
            # 最后一层使用Sigmoid激活函数,输出一个介于0和1之间的值,表示输入是真实图像的概率
            nn.Sigmoid()  
        )
        
    def forward(self, input):
        # 前向传播,输入图像通过判别器网络
        return self.main(input)

# 实例化判别器
discriminator = Discriminator()

在这个示例中,判别器由一系列卷积层和激活层组成,最后一层是Sigmoid激活函数,用于输出一个概率值,表示输入图像是真实图像的概率。这个简单的判别器可以作为GAN中判别器的基本架构,具体的层数和参数可以根据实际任务进行调整和优化。

3. 训练过程

RealESRGAN的训练过程是一个生成器和判别器之间的对抗过程。生成器试图生成越来越逼真的高分辨率图像以“欺骗”判别器,而判别器则试图区分生成的图像和真实的图像。通过这种对抗训练,生成器可以逐渐提高其生成图像的质量,以达到与真实图像相似的外观。以下是一个完整的训练过程的PyTorch代码示例,包括生成器(Generator)和判别器(Discriminator)的训练。这个示例展示了如何使用PyTorch框架来训练一个简单的生成对抗网络(GAN)。

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 定义生成器和判别器
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            # 定义网络层
            nn.Conv2d(100, 256, 4, 1, 0),
            nn.LeakyReLU(0.2, inplace=True),
            nn.ConvTranspose2d(256, 128, 4, 2, 1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.ConvTranspose2d(128, 64, 4, 2, 1),
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.2, inplace=True),
            nn.ConvTranspose2d(64, 3, 4, 2, 1),
            nn.Tanh()
        )

    def forward(self, input):
        return self.main(input)

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            # 定义网络层
            nn.Conv2d(3, 64, 4, 2, 1),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(64, 128, 4, 2, 1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(128, 256, 4, 2, 1),
            nn.BatchNorm2d(256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(256, 1, 4, 1, 0),
            nn.Sigmoid()
        )

    def forward(self, input):
        return self.main(input)

# 实例化生成器和判别器
generator = Generator()
discriminator = Discriminator()

# 设置损失函数和优化器
criterion = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

# 加载数据集
transform = transforms.Compose([
    transforms.Resize_((64, 64)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
dataloader = DataLoader(dataset, batch_size=64, shuffle=True)

# 训练循环
num_epochs = 5
for epoch in range(num_epochs):
    for i, (imgs, _) in enumerate(dataloader):
        # 训练判别器
        real = Variable(imgs.type(Tensor))
        label = Variable(Tensor(imgs.size(0), 1).fill_(1.0), requires_grad=False)
        fake = generator(Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], 100, 1, 1)))))
        fake_label = Variable(Tensor(imgs.size(0), 1).fill_(0.0), requires_grad=False)
        
        optimizer_D.zero_grad()
        real_loss = criterion(discriminator(real), label)
        fake_loss = criterion(discriminator(fake.detach()), fake_label)
        d_loss = (real_loss + fake_loss) / 2
        d_loss.backward()
        optimizer_D.step()
        
        # 训练生成器
        optimizer_G.zero_grad()
        g_loss = criterion(discriminator(fake), label)
        g_loss.backward()
        optimizer_G.step()
        
        print(f"Epoch [{epoch+1}/{num_epochs}] Batch {i+1}/{len(dataloader)} D_loss: {d_loss.item():.4f} G_loss: {g_loss.item():.4f}")

print("Training Complete")

这个示例展示了如何使用PyTorch框架来训练一个简单的生成对抗网络(GAN),包括生成器和判别器的定义、训练过程和数据加载。

4. 损失函数

RealESRGAN的训练涉及到多种损失函数,包括像素损失、感知损失和对抗损失等,这些损失函数共同指导训练过程,以生成更高质量的图像。二元交叉熵损失(Binary Cross-Entropy Loss)是GAN中最常用的损失函数之一,用于判别器的二分类任务。

import torch
import torch.nn as nn

# 定义损失函数
criterion = nn.BCELoss()

# 假设真实标签和预测结果
real_labels = torch.ones((64, 1))  # 真实图像的概率为1
fake_labels = torch.zeros((64, 1))  # 生成图像的概率为0

# 判别器对真实图像的预测
real_outputs = torch.randn(64, 1)  # 假设判别器输出
# 判别器对生成图像的预测
fake_outputs = torch.randn(64, 1)  # 假设判别器输出

# 计算损失
real_loss = criterion(real_outputs, real_labels)
fake_loss = criterion(fake_outputs, fake_labels)

# 总损失
d_loss = (real_loss + fake_loss) / 2

5. 数据增强和训练策略

RealESRGAN通过精心设计的数据增强和训练策略来提高模型的泛化能力,使其能够更好地适应真实世界中的各种图像退化情况。

import torch
import torch.nn as nn
import torch.optim as optim

# 定义生成器
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            # 定义网络层
        )

    def forward(self, input):
        return self.main(input)

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            # 定义网络层
        )

    def forward(self, input):
        return self.main(input)

# 初始化生成器和判别器
generator = Generator()
discriminator = Discriminator()

# 设置损失函数和优化器
adversarial_loss = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

# 训练循环
for epoch in range(num_epochs):
    for i, (imgs, _) in enumerate(dataloader):
        real_imgs = Variable(imgs.type(Tensor))
        valid = Variable(Tensor(imgs.size(0), 1).fill_(1.0), requires_grad=False)
        fake = Variable(Tensor(imgs.size(0), 1).fill_(0.0), requires_grad=False)
        
        optimizer_G.zero_grad()
        z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], 100))))
        gen_imgs = generator(z)
        g_loss = adversarial_loss(discriminator(gen_imgs), valid)
        g_loss.backward()
        optimizer_G.step()
        
        optimizer_D.zero_grad()
        real_loss = adversarial_loss(discriminator(real_imgs), valid)
        fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
        d_loss = (real_loss + fake_loss) / 2
        d_loss.backward()
        optimizer_D.step()

三、应用场景

1. 医学成像

         在医学成像领域,如MRI和CT扫描,图像的分辨率对于疾病的诊断和治疗计划至关重要。然而,由于设备限制或患者运动等因素,获取的图像可能分辨率不足。 RealESRGAN可以显著提高这些医学图像的分辨率,帮助医生更清晰地识别微小的病变和结构。通过增强图像细节,医生可以更准确地诊断疾病,制定治疗方案,并评估治疗效果。

# 查看一个患者的图像
first_patient = load_scan(INPUT_FOLDER + patients[0])
first_patient_pixels = get_pixels_hu(first_patient)
plt.hist(first_patient_pixels.flatten(), bins=80, color='c')
plt.xlabel("Hounsfield Units (HU)")
plt.ylabel("Frequency")
plt.show()

# 显示一个中间位置的切片
plt.imshow(first_patient_pixels[80], cmap=plt.cm.gray)
plt.show()

# CT重新采样到[1 1 1](由于不同的扫描,切片的距离可能不同)
def resample(image, scan, new_spacing=[1,1,1]):
    # Determine current pixel spacing
    spacing = np.array([scan[0].SliceThickness] + scan[0].PixelSpacing, dtype=np.float32)
    resize_factor = spacing / new_spacing
    new_real_shape = image.shape * resize_factor
    new_shape = np.round(new_real_shape)
    real_resize_factor = new_shape / image.shape
    new_spacing = spacing / real_resize_factor
    image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest')
    return image, new_spacing

pix_resampled, spacing = resample(first_patient_pixels, first_patient, [1,1,1])
print("Shape before resampling\t", first_patient_pixels.shape)
print("Shape after resampling\t", pix_resampled.shape)

具体应用

  • 肿瘤诊断:通过提高肿瘤区域的分辨率,帮助医生判断肿瘤的性质和边界。
  • 神经成像:增强神经纤维的可见度,用于神经退行性疾病的研究和诊断。
  • 眼科:提高视网膜图像的分辨率,用于黄斑变性和其他眼底病变的检测。

2. 卫星图像分析

        卫星图像在地理信息系统(GIS)、环境监测和城市规划中扮演着重要角色。然而,由于传输和存储的限制,卫星图像的分辨率可能不足以满足精细分析的需求。RealESRGAN能够将低分辨率的卫星图像转换为高分辨率图像,从而提供更多的地面细节。这对于监测环境变化、城市规划和灾害响应等领域非常有价值。

# 假设我们有一个视频流,我们想要使用RealESRGAN对其进行超分辨率处理
# 这里是一个简化的示例,展示如何加载视频、读取帧、应用RealESRGAN模型,并保存结果

import cv2

# 加载视频
cap = cv2.VideoCapture('video.mp4')

# 读取视频帧
ret, frame = cap.read()

# 应用RealESRGAN模型(这里假设你已经有了一个预训练的RealESRGAN模型)
# model = RealESRGANModel()  # 假设这是你的RealESRGAN模型
# enhanced_frame = model(frame)

# 保存增强后的帧
# 这里需要将增强后的帧写入新的视频文件
# out = cv2.VideoWriter('enhanced_video.mp4', cv2.VideoWriter_fourcc(*'mp4v'), 20, (frame.shape[1], frame.shape[0]))

while ret:
    ret, frame = cap.read()
    # 应用RealESRGAN模型
    # enhanced_frame = model(frame)
    
    # 保存增强后的帧
    # out.write(enhanced_frame)
    
    # 显示帧
    cv2.imshow('Frame', frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

具体应用

  • 农业监测:通过分析高分辨率图像,评估作物生长情况和土地利用变化。
  • 城市发展:监测城市扩张和基础设施建设,为城市规划提供决策支持。
  • 灾害管理:在自然灾害后,快速获取受影响区域的高分辨率图像,评估灾害影响并指导救援行动。

3. 老照片修复

         许多历史照片因年代久远而变得模糊不清,这些照片对于个人和文化历史都具有重要意义。RealESRGAN不仅可以提高老照片的分辨率,还可以在一定程度上修复因时间而损坏的图像,恢复其原有的色彩和细节。

<!-- 电影网站的HTML结构 -->
<div class="contain">
    <div class="main">
        <div class="panelhead">电影列表</div>
        <div class="panel-content">
            <div class="movies-list">
                <!-- 电影项 -->
                <div class="movie-item">
                    <div class="movietitle">电影标题</div>
                    <div class="integer">评分</div>
                </div>
                <!-- 更多电影项 -->
            </div>
        </div>
    </div>
    <!-- 其他内容 -->
</div>

具体应用

  • 家庭相册:帮助用户恢复和增强家庭相册中珍贵的老照片。
  • 历史档案:为博物馆和档案馆提供技术支持,修复和数字化历史照片。
  • 新闻媒体:增强历史新闻图片的分辨率,用于历史事件的回顾和报道。

4. 视频监控

视频监控系统在安全防护、交通管理等领域中非常重要。然而,由于摄像头分辨率和存储限制,监控视频的清晰度往往不足以识别细节。RealESRGAN能够将监控视频的分辨率提升,使得视频中的人物、车辆等目标的特征更加清晰,有助于事后的分析和识别。

# 老照片的超分辨率处理
# 这里是一个简化的示例,展示如何读取老照片、应用RealESRGAN模型,并保存结果

from PIL import Image
import torch
# 假设RealESRGAN模型已经被加载
# model = RealESRGANModel()

# 读取老照片
old_photo = Image.open('old_photo.jpg')

# 转换为Tensor
old_photo_tensor = transforms.ToTensor()(old_photo)

# 应用RealESRGAN模型
# enhanced_photo_tensor = model(old_photo_tensor)

# 转换回PIL图像
# enhanced_photo = transforms.ToPILImage()(enhanced_photo_tensor)

# 保存增强后的照片
# enhanced_photo.save('enhanced_old_photo.jpg')

具体应用

  • 安全监控:提高监控视频的分辨率,以便更准确地识别入侵者或可疑行为。
  • 交通监控:增强车牌和车辆特征的识别,用于交通违规的取证。
  • 公共安全:在人群密集的公共场所,提高监控视频的分辨率,以便在紧急情况下快速定位和响应。

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

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

相关文章

零拷贝相关知识点(一)

前言 大家好&#xff0c;我是程序员田螺。 零拷贝是老生常谈的问题啦&#xff0c;大厂非常喜欢问。比如Kafka为什么快&#xff0c;RocketMQ为什么快等&#xff0c;都涉及到零拷贝知识点。最近技术讨论群几个伙伴分享了阿里、虾皮的面试真题&#xff0c;也都涉及到零拷贝。因此…

Warcraft Logs [Classic] [WCL] exe download, set up, setting upload data

Warcraft Logs [Classic] [WCL] exe download, set up, setting & upload data WCL客户端下载&#xff0c;安装&#xff0c;配置和如何上传数据 Warcraft Logs - Combat Analysis for Warcraft 漫长的22分钟下载真的够慢的 到此为止&#xff0c;WCL客户端才安装完成 双击…

DIY搭建网站(学术个人介绍主页)

本教程介绍了如何创建并管理一个基于GitHub Pages的个人网站。首先&#xff0c;需要在GitHub上创建一个遵循特定命名规则的新仓库&#xff0c;例如用户名.github.io&#xff0c;以便建立个人站点。接着&#xff0c;通过Fork一个开源模板代码仓库并添加index.html文件来构建主页…

Java设计模式 —— 【创建型模式】原型模式(浅拷贝、深拷贝)详解

文章目录 前言原型模式一、浅拷贝1、案例2、引用数据类型 二、深拷贝1、重写clone()方法2、序列化 总结 前言 先看一下传统的对象克隆方式&#xff1a; 原型类&#xff1a; public class Student {private String name;public Student(String name) {this.name name;}publi…

Python 自动化办公的 10 大脚本

大家好&#xff0c;我是你们的 Python 讲师&#xff01;今天我们将讨论 10 个实用的 Python 自动化办公脚本。这些脚本可以帮助你简化日常工作&#xff0c;提高效率。无论是处理 Excel 文件、发送邮件&#xff0c;还是自动化网页操作&#xff0c;Python 都能派上用场。 1. 批量…

设计模式学习[10]---迪米特法则+外观模式

文章目录 前言1. 迪米特法则2. 外观模式2.1 原理阐述2.2 举例说明 总结 前言 之前有写到过 依赖倒置原则&#xff0c;这篇博客中涉及到的迪米特法则和外观模式更像是这个依赖倒置原则的一个拓展。 设计模式的原则嘛&#xff0c;总归还是高内聚低耦合&#xff0c;下面就来阐述…

【看海的算法日记✨优选篇✨】第三回:二分之妙,寻径中道

&#x1f3ac; 个人主页&#xff1a;谁在夜里看海. &#x1f4d6; 个人专栏&#xff1a;《C系列》《Linux系列》《算法系列》 ⛰️ 一念既出&#xff0c;万山无阻 目录 &#x1f4d6;一、算法思想 细节问题 &#x1f4da;左右临界 &#x1f4da;中点选择 &#x1f4da;…

使用Canal将MySQL数据同步到ES(Linux)

一、Canal官网文档 去到官方文档根据官网文档进行操作&#xff1a; QuickStart alibaba/canal Wiki GitHub 二、开启服务器中MySQL的binlog [mysqld] log-binmysql-bin # 开启 binlog binlog-formatROW # 选择 ROW 模式 server_id1 # 配置 MySQL replaction 需要定义&#x…

CENet及多模态情感计算实战

✨✨ 欢迎大家来访Srlua的博文&#xff08;づ&#xffe3;3&#xffe3;&#xff09;づ╭❤&#xff5e;✨✨ &#x1f31f;&#x1f31f; 欢迎各位亲爱的读者&#xff0c;感谢你们抽出宝贵的时间来阅读我的文章。 我是Srlua小谢&#xff0c;在这里我会分享我的知识和经验。&am…

基于深度学习和卷积神经网络的乳腺癌影像自动化诊断系统(PyQt5界面+数据集+训练代码)

乳腺癌是全球女性中最常见的恶性肿瘤之一&#xff0c;早期准确诊断对于提高生存率具有至关重要的意义。传统的乳腺癌诊断方法依赖于放射科医生的经验&#xff0c;然而&#xff0c;由于影像分析的复杂性和人类判断的局限性&#xff0c;准确率和一致性仍存在挑战。近年来&#xf…

【热门主题】000074 深度学习模型:探索与应用

前言&#xff1a;哈喽&#xff0c;大家好&#xff0c;今天给大家分享一篇文章&#xff01;并提供具体代码帮助大家深入理解&#xff0c;彻底掌握&#xff01;创作不易&#xff0c;如果能帮助到大家或者给大家一些灵感和启发&#xff0c;欢迎收藏关注哦 &#x1f495; 目录 【热…

MacOS使用VSCode编写C++程序如何配置clang编译环境

前言 这段时间在练习写C和Python&#xff0c;用vscode这个开发工具&#xff0c;调试的时候遇到一些麻烦&#xff0c;浪费了很多时间&#xff0c;因此整理了这个文档。将详细的细节描述清楚&#xff0c;避免与我遇到同样问题的人踩坑。 1.开发环境的配置 vscode的开发环境配置…

Scala关于成绩的常规操作

score.txt中的数据&#xff1a; 姓名&#xff0c;语文&#xff0c;数学&#xff0c;英语 张伟&#xff0c;87&#xff0c;92&#xff0c;88 李娜&#xff0c;90&#xff0c;85&#xff0c;95 王强&#xff0c;78&#xff0c;90&#xff0c;82 赵敏&#xff0c;92&#xff0c;8…

【实战】在Koa.js中实现文件上传的接口 (本地存储)

目录 环境准备 使用 koa-body 中间件获取上传的文件 使用 Postman 测试 使用 koa-static 中间件生成图片链接 编写前端页面上传文件 文件上传是一个基本的功能&#xff0c;每个系统几乎都会有&#xff0c;比如上传图片、上传Excel等。那么在Node Koa应用中如何实现一个支持…

使用html语言完成拼多多移动端导航栏的设计-大连东软信息学院计算机科学与技术专业高级网页设计基础课题

目录 前言 一、效果图 二、图标的使用 三、代码的编写 四、运行效果 五、文档编写 前言 1.本文所讲内容来自辽宁大连东软信息学院计算机与技术专业高级网页设计&#xff08;专升本&#xff09;课程期中四级项目课题之一&#xff0c;题目要求是自主选择相应的APP移动端&…

从语法、功能、社区和使用场景来比较 Sass 和 LESS

一&#xff1a;可以从语法、功能、社区和使用场景来比较 Sass 和 LESS&#xff1a; 1&#xff1a;语法 原始的 Sass 采用的是缩进而不是大括号&#xff0c;后续的 Sass 版本与 LESS 一样使用与 CSS 类似的语法&#xff1a; address {.fa.fa-mobile-phone {margin: 0 3px 0 2…

7. 现代卷积神经网络

文章目录 7.1. 深度卷积神经网络&#xff08;AlexNet&#xff09;7.2. 使用块的网络&#xff08;VGG&#xff09;7.3. 网络中的网络&#xff08;NiN&#xff09;7.4. 含并行连结的网络&#xff08;GoogLeNet&#xff09;7.5. 批量规范化7.5.1. 训练深层网络7.5.2. 批量规范化层…

sqlmap详细使用

SQLmap使用详解 SQLmap&#xff08;常规&#xff09;使用步骤 1、查询注入点 python sqlmap.py -u http://127.0.0.1/sqli-labs/Less-1/?id12、查询所有数据库 python sqlmap.py -u http://127.0.0.1/sqli-labs/Less-1/?id1 --dbs3、查询当前数据库 python sqlmap.py -u htt…

React+TS+css in js 练习

今天分享的内容是动态规划的经典问题--0-1 背包问题 0-1背包问题的描述如下:给定一组物品,每种物品都有自己的重量和价值,背包的总容量是固定的。我们需要从这些物品中挑选一部分,使得背包内物品的总价值最大,同时不超过背包的总容量。 举个例子&#xff1a;假设这组物品的质量…

刷题日常(找到字符串中所有字母异位词,​ 和为 K 的子数组​,​ 滑动窗口最大值​,全排列)

找到字符串中所有字母异位词 给定两个字符串 s 和 p&#xff0c;找到 s 中所有 p 的 异位词的子串&#xff0c;返回这些子串的起始索引。不考虑答案输出的顺序。 题目分析&#xff1a; 1.将p里面的字符先丢进一个hash1中&#xff0c;只需要在S字符里面找到多少个和他相同的has…