算法进阶 | 必知！5大深度生成模型！

news2024/9/23 19:58:26

本文来源公众号“算法进阶”，仅用于学术分享，侵权删，干货满满。

原文链接：必知！5大深度生成模型！

随着Sora、diffusion、GPT等模型的大火，深度生成模型又成为了大家的焦点。

深度生成模型是一类强大的机器学习工具，它可以从输入数据学习其潜在的分布，进而生成与训练数据相似的新的样本数据，它在计算机视觉、密度估计、自然语言和语音识别等领域得到成功应用, 并给无监督学习提供了良好的范式。

本文汇总了常用的深度学习模型，深入介绍其原理及应用：VAE（变分自编码器）、GAN（生成对抗网络）、AR（自回归模型 如transformer）、Flow（流模型）和Diffusion（扩散模型）

VAE（变分自编码器）

算法原理：

VAE是在自编码器（Autoencoder）的基础上，结合变分推断（Variational Inference）和贝叶斯理论提出的一种深度生成模型。VAE的目标是学习一个能够生成与训练数据相似样本的模型。它假设隐变量服从某种先验分布（如标准正态分布），并通过编码器将输入数据映射到隐变量的后验分布，再通过解码器将隐变量还原成生成样本。VAE的训练涉及到重构误差和KL散度两个部分的优化。

训练过程：

  1. 编码器：将输入数据x编码为隐变量z的均值μ和标准差σ。

  2. 采样：从标准正态分布中采样一个ε，通过μ和σ计算z = μ + ε * σ。

  3. 解码器：将z解码为生成样本x'。

  4. 计算重构误差（如MSE）和KL散度，并优化模型参数以最小化两者的和。

优点：

  • 能够生成多样化的样本。

  • 隐变量具有明确的概率解释。

缺点：

  • 训练过程可能不稳定。

  • 生成样本的质量可能不如其他模型。

适用场景：

  • 数据生成与插值。

  • 特征提取与降维。

Python示例代码（使用PyTorch实现）：

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

class VAE(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(VAE, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, 2 * hidden_dim)  # 均值和标准差
        )
        self.decoder = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, input_dim),
            nn.Sigmoid()  # 二值数据，使用Sigmoid激活函数
        )

    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std

    def forward(self, x):
        h = self.encoder(x)
        mu, logvar = h.chunk(2, dim=-1)
        z = self.reparameterize(mu, logvar)
        x_recon = self.decoder(z)
        return x_recon, mu, logvar

# 示例训练过程
model = VAE(input_dim=784, hidden_dim=400)
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 假设x是输入数据，batch_size是批次大小
x = torch.randn(batch_size, 784)
recon_x, mu, logvar = model(x)
loss = nn.functional.binary_cross_entropy(recon_x, x, reduction='sum') \
       + 0.5 * torch.sum(torch.exp(logvar) + mu.pow(2) - 1 - logvar)

optimizer.zero_grad()
loss.backward()
optimizer.step()

GAN（生成对抗网络）

算法原理：

GAN由两部分组成：生成器（Generator）和判别器（Discriminator）。生成器的任务是生成尽可能接近真实数据的假数据，而判别器的任务是区分输入数据是真实数据还是生成器生成的假数据。二者通过相互竞争与对抗，共同进化，最终生成器能够生成非常接近真实数据的样本。

训练过程：

  1. 判别器接受真实数据和生成器生成的假数据，进行二分类训练，优化其判断真实或生成数据的能力。

  2. 生成器根据判别器的反馈，尝试生成更加真实的假数据以欺骗判别器。

  3. 交替训练判别器和生成器，直到判别器无法区分真实和生成数据，或达到预设的训练轮数。

优点：

  • 能够生成高质量的样本。

  • 训练过程相对自由，不受数据分布限制。

缺点：

  • 训练不稳定，容易陷入局部最优。

  • 需要大量的计算资源。

适用场景：

  • 图像生成。

  • 文本生成。

  • 语音识别等。

Python示例代码（使用PyTorch实现）：

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

# 判别器
class Discriminator(nn.Module):
    def __init__(self, input_dim):
        super(Discriminator, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.fc(x)

# 生成器
class Generator(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(Generator, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Linear(128, output_dim),
            nn.Tanh()
        )

    def forward(self, x):
        return self.fc(x)

# 示例训练过程
discriminator = Discriminator(input_dim=784)
generator = Generator(input_dim=100, output_dim=784)
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002)
optimizer_G = optim.Adam(generator.parameters(), lr=0.0002)
criterion = nn.BCEWithLogitsLoss()

# 假设real_data是真实数据，batch_size是批次大小
real_data = torch.randn(batch_size, 784)

# 训练判别器
for p in discriminator.parameters():
    p.requires_grad = True
for p in generator.parameters():
    p.requires_grad = False

noise = torch.randn(batch_size, 100)
fake_data = generator(noise)
real_loss = criterion(discriminator(real_data), torch.ones_like(real_data))
fake_loss = criterion(discriminator(fake_data.detach()), torch.zeros_like(real_data))
discriminator_loss = real_loss + fake_loss
optimizer_D.zero_grad()
discriminator_loss.backward()
optimizer_D.step()

# 训练生成器
for p in discriminator.parameters():
    p.requires_grad = False
for p in generator.parameters():
    p.requires_grad = True

noise = torch.randn(batch_size, 100)
fake_data = generator(noise)
gen_loss = criterion(discriminator(fake_data), torch.ones_like(real_data))
optimizer_G.zero_grad()
gen_loss.backward()
optimizer_G.step()

AR（自回归模型）

算法原理：自回归模型是一种基于序列数据的生成模型，它通过预测序列中下一个元素的值来生成数据。给定一个序列(x_1, x_2, ..., x_n)，自回归模型试图学习条件概率分布(P(x_t | x_{t-1}, ..., x_1))，其中(t)表示序列的当前位置。AR模型可以通过循环神经网络（RNN）或Transformer等结构实现。如下以Transformer为例解析。

在深度学习的早期阶段，卷积神经网络（CNN）在图像识别和自然语言处理领域取得了显著的成功。然而，随着任务复杂度的增加，序列到序列（Seq2Seq）模型和循环神经网络（RNN）成为处理序列数据的常用方法。尽管RNN及其变体在某些任务上表现良好，但它们在处理长序列时容易遇到梯度消失和模型退化问题。为了解决这些问题，Transformer模型被提出。而后的GPT、Bert等大模型都是基于Transformer实现了卓越的性能！

模型原理：

Transformer模型精巧地结合了编码器和解码器两大部分，每一部分均由若干相同构造的“层”堆叠而成。这些层巧妙地将自注意力子层与线性前馈神经网络子层结合在一起。自注意力子层巧妙地运用点积注意力机制，为每个位置的输入序列编织独特的表示，而线性前馈神经网络子层则汲取自注意力层的智慧，产出富含信息的输出表示。值得一提的是，编码器和解码器各自装备了一个位置编码层，专门捕捉输入序列中的位置脉络。

模型训练：

Transformer模型的修炼之道依赖于反向传播算法和优化算法，如随机梯度下降。在修炼过程中，它细致地计算损失函数对权重的梯度，并运用优化算法微调这些权重，以追求损失函数的最小化。为了加速修炼进度和提高模型的通用能力，修炼者们还常常采纳正则化技术、集成学习等策略。

优点：

  1. 梯度消失与模型退化之困得以解决：Transformer模型凭借其独特的自注意力机制，能够游刃有余地捕捉序列中的长期依赖关系，从而摆脱了梯度消失和模型退化的桎梏。

  2. 并行计算能力卓越：Transformer模型的计算架构具备天然的并行性，使得在GPU上能够风驰电掣地进行训练和推断。

  3. 多任务表现出色：凭借强大的特征学习和表示能力，Transformer模型在机器翻译、文本分类、语音识别等多项任务中展现了卓越的性能。

缺点：

  1. 计算资源需求庞大：由于Transformer模型的计算可并行性，训练和推断过程需要庞大的计算资源支持。

  2. 对初始化权重敏感：Transformer模型对初始化权重的选择极为挑剔，不当的初始化可能导致训练过程不稳定或出现过拟合问题。

  3. 长期依赖关系处理受限：尽管Transformer模型已有效解决梯度消失和模型退化问题，但在处理超长序列时仍面临挑战。

应用场景：

Transformer模型在自然语言处理领域的应用可谓广泛，涵盖机器翻译、文本分类、文本生成等诸多方面。此外，Transformer模型还在图像识别、语音识别等领域大放异彩。

Python示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
#该示例仅用于说明Transformer的基本结构和原理。实际的Transformer模型（如GPT或BERT）要复杂得多，并且需要更多的预处理步骤，如分词、填充、掩码等。
class Transformer(nn.Module):
    def __init__(self, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward=2048):
        super(Transformer, self).__init__()
        self.model_type = 'Transformer'

        # encoder layers
        self.src_mask = None
        self.pos_encoder = PositionalEncoding(d_model, max_len=5000)
        encoder_layers = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, num_encoder_layers)

        # decoder layers
        decoder_layers = nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward)
        self.transformer_decoder = nn.TransformerDecoder(decoder_layers, num_decoder_layers)

        # decoder
        self.decoder = nn.Linear(d_model, d_model)

        self.init_weights()

    def init_weights(self):
        initrange = 0.1
        self.decoder.weight.data.uniform_(-initrange, initrange)

    def forward(self, src, tgt, teacher_forcing_ratio=0.5):
        batch_size = tgt.size(0)
        tgt_len = tgt.size(1)
        tgt_vocab_size = self.decoder.out_features

        # forward pass through encoder
        src = self.pos_encoder(src)
        output = self.transformer_encoder(src)

        # prepare decoder input with teacher forcing
        target_input = tgt[:, :-1].contiguous()
        target_input = target_input.view(batch_size * tgt_len, -1)
        target_input = torch.autograd.Variable(target_input)

        # forward pass through decoder
        output2 = self.transformer_decoder(target_input, output)
        output2 = output2.view(batch_size, tgt_len, -1)

        # generate predictions
        prediction = self.decoder(output2)
        prediction = prediction.view(batch_size * tgt_len, tgt_vocab_size)

        return prediction[:, -1], prediction


class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super(PositionalEncoding, self).__init__()

        # Compute the positional encodings once in log space.
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1).float()
        div_term = torch.exp(torch.arange(0, d_model, 2).float() *
                             -(torch.log(torch.tensor(10000.0)) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:, :x.size(1)]
        return x

# 超参数
d_model = 512
nhead = 8
num_encoder_layers = 6
num_decoder_layers = 6
dim_feedforward = 2048

# 实例化模型
model = Transformer(d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward)

# 随机生成数据
src = torch.randn(10, 32, 512)
tgt = torch.randn(10, 32, 512)

# 前向传播
prediction, predictions = model(src, tgt)

print(prediction)

Flow（流模型）

算法原理：流模型是一种基于可逆变换的深度生成模型。它通过一系列可逆的变换，将简单分布（如均匀分布或正态分布）转换为复杂的数据分布。

训练过程：在训练阶段，流模型通过最小化潜在空间中的样本与真实数据之间的损失函数来学习可逆变换的参数。

优点：

  • 可以高效地进行样本生成和密度估计。

  • 具有可逆性，便于反向传播和优化。

缺点：

  • 设计合适的可逆变换可能具有挑战性。

  • 对于高维数据，流模型可能难以捕捉到复杂的依赖关系。

适用场景：流模型适用于图像生成、音频生成和密度估计等任务。

Python示例代码：

import torch
import torch.nn as nn

class FlowModel(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(FlowModel, self).__init__()
        self.transform1 = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.Tanh()
        )
        self.transform2 = nn.Sequential(
            nn.Linear(hidden_dim, input_dim),
            nn.Sigmoid()
        )

    def forward(self, x):
        z = self.transform1(x)
        x_hat = self.transform2(z)
        return x_hat, z

‍Diffusion Model

Diffusion Model（扩散模型）是一类深度生成模型，它的灵感来源于物理学中的扩散过程。与传统的生成模型（如VAE、GAN）不同，Diffusion Model通过模拟数据从随机噪声逐渐扩散到目标数据的过程来生成数据。这种模型在图像生成、文本生成和音频生成等领域都有出色的表现。

算法原理：

Diffusion Model的基本思想是将数据生成过程看作一个马尔可夫链。从目标数据开始，每一步都向随机噪声靠近，直到达到纯噪声状态。然后，通过反向过程，从纯噪声逐渐恢复到目标数据。这个过程通常由一系列的条件概率分布来描述。

训练过程：

  1. 前向过程（Forward Process）：从真实数据开始，逐步添加噪声，直到达到纯噪声状态。这个过程中，需要计算每一步的噪声水平，并保存下来。

  2. 反向过程（Reverse Process）：从纯噪声开始，逐步去除噪声，直到恢复到目标数据。在这个过程中，使用神经网络（通常是U-Net结构）来预测每一步的噪声水平，并据此生成数据。

  3. 优化：通过最小化真实数据与生成数据之间的差异来训练模型。常用的损失函数包括MSE（均方误差）和BCE（二元交叉熵）。

优点：

  1. 生成质量高：由于Diffusion Model采用了逐步扩散和恢复的过程，因此可以生成高质量的数据。

  2. 可解释性强：Diffusion Model的生成过程具有明显的物理意义，便于理解和解释。

  3. 灵活性好：Diffusion Model可以处理各种类型的数据，包括图像、文本和音频等。

缺点：

  1. 训练时间长：由于Diffusion Model需要进行多步的扩散和恢复过程，因此训练时间较长。

  2. 计算资源需求大：为了保证生成质量，Diffusion Model通常需要较大的计算资源，包括内存和计算力。

适用场景：

Diffusion Model适用于需要生成高质量数据的场景，如图像生成、文本生成和音频生成等。同时，由于其可解释性强和灵活性好的特点，Diffusion Model也可以应用于其他需要深度生成模型的领域。

Python示例代码：

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

# 定义U-Net模型
class UNet(nn.Module):
    # ...省略模型定义...

# 定义Diffusion Model
class DiffusionModel(nn.Module):
    def __init__(self, unet):
        super(DiffusionModel, self).__init__()
        self.unet = unet
        
    def forward(self, x_t, t):
        # x_t为当前时刻的数据，t为噪声水平
        # 使用U-Net预测噪声水平
        noise_pred = self.unet(x_t, t)
        # 根据噪声水平生成数据
        x_t_minus_1 = x_t - noise_pred * torch.sqrt(1 - torch.exp(-2 * t))
        return x_t_minus_1

# 初始化模型和优化器
unet = UNet()
model = DiffusionModel(unet)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练过程
for epoch in range(num_epochs):
    for x_real in dataloader:  # 从数据加载器中获取真实数据
        # 前向过程
        x_t = x_real  # 从真实数据开始
        for t in torch.linspace(0, 1, num_steps):
            # 添加噪声
            noise = torch.randn_like(x_t) * torch.sqrt(1 - torch.exp(-2 * t))
            x_t = x_t + noise * torch.sqrt(torch.exp(-2 * t))
            
            # 计算预测噪声
            noise_pred = model(x_t, t)
            
            # 计算损失
            loss = nn.MSELoss()(noise_pred, noise)
            
            # 反向传播和优化
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

通过对GAN、VAE、Flow、Diffusion和AR这五种常见生成模型的分析比较，我们可以看到不同模型的优缺点和适用场景，VAE和GAN是两种常用的深度生成模型，分别基于贝叶斯概率理论和对抗训练来生成样本。AR模型则适用于处理具有时序依赖关系的数据，如序列数据。Flow模型和Diffusion模型在生成样本方面具有较好的稳定性和多样性，但需要较高的计算成本。未来的生成模型研究可能会进一步探索模型的稳定性和可训练性，以及如何提高生成样本的质量和多样性。

THE END !

文章结束，感谢阅读。您的点赞，收藏，评论是我继续更新的动力。大家有推荐的公众号可以评论区留言，共同学习，一起进步。

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

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

相关文章

【简历】25届南京某一本JAVA简历：简历通过率还好，但是拿不到OFFER

【简历】25届南京某一本JAVA简历：简历通过率还好，但是拿不到OFFER

注：为保证用户信息安全，姓名和学校等信息已经进行同层次变更，内容部分细节也进行了部分隐藏 简历说明 今天看一份25届南京某一本大学的Java简历。 这个简历呢，学校是一本。我们说上来先要定校招层次，这个层次就按照…
阅读更多...
D35XT120-ASEMI新能源专用D35XT120

D35XT120-ASEMI新能源专用D35XT120

编辑：ll D35XT120-ASEMI新能源专用D35XT120 型号：D35XT120 品牌：ASEMI 封装：DXT-5 批号：2024 现货：50000 正向电流（Id）：35A 反向耐压（VRRM&#xff0…
阅读更多...
dubbo是什么？，能做什么？以及其工作流程

dubbo是什么？，能做什么？以及其工作流程

1.Dubbo是什么？能做什么？ Dubbo是阿里巴巴开源的基于Java的高性能RPC分布式服务框架，现已成为Apache基金会孵化项目，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案 简单来说，dubbo…
阅读更多...
通义灵码怎么样？分为哪些版本，看看基础能力多少分？

通义灵码怎么样？分为哪些版本，看看基础能力多少分？

通义灵码，是一款基于通义大模型的智能编码辅助工具，提供行级/函数级实时续写、自然语言生成代码、单元测试生成、代码优化、注释生成、代码解释、研发智能问答、异常报错排查等能力，并针对阿里云的云服务使用场景调优，助力开发者高…
阅读更多...
【计算机组成原理】计算机系统层次结构

【计算机组成原理】计算机系统层次结构

计算机系统层次结构 计算机系统是一个层次结构系统，每一层都通过向上层用户提供一个抽象的简洁接口而将低层的实现细节隐藏起来。计算机解决应用问题的过程就是不同抽象层进行转换的过程 计算机系统抽象层的转换 下图描述了从最终用户希望计算机完成的应用(问题)…
阅读更多...
Java重修笔记 第四十九天 Collections 工具类

Java重修笔记 第四十九天 Collections 工具类

Collections 工具类 1. public static void reverse(List<?> list) 反转集合中元素的顺序 2. public static void shuffle(List<?> list) 将集合里的元素顺序打乱 3. public static <T extends Comparable<? super T>> void sort(List<T>…
阅读更多...
Java项目: 基于SpringBoot+mysql企业客户管理系统(含源码+数据库+答辩PPT+毕业论文)

Java项目: 基于SpringBoot+mysql企业客户管理系统(含源码+数据库+答辩PPT+毕业论文)

一、项目简介 本项目是一套基于SpringBootmysql企业客户管理系统 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调试&#xff0c;eclipse或者idea 确保可以运行&#xff01; 该系统功能完善、界面美观、操作简单、功…
阅读更多...
工业相机飞拍的原理及工作原理

工业相机飞拍的原理及工作原理

工业相机飞拍&#xff08;或称为工业高速相机飞行拍摄&#xff09;是一种利用高速图像捕捉技术和精密运动控制系统进行高效图像采集的先进技术。它广泛应用于工业检测、质量控制和自动化生产等领域。本文将详细探讨工业相机飞拍的原理及其工作方式。 一、工业相机飞拍的基本概…
阅读更多...
【深度学习】卷积神经网络与 LeNet

【深度学习】卷积神经网络与 LeNet

在 softmax 回归中&#xff0c;我们使用的数据集是图像数据。这种数据的每个样本都是由一个二维像素网格组成&#xff0c;每个像素可能是一个或多个数值&#xff0c;取决于是黑白还是彩色图像。 我们之前的处理方式是通过“展平”&#xff0c;用一个标量表示一个像素&#xff…
阅读更多...
electron 客户端 windows linux（麒麟V10）多系统离线打包 最新版 ＜一＞

electron 客户端 windows linux（麒麟V10）多系统离线打包 最新版 ＜一＞

electron客户端下载、构建、打包在国内网络情况下&#xff0c;绝对不是什么易事。更不要说离线干活&#xff0c;更是难上加难。 这一篇主要讲下windows离线环境下&#xff0c;如何完成electron的下载打包。咱废话不多说&#xff0c;直接上干货。注意&#xff0c;我的大前提是完…
阅读更多...
Nacos部分漏洞2 附POC

Nacos部分漏洞2 附POC

@[toc] Nacos部分漏洞2 附POC 免责声明：请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息或者工具而造成的任何直接或者间接的后果及损失，均由使用者本人负责，所产生的一切不良后果与文章作者无关。该文章仅供学习用途使用。 1. Nacos简介 微信公…
阅读更多...
蓝牙耳机性价比高的有哪些？年度4大高性价比热款推荐

蓝牙耳机性价比高的有哪些？年度4大高性价比热款推荐

在过去的一年里&#xff0c;市场上涌现了许多具有出色性能且价格相对亲民的蓝牙耳机&#xff0c;它们在音质、稳定性、续航能力等核心性能上表现出色&#xff0c;同时在用户最关心的价格上也展现出了极大的吸引力&#xff0c;蓝牙耳机性价比高的有哪些&#xff1f;为了帮助大家…
阅读更多...
并发工具类（三）：Semaphore

并发工具类（三）：Semaphore

1、Semaphore介绍 Semaphore&#xff08;信号量&#xff09;也是juc包下一个线程同步工具&#xff0c;主要用于 在一个时刻允许多个线程 对共享资源进行并行操作的场景。通常情况下&#xff0c;使用 Semaphore 的过程实际上是多个线程 访问共享资源获取许可证的过程。 Semaphor…
阅读更多...
SpringBoot中使用log遇到的一些问题

SpringBoot中使用log遇到的一些问题

1、springboot logger.level与<logger>优先级&#xff1f; 百度结果如下&#xff1a; 所以得出结论&#xff0c;如果在yml种配置&#xff1a; logging:level:com.ruoyi: debugorg.springframework: warn 同时在logback-spring.xml中配置了 <!-- 系统模块日志级别控…
阅读更多...
【无损检测】基于用深度学习的工业超声B-Scan 图像中的焊缝缺陷

【无损检测】基于用深度学习的工业超声B-Scan 图像中的焊缝缺陷

Automated Weld Defect Detection in Industrial Ultrasonic B-Scan Images Using Deep Learning Abstract: 自动超声波检测&#xff08;AUT&#xff09;是一种无损检测&#xff08;NDT&#xff09;方法&#xff0c;广泛应用于具有重要经济意义的行业。为了确保对独有的 AUT 数…
阅读更多...
数据结构与算法（3）栈和队列

数据结构与算法（3）栈和队列

1.前言 哈喽大家好啊&#xff0c;今天博主继续为大家带来数据结构与算法的学习笔记&#xff0c;今天是关于栈和队列&#xff0c;未来博主会将上一章《顺序表与链表》以及本章《栈与队列》做专门的习题应用专题讲解&#xff0c;都会很有内容含量 &#xff0c;欢迎大家多多支持&…
阅读更多...
Facebook 小店：不出单？没流量？如何解决？

Facebook 小店：不出单？没流量？如何解决？

Facebook Marketplace为用户提供一个在本地交易商品的平台&#xff0c;包括二手商品、房屋出租和家政服务等都可以在上面检索到相关信息。据数据统计&#xff0c;每月约有4亿人使用Facebook Marketplace功能&#xff0c;潜力巨大&#xff0c;为商家提供了广阔的商机。然而&…
阅读更多...
笔记 14 ： 彭老师课本第 8 章， UART ： 寄存器介绍 ，

笔记 14 ： 彭老师课本第 8 章， UART ： 寄存器介绍 ，

&#xff08;99&#xff09; 继续介绍 uart 的关于通道的 一整套 寄存器&#xff0c; UCON 等&#xff1a; 接着介绍寄存器 UTRSTAT &#xff1a; 接着介绍读写数据的寄存器&#xff1a; 设置 uart 的波特率&#xff0c;有关的寄存器&#xff1a; &#xff08;100&#xf…
阅读更多...
【Linux】进程优先级｜进程切换

【Linux】进程优先级｜进程切换

目录 进程优先级 1️⃣ 进程优先级 1.什么是进程优先级&#xff1f; 2.进程优先级的类型 3.进程优先级的作用 4.进程优先级的实现 5.进程优先级的重要性 6.查看系统进程 7.修改进程优先级 top命令进行修改 renice命令 8.优先级调度原理​编辑 进程切换 进程优先级…
阅读更多...
1985-2022年全国土地利用分类可视化数据（30M）

1985-2022年全国土地利用分类可视化数据（30M）

1985-2022年全国土地利用分类可视化数据&#xff08;30M&#xff09; 1、时间&#xff1a;1989-2022年 2、空间分辨率&#xff1a;30米&#xff0c; 3、地理坐标系&#xff1a;WGS-84 4、土地类型&#xff1a;九种 类型编码含义1&#xff1a;农田&#xff1b;2&#xff1a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023