从零开始构建自动编码器:手把手教你用PyTorch实现图像降维与生成

威联通NAS配置阿里云域名和SSL证书 阅读详情

从零开始构建自动编码器:手把手教你用PyTorch实现图像降维与生成

最近在整理一些老照片时,我发现了一个有趣的现象:很多照片虽然分辨率不高,但人眼依然能清晰地辨认出其中的内容。这让我联想到深度学习中的一个经典模型——自动编码器。它就像一个聪明的“数据压缩专家”,能学习如何用更少的信息量来“记住”一张图片的核心特征,然后再尝试把它“画”出来。这个过程听起来很神奇,但背后的原理其实并不复杂,而且用PyTorch实现起来也相当直观。今天,我们就抛开那些复杂的数学公式,从一个图像爱好者的角度,一步步搭建一个属于自己的自动编码器,看看它如何压缩一张图片,又如何从压缩后的“记忆”中重建出原图。无论你是刚接触深度学习的新手,还是想找个有趣的项目练手,这篇文章都将带你从数据加载开始,亲手构建、训练并可视化一个能处理图像数据的自动编码器。

1. 自动编码器:不只是压缩,更是理解

自动编码器的核心思想,可以用一个简单的比喻来理解:想象你需要向朋友描述一幅复杂的画,但只能用一句话。你会抓住画中最核心的元素——比如“一个戴草帽的男孩在夕阳下的麦田里奔跑”。这句话就是原画的“压缩表示”。你的朋友根据这句话,在脑海中重新构思一幅画,这个过程就是“重建”。自动编码器做的正是这两件事:编码器负责学习如何用低维的“潜空间”向量来概括输入数据;解码器则负责从这个向量中尽可能还原出原始数据。

注意:潜空间是自动编码器学习到的核心所在,它不是一个随意的压缩包,而是一个有结构的、承载了数据本质特征的数学空间。理解这一点,是理解后续变分自动编码器等生成模型的关键。

它与普通的数据压缩算法(如JPEG)有本质区别。JPEG是基于信号处理规则的无损或有损编码,而自动编码器是通过数据驱动的方式,学习数据本身的分布和特征。这意味着,一个在面部图像上训练良好的自动编码器,其潜空间可能会编码“笑容程度”、“头部朝向”等语义特征,而不仅仅是像素排列。

为什么从图像开始? 图像数据直观,重建效果一目了然,非常适合作为入门项目。我们将使用经典的MNIST手写数字数据集,它结构简单,训练快速,能让我们把精力集中在模型本身。

在开始敲代码之前,我们需要明确几个核心概念:

  • 瓶颈层:编码器和解码器之间最窄的那一层,其维度决定了压缩程度。维度越低,压缩越狠,但重建也越困难。
  • 重建损失:衡量解码器输出与原始输入差异的指标,通常使用均方误差或二元交叉熵。
  • 过完备与欠完备:如果潜空间维度大于输入维度,模型可能学不到有效特征(只是复制输入);我们通常构建欠完备自动编码器,迫使网络学习数据中的关键模式。

2. 环境搭建与数据准备

工欲善其事,必先利其器。我们先来准备好开发环境。我强烈建议使用Anaconda来管理Python环境,它能避免很多令人头疼的依赖冲突问题。

# 创建一个新的conda环境(如果你还没有的话)
conda create -n ae_tutorial python=3.9
conda activate ae_tutorial

# 安装核心库
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118  # 根据你的CUDA版本选择
pip install matplotlib numpy pandas jupyter

数据方面,我们将使用torchvision内置的MNIST数据集。它包含了6万张训练图片和1万张测试图片,每张都是28x28像素的灰度手写数字。

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

# 定义数据预处理管道
# 将图像转换为Tensor,并归一化到[0, 1]区间
transform = transforms.Compose([
    transforms.ToTensor(),
])

# 下载并加载训练集和测试集
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# 创建数据加载器
batch_size = 128
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 让我们看一眼数据
def show_images(images, n=10):
    plt.figure(figsize=(20, 4))
    for i in range(n):
        ax = plt.subplot(2, n//2, i+1)
        plt.imshow(images[i].squeeze(), cmap='gray')
        plt.axis('off')
    plt.show()

# 获取一个批次的数据
data_iter = iter(train_loader)
images, labels = next(data_iter)
print(f"图像批次形状: {images.shape}")  # 应为 [128, 1, 28, 28]
show_images(images)

运行上面的代码,你应该能看到10个手写数字的灰度图。数据维度是[批量大小, 通道数, 高度, 宽度]。对于MNIST,通道数是1(灰度)。接下来,我们进入最激动人心的部分——构建模型。

3. 构建自动编码器模型:编码与解码的艺术

我们将构建一个全连接层的自动编码器。虽然卷积网络在处理图像上更强大,但全连接网络结构清晰,非常适合理解自动编码器的基本工作原理。我们的设计目标是:将784维(28*28)的输入图像,压缩到一个只有32维的潜空间向量,然后再重建回784维的图像。

class Autoencoder(nn.Module):
    def __init__(self, input_dim=784, latent_dim=32):
        super(Autoencoder, self).__init__()
        self.latent_dim = latent_dim
        
        # 编码器部分:784 -> 256 -> 128 -> 64 -> 32
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.ReLU(True),  # inplace=True可以节省一点内存
            nn.Linear(256, 128),
            nn.ReLU(True),
            nn.Linear(128, 64),
            nn.ReLU(True),
            nn.Linear(64, latent_dim),
            # 编码器输出层通常不加激活函数,保持线性
        )
        
        # 解码器部分:32 -> 64 -> 128 -> 256 -> 784
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 64),
            nn.ReLU(True),
            nn.Linear(64, 128),
            nn.ReLU(True),
            nn.Linear(128, 256),
            nn.ReLU(True),
            nn.Linear(256, input_dim),
            nn.Sigmoid()  # 将输出值压缩到[0,1],与输入归一化范围一致
        )
    
    def forward(self, x):
        # 展平输入图像
        x_flat = x.view(x.size(0), -1)
        # 编码
        latent = self.encoder(x_flat)
        # 解码
        reconstructed = self.decoder(latent)
        # 恢复图像形状
        reconstructed = reconstructed.view(x.size())
        return reconstructed, latent

# 实例化模型
model = Autoencoder(input_dim=784, latent_dim=32)
print(model)

这个模型结构有几个关键点值得讨论:

  1. 激活函数的选择:隐藏层使用ReLU,它能缓解梯度消失问题并加速训练。解码器最后一层使用Sigmoid,因为我们的输入像素值被归一化到了[0,1]。
  2. 层数与维度:编码器维度逐层递减,形成一个“漏斗”;解码器则对称地逐层递增。这种对称结构很常见,但并非必须。
  3. 潜空间:latent_dim=32意味着我们将784维的数据压缩到了32维,压缩比约为24:1。你可以尝试调整这个值,观察对重建质量的影响。

为了更直观地理解信息流动,我们来看一下数据通过模型各层时的维度变化:

层 (编码器)输出维度说明
输入图像[batch, 1, 28, 28]原始批次数据
展平后[batch, 784]准备进入全连接层
Linear(784->256)[batch, 256]第一层线性变换
Linear(256->128)[batch, 128]进一步压缩
Linear(128->64)[batch, 64]接近潜空间
潜空间向量[batch, 32]核心压缩表示
Linear(32->64)[batch, 64]解码开始
Linear(64->128)[batch, 128]逐步恢复信息
Linear(128->256)[batch, 256]接近原始维度
Linear(256->784) + Sigmoid[batch, 784]重建的展平图像
重塑后输出[batch, 1, 28, 28]最终重建图像

模型搭建好了,下一步就是让它“学习”。

4. 训练策略:损失函数、优化器与可视化监控

训练自动编码器的目标很简单:让输出尽可能像输入。因此,我们需要一个衡量两者差异的损失函数。对于像素值在[0,1]的图像,常用的损失函数是二元交叉熵损失或均方误差。这里我们使用均方误差,它对所有像素的误差一视同仁,计算也简单。

# 定义损失函数和优化器
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.Adam(model.parameters(), lr=1e-3)  # Adam优化器,学习率0.001

# 训练函数
def train_epoch(model, dataloader, criterion, optimizer, device):
    model.train()
    running_loss = 0.0
    for batch_idx, (data, _) in enumerate(dataloader):
        data = data.to(device)
        
        # 前向传播
        reconstructed, _ = model(data)
        loss = criterion(reconstructed, data)
        
        # 反向传播与优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
    
    avg_loss = running_loss / len(dataloader)
    return avg_loss

# 测试/验证函数
def validate(model, dataloader, criterion, device):
    model.eval()
    running_loss = 0.0
    with torch.no_grad():  # 禁用梯度计算,节省内存和计算
        for data, _ in dataloader:
            data = data.to(device)
            reconstructed, _ = model(data)
            loss = criterion(reconstructed, data)
            running_loss += loss.item()
    avg_loss = running_loss / len(dataloader)
    return avg_loss

训练循环是深度学习的核心节奏。我们将训练多个轮次,并监控损失值的变化。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用设备: {device}")
model = model.to(device)

num_epochs = 20
train_losses = []
val_losses = []

for epoch in range(num_epochs):
    # 训练一个轮次
    train_loss = train_epoch(model, train_loader, criterion, optimizer, device)
    train_losses.append(train_loss)
    
    # 在测试集上验证
    val_loss = validate(model, test_loader, criterion, device)
    val_losses.append(val_loss)
    
    # 每5个轮次打印一次进度,并可视化一些重建结果
    if (epoch + 1) % 5 == 0 or epoch == 0:
        print(f'Epoch [{epoch+1:03d}/{num_epochs}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')
        
        # 可视化部分测试图像的重建结果
        model.eval()
        with torch.no_grad():
            test_iter = iter(test_loader)
            test_images, _ = next(test_iter)
            test_images = test_images.to(device)
            reconstructed, _ = model(test_images[:8])  # 取前8张
            
            # 将张量移回CPU并转换为numpy用于绘图
            test_images = test_images.cpu()
            reconstructed = reconstructed.cpu()
            
            # 绘制对比图
            fig, axes = plt.subplots(2, 8, figsize=(16, 4))
            for i in range(8):
                axes[0, i].imshow(test_images[i].squeeze(), cmap='gray')
                axes[0, i].axis('off')
                axes[1, i].imshow(reconstructed[i].squeeze(), cmap='gray')
                axes[1, i].axis('off')
            axes[0, 0].set_ylabel('原始图像', fontsize=12)
            axes[1, 0].set_ylabel('重建图像', fontsize=12
            plt.suptitle(f'Epoch {epoch+1} 重建效果对比', fontsize=14)
            plt.show()

# 绘制损失曲线
plt.figure(figsize=(10, 5))
plt.plot(range(1, num_epochs+1), train_losses, label='训练损失', marker='o')
plt.plot(range(1, num_epochs+1), val_losses, label='验证损失', marker='s')
plt.xlabel('训练轮次')
plt.ylabel('损失值 (MSE)')
plt.title('自动编码器训练损失曲线')
plt.legend()
plt.grid(True)
plt.show()

在训练过程中,你会观察到损失值稳步下降,同时重建图像从最初模糊的“鬼影”逐渐变得清晰。如果验证损失在某个点后开始上升,而训练损失持续下降,那可能是过拟合的迹象,意味着模型只记住了训练集,而没有学到泛化特征。这时可以考虑增加Dropout层、使用权重衰减或获取更多数据。

提示:学习率是训练中最重要的超参数之一。如果损失下降很慢或震荡,可以尝试降低学习率(如1e-4)。如果损失几乎不变,可以适当调高。使用torch.optim.lr_scheduler可以动态调整学习率,让训练更高效。

5. 潜空间探索:降维、可视化与生成实验

训练完成后,我们得到了一个能有效压缩和重建图像的模型。但自动编码器的价值远不止于此。它的核心产物——潜空间,是一个宝库。我们可以探索这个32维的空间,看看它到底学到了什么。

首先,我们可以用主成分分析或t-SNE将高维潜空间向量降维到2D或3D进行可视化。

from sklearn.manifold import TSNE
import numpy as np

# 收集测试集图像的潜空间表示和标签
model.eval()
latent_vectors = []
labels_list = []

with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        _, latent = model(images)  # 只取潜空间向量
        latent_vectors.append(latent.cpu().numpy())
        labels_list.append(labels.numpy())

latent_vectors = np.concatenate(latent_vectors, axis=0)
labels_list = np.concatenate(labels_list, axis=0)

# 使用t-SNE降维到2D
tsne = TSNE(n_components=2, random_state=42, perplexity=30)
latent_2d = tsne.fit_transform(latent_vectors[:1000])  # 取前1000个点加快计算

# 可视化
plt.figure(figsize=(10, 8))
scatter = plt.scatter(latent_2d[:, 0], latent_2d[:, 1], c=labels_list[:1000], cmap='tab10', alpha=0.6)
plt.colorbar(scatter, label='数字类别')
plt.title('自动编码器潜空间的t-SNE可视化 (2D)')
plt.xlabel('t-SNE 特征 1')
plt.ylabel('t-SNE 特征 2')
plt.grid(True, alpha=0.3)
plt.show()

如果训练得当,你可能会看到相同数字的样本在潜空间中聚集在一起。这说明自动编码器确实学到了有意义的特征,它将语义上相似的图像映射到了潜空间中相近的位置。

更酷的实验是潜空间插值。我们在潜空间中两个点之间进行线性插值,然后让解码器生成中间图像,可以直观看到数字的 morphing 过程。

def interpolate_latent_vectors(model, z1, z2, steps=10):
    """在两点间线性插值"""
    interpolated_imgs = []
    alphas = np.linspace(0, 1, steps)
    
    with torch.no_grad():
        for alpha in alphas:
            z = alpha * z1 + (1 - alpha) * z2
            # 解码
            recon = model.decoder(z).view(1, 1, 28, 28)
            interpolated_imgs.append(recon.squeeze().cpu().numpy())
    return interpolated_imgs

# 选取两个不同数字的样本
model.eval()
with torch.no_grad():
    # 假设我们想从数字'2'插值到数字'7'
    # 首先找到测试集中标签为2和7的样本
    indices_2 = np.where(labels_list == 2)[0][:2]
    indices_7 = np.where(labels_list == 7)[0][:2]
    
    # 获取它们的潜向量
    z_2 = torch.tensor(latent_vectors[indices_2[0]]).unsqueeze(0).to(device).float()
    z_7 = torch.tensor(latent_vectors[indices_7[0]]).unsqueeze(0).to(device).float()
    
    # 插值生成图像
    interpolated = interpolate_latent_vectors(model, z_2, z_7, steps=10)

# 可视化插值序列
fig, axes = plt.subplots(1, 10, figsize=(15, 3))
for i in range(10):
    axes[i].imshow(interpolated[i], cmap='gray')
    axes[i].axis('off')
    if i == 0:
        axes[i].set_title('起点 (数字 2)')
    elif i == 9:
        axes[i].set_title('终点 (数字 7)')
plt.suptitle('潜空间线性插值:从数字2渐变到数字7', fontsize=14)
plt.show()

你会看到一个数字平滑地 morphing 成另一个数字的过程。如果中间某些图像看起来像“3”或“5”,那说明潜空间的流形结构是连续的,并且解码器学会了如何从潜空间的任何一点生成合理的图像。这是理解更高级生成模型(如VAE、GAN)的重要基础。

6. 进阶与实战:卷积自动编码器与异常检测

我们之前构建的是全连接自动编码器,它对图像的空间局部性利用不足。对于图像数据,卷积自动编码器是更自然、更强大的选择。它使用卷积层作为编码器,转置卷积层作为解码器,能更好地保留图像的空间结构。

class ConvAutoencoder(nn.Module):
    def __init__(self, latent_dim=32):
        super(ConvAutoencoder, self).__init__()
        
        # 编码器: [B, 1, 28, 28] -> [B, latent_dim]
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 16, 3, stride=2, padding=1),  # [B, 16, 14, 14]
            nn.ReLU(True),
            nn.Conv2d(16, 32, 3, stride=2, padding=1), # [B, 32, 7, 7]
            nn.ReLU(True),
            nn.Conv2d(32, 64, 3, stride=2, padding=1), # [B, 64, 4, 4] (28->14->7->4)
            nn.ReLU(True),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, latent_dim)
        )
        
        # 解码器: [B, latent_dim] -> [B, 1, 28, 28]
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 64 * 4 * 4),
            nn.Unflatten(1, (64, 4, 4)),  # 重塑为特征图
            nn.ReLU(True),
            nn.ConvTranspose2d(64, 32, 3, stride=2, padding=1, output_padding=0), # [B, 32, 7, 7]
            nn.ReLU(True),
            nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1), # [B, 16, 14, 14]
            nn.ReLU(True),
            nn.ConvTranspose2d(16, 1, 3, stride=2, padding=1, output_padding=1),  # [B, 1, 28, 28]
            nn.Sigmoid()
        )
    
    def forward(self, x):
        latent = self.encoder(x)
        reconstructed = self.decoder(latent)
        return reconstructed, latent

# 实例化卷积自动编码器
conv_model = ConvAutoencoder(latent_dim=32).to(device)
print(conv_model)

卷积自动编码器通常能获得更好的重建质量,尤其是边缘和纹理细节。你可以用同样的训练流程来训练它,并比较两者的重建效果和潜空间特性。

自动编码器的一个经典实战应用是异常检测。其逻辑是:模型在正常数据上训练,学习重建正常样本。当遇到异常样本时,由于其特征与训练数据分布不同,模型的重建误差会显著增高。

def compute_reconstruction_error(model, dataloader, device):
    """计算整个数据集的平均重建误差"""
    model.eval()
    total_error = 0
    total_samples = 0
    with torch.no_grad():
        for data, _ in dataloader:
            data = data.to(device)
            reconstructed, _ = model(data)
            # 逐样本计算MSE
            error = torch.mean((reconstructed - data) ** 2, dim=[1,2,3])  # [batch_size]
            total_error += error.sum().item()
            total_samples += data.size(0)
    return total_error / total_samples

# 计算MNIST测试集的“正常”误差基准
normal_error = compute_reconstruction_error(model, test_loader, device)
print(f"MNIST测试集平均重建误差: {normal_error:.6f}")

# 模拟异常检测:用Fashion-MNIST作为“异常”数据
fashion_transform = transforms.Compose([transforms.ToTensor()])
fashion_test = datasets.FashionMNIST(root='./data', train=False, download=True, transform=fashion_transform)
fashion_loader = DataLoader(fashion_test, batch_size=128, shuffle=False)

# 计算Fashion-MNIST的重建误差
anomaly_error = compute_reconstruction_error(model, fashion_loader, device)
print(f"Fashion-MNIST(异常)平均重建误差: {anomaly_error:.6f}")
print(f"异常误差是正常误差的 {anomaly_error/normal_error:.2f} 倍")

你会发现,模型在没见过的Fashion-MNIST数据上的重建误差远高于手写数字。在实际工业场景中,比如检测生产线上的缺陷产品,我们可以用大量正常产品图像训练自动编码器,然后设定一个误差阈值。当某个产品的重建误差超过阈值时,就将其标记为潜在异常。

7. 避坑指南与性能调优

在项目实践中,我遇到过几个常见的坑。首先是潜空间维度的选择。如果维度太高,模型可能学不到紧凑表示(只是恒等映射);如果太低,信息丢失严重,重建质量会很差。一个经验法则是从输入维度的5%-10%开始尝试。对于784维的MNIST,32维(约4%)是个不错的起点。

其次是激活函数。除了ReLU,你也可以在编码器输出层尝试Tanh,将潜空间约束在[-1,1]区间,有时能使空间更规整。解码器最后一层必须根据输入数据范围选择:二值数据用Sigmoid,归一化到[-1,1]的数据用Tanh,普通实数数据有时直接用线性层。

梯度消失/爆炸在较深的自动编码器中也可能出现。除了使用ReLU、BatchNorm外,还可以考虑残差连接:

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        self.downsample = None
        if stride != 1 or in_channels != out_channels:
            self.downsample = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 1, stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
    
    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        
        if self.downsample is not None:
            identity = self.downsample(x)
        
        out += identity
        out = self.relu(out)
        return out

将这样的残差块融入编码器和解码器,可以构建更深的网络而不担心梯度问题。

最后是评估指标。除了损失函数,对于图像生成质量,可以定期人工检查重建样本,或计算结构相似性指数等感知指标。对于潜空间的质量,可以训练一个简单的分类器(如SVM)在潜向量上分类,用分类准确率间接衡量潜空间的特征判别力。

折腾完这些,你可能已经得到了一个重建效果不错的模型。但自动编码器真正的魅力在于,它是通往更复杂世界的跳板。理解了它如何学习数据的压缩表示,你就能更好地理解变分自动编码器如何引入概率生成,去噪自动编码器如何提升鲁棒性,以及它在推荐系统、特征提取等领域的实际应用。下次当你面对高维数据不知所措时,不妨想想这个简单的编码-解码框架,它或许能为你打开一扇新的门。

威联通QNAP使用acme.sh工具自动续签到期SSL证书 acme.sh功能及特点:1.自动续签更新证书;2.支持证书更新通知(QQ、Dingtalk钉钉、Telegra–m、Email等)申请证书方式(分为http和dns两种):1.http方式不适合于NAS使用,该方式需要通过80、443端口验证域名访问状态,而国,,,内—网络环境因素一般家用宽带是不给用80、443等端口的。2.dns方式。 阅读详情

相关推荐

威联通NAS结合阿里云实现安全远程访问:域名与SSL证书全攻略

本文详细介绍了如何为威联通NAS配置专属域名和SSL证书,实现安全便捷的远程访问。通过阿里云注册域名、利用DDNS Docker容器实现动态解析,并部署免费SSL证书加密连接,将家庭NAS升级为可安全访问的个人云。方案成本低、步骤清晰,有效解决了动态IP和传输安全两大核心问题。

t1u2v的博客 467

威联通配置ssl证书和plex配置证书

在证书绑定域名那里填写你自己需要申请证书的域名,其他的不用更改,然后点击提交审核,过个10 分钟差不多能审核完成。安装的可能用不了下面这些步骤,直接把证书文件放到nas中,然后找到此文件的真实路径,在plex里面填写上就可以了。下载完成之后你会得到一个压缩包,把两个文件解压出来,放到你能找到的地方。域名使用权),我这里用的是阿里云的域名。,点击创建证书,会在下面出来一个申请一条信息(2号框框),然后点击。plex是在官网下载的最新版的包安装的。​ 下载的阿里云的证书文件。

qq_39818681的博客 3832

PyTorch生成式人工智能(17)——变分自编码器详解与实现

变分自编码器 (Variational Auto-Encoder, VAE) 是对自编码器 (AutoEncoder, AE) 的改进,通过将输入编码为潜空间中的概率分布而非固定点,解决了 AE 在生成新样本和输入插值方面的局限性。VAE 的损失函数包含重建损失和 KL 散度,后者确保潜空间接近标准正态分布,从而生成连续且可解释的潜表示。本文从零开始构建了一个用于生成人脸图像的 VAE 模型,使用卷积神经网络作为编码器和解码器,并在 eyeglasses 数据集上进行训练。

盼小辉丶的博客 2873

威联通(qnap)组装 + ipv6获取 + 阿里云ddns + 外网访问 + 千兆网卡100M显示问题解决

威联通(qnap)搭建,ipv6 地址获取、电信光猫超级管理员密码获取、阿里云域名+ ipv6 ddns 解析配置、千兆网卡100M网速解决方法

flyaaa123的博客 2万+

从零开始大模型开发与微调:MNIST数据集的准备

随着深度学习技术的快速发展,大型预训练模型成为了推动人工智能领域进步的重要力量。这些模型通常具有庞大的参数量和出色的性能,但在实际应用中,往往需要对这些模型进行微调以适应特定任务或数据集。微调过程不仅可以提高模型的性能,还能节省训练新模型所需的时间和资源。MNIST数据集因其简单且广泛用于验证机器学习算法的特性,成为了一个理想的实验平台,尤其适合探索如何从零开始构建和微调大模型。微调策略的核心在于利用预训练模型的权重,通过仅训练最后几层(或某些特定层)来适应特定任务。

AI大模型应用之禅 1226

人工智能大模型原理与应用实战:从Autoencoder到Variational Autoencoder

作者:禅与计算机程序设计艺术 1.背景介绍 随着深度学习的火热,人们越来越关注如何利用数据驱动的方式训练高效的神经网络模型,提升模型的预测精度、泛化能力及拟合速度。但同时,由于高维数据的复杂性,传统机器学习方法对于处理高维数据的效果也并不尽如人意。因此,近年来,基于深度学习的大型模型被广泛用于解决图

AI天才研究院 580

用Python手把手教你实现一个深度自动编码器(附完整代码)

本文手把手教你使用Python和PyTorch实现一个深度自动编码器(Deep Autoencoder),涵盖从环境搭建、数据预处理、网络构建(全连接与卷积两种架构)到训练策略、损失函数选择及模型评估可视化的完整流程。通过MNIST数据集实战,详细解析了编码器与解码器的设计、防止过拟合的技巧以及潜在空间的应用,为数据降维、特征提取和图像生成等任务提供实用代码指南。

meat5的博客 167

利用阿里云解析api实现DDNS

对于个人研发者来说购买高性能的阿里云等服务器价格偏高,实际利用率也不高,所以最近一直在研究intel nuc。功耗低省电,还能客串家用客厅系统,一举多得。 但是问题来了,我的域名是在万网(被阿里云收购了)购买,家里宽带是联通光线无固定ip。 如何实现动态解析就成了首要问题,本来打算通过dnspod或花生壳这种东西做中转凑副一下, 但这不是我的性格,偶然得知阿里云开通了云解析API并提供了SDK环境,所以说干就干,根据联通宽带的路由方式自己写DDNS算法。 硬件配置如下: 1,联通的光纤虽然是动态分配ip,但是是独享公网ip。这点很重要,有线电视宽带不是独享公网ip,所以本方法不适用。 2,tp-link路由器 3,intel nuc通过路由实现器上网 DDNS程序大体思想如下: 1,轮询当前路由器公网ip是否变更 2,如变更则更新阿域名绑定的 ip 地址 3,如无变更则不做任何操作 4,进入路由器管理页面,选择端口映射,将需要的端口映射到指定ip的指定端口。

Pytorch卷积自动编码器实现

Pytorch卷积自动编码器实现 去发现同类优质开源项目:https://gitcode.com/ 此仓库包含了一个使用Pytorch框架实现的卷积自动编码器(Convolutional Autoencoder)的示例项目。自编码器是一种无监督学习模型,能够学习数据的有效表示。卷积自动编码器利用卷积神经网络的特点,适用于处理图像数据,可以有效地进行图像压缩和特征提取。 本项目详细展示了如何从零开始...

gitblog_06799的博客 413

qnap 计划任务实现阿里云ddns方法

一直想弄个nas来同步自己的3台电脑工作文件+照片备份。 今日趁着某电商打折入了一台QNAP低端设备,想用外网访问和Qsync同步,但由于myqnapcloud.cn的速度不理想,而且也不够逼格,所以自己申请了域名,现在要解决的就是DDNS的问题了, 条件:你家里的网是公网,有自己的域名,我申请的是aliyun的域名,最便宜的那种 进入重点: 1.没有域名的去申请域名,申请完了,建一条A记录 主机记录那里我用的NAS,到时候访问就是nas.域名,如果你想用www.域名。访问你的nas那你主机记录就填写www,IP那里随便添,反正一会是要自动换的,你可以填写0.0.0.0。 2.建立完A记录后,

使用再生龙还原镜像文件到硬盘

1. 把制作好的再生龙光盘插入需要的电脑,开机按F4使用再生龙启动2. 选择默认的:Clonezailla live(Default settings,VGA 800*600),然后等待几分钟 3. 选择语言:简体中文 4. 选择不修改键盘映射 5. 选择使用再生龙          6. 选择硬盘/分区(存到/来自)镜像文件,此选项既可以制作镜像,也可以恢复镜像。 7. 使用本机的分区     ...

weixin_42168893的博客 1万+

更简单的掩码图像建模框架SimMIM介绍和PyTorch代码实现

在本文中,我们介绍 SimMIM,这是一种受掩码建模启发的强大 SSL 算法,其中一部分输入数据被掩码,模型的目标是最小化重建损失。为了更熟悉模型的运行方式我们还是用Pytorch对其进行了实现 ,这样可以帮助我们了解模型的细节。引用:作者:Borna Ahmadzadeh。...

deephub 4734

20个闭环渗透测试项目:从漏洞发现到简历突围

渗透测试不仅是工具使用,更是对系统设计缺陷与实现偏差的深度推演。理解OWASP Top 10、Burp Suite等基础能力只是起点,真正具备工程价值的是能复现、可验证、可协作的完整攻击链。本文聚焦真实业务场景下的SSRF协议绕过、JWT签名机制缺陷、Redis未授权利用、Kong网关配置风险及etcd存储结构分析等核心热词,揭示漏洞本质在于架构决策与配置偏差的叠加态。适用于红队实战、甲方安全建设与乙方渗透审计等多类岗位,帮助从业者将技术动作升维为技术叙事。

weixin_32234493的博客 417

Stable Diffusion实战:5分钟教你用本地GPU跑通文本生成图像(附常见报错解决)

本文详细介绍了如何在本地GPU上快速部署和运行Stable Diffusion,实现文本生成图像的技术。从环境配置、模型加载到生成优化,提供了完整的实战指南,特别针对常见报错问题给出了解决方案,帮助开发者和技术爱好者高效掌握这一深度生成模型的应用。

github5actions的博客 630

深度学习二分类实战:用Python+Keras搞定基因表达数据预测(附完整代码)

本文详细介绍了如何使用Python和Keras构建深度学习模型进行基因表达数据的二分类预测。通过数据预处理、特征选择、神经网络构建及优化策略,特别针对小样本场景提供了调参技巧和模型解释方法。文章还包含完整的代码示例,帮助读者快速掌握深度学习在生物信息学中的应用。

weixin_30642561的博客 246

h5支付不能打开支付宝 ios_iOS支付宝H5支付无法返回APP解决方案

本文前大段在讲楼主是如何解决这个问题的,以及中间遇到的麻烦。赶时间的同学可以直接看最后的 最终解决方案。在讨论之前,我们先看看官方文档上的一句话:注意:在iOS系统中,唤起支付宝App支付完成后,不会自动回到浏览器或商户APP。用户可手工切回到浏览器或商户APP;支付宝H5收银台会自动跳转回商户return_url指定的页面。what? 官方直接跟我们说GG了?楼主不甘心,还是想尝试一下。借鉴之前...

weixin_39864101的博客 856

探索深度学习的魔力:从零开始构建分数基与扩散模型

探索深度学习的魔力:从零开始构建分数基与扩散模型 在这个数字化时代,生成式建模已经成为了人工智能领域的热门话题。开源项目“从零开始的分数基与扩散模型教程”(ScoreDiffusionModel)提供了一个极好的平台,让你深入理解并实践这一领域中的先进算法。该项目由JeongJiHeon和NamYujin两位开发者精心打造,旨在帮助你掌握如NCSN、DDPM、DDIM、VESDE/VPSDE以及L...

gitblog_00048的博客 526

基于Jeecgboot3.9.0的flowable7.2.0流程增加一个OA请假单功能例子(二)

基于Jeecgboot3.9.0的flowable7.2.0流程增加一个OA请假单功能例子(二)

宁波阿成的博客 202

从零开始理解VAE:变分自编码器的原理与实践指南

本文深入浅出地解析了变分自编码器(VAE)的核心原理与实践方法。通过对比传统自动编码器(AE),阐释了VAE如何通过引入概率分布和KL散度,实现从数据压缩到数据生成的跨越。文章详细剖析了重参数化技巧等关键技术难点,并提供了基于PyTorch构建VAE模型生成MNIST数字的完整实战指南,同时讨论了模型局限性与调参经验。

ol78901234的博客 188

【实战项目开发技术分享】ROS1.0、ROS 2.0和CyberRT开源通信框架对比

随着机器人和自动驾驶技术的飞速发展,开源通信框架在机器人、自动驾驶行业扮演着重要的角色。ROS1.0是一个广泛应用于机器人领域的开源框架,ROS 2.0是其改进版本,而CyberRT是Baidu Apollo自动驾驶平台的通信框架。ROS和ROS 2.0都注重灵活性和共享性,适用于各种机器人应用。CyberRT则专注于实时性和高性能,适用于自动驾驶等对实时性要求较高的场景。选择适合的框架取决于具体应用需求和开发者的偏好。

xiewf的博客 2万+

【笔试真题】- 华子-2025.12.17-研发岗

难度:中等难度:中等偏难难度:中等K小姐是一名服务器运维工程师,她负责监控公司服务器的访问日志。服务器采用指数退避策略来优化访问频率,每次重试的时间间隔会按照某种规律增长。经过一段时间的监控,K小姐记录了 nnn 个访问时间点,第 iii 个时间点的值为 a[i]a[i]a[i](可能有重复)。现在,她想分析这些访问时间点是否符合某种特定的模式。具体来说,对于给定的参数对 (x,y)(x, y)(x,y),她想知道:有多少个访问时间点 a[i]a[i]a[i] 满足 a[i]=xK+ya[i] = x^K

春秋招笔试突围 192

基于条件生成对抗网络(cGAN)的角色设计:从父母配色生成彩虹小马新形象

条件生成对抗网络(cGAN)是生成对抗网络(GAN)的重要变体,通过在生成器和判别器中引入额外的条件信息,实现了对生成过程的精确控制。其核心原理在于生成器与判别器的对抗博弈,生成器学习从随机噪声和条件向量中合成数据,而判别器则学习区分真实数据与生成数据,并同时判断其是否符合给定的条件。这项技术的核心价值在于解决了传统GAN生成结果不可控的难题,为图像生成、风格迁移和创意设计等领域提供了强大的工具。在应用场景上,cGAN广泛应用于图像到图像的翻译、文本到图像的生成以及可控的角色设计。本文以《彩虹小马》角色设计

weixin_33912453的博客 436

基于Simulink的加速度计振动分析:单自由度质量-弹簧-阻尼系统

摘要:基于Simulink的加速度计单自由度振动分析 本文研究了加速度计的单自由度(SDOF)质量-弹簧-阻尼系统模型,通过MATLAB/Simulink平台建立了完整的振动分析仿真系统。文章详细阐述了理论建模过程,推导了系统运动微分方程和传递函数,并提供了Simulink模型搭建的具体步骤和MATLAB实现代码。研究通过正弦扫频、随机振动和冲击响应三种典型输入信号,分析了系统的幅频特性、相频特性及时域响应,验证了加速度计的工作机理。仿真结果表明,该方法能有效模拟加速度计在不同激励条件下的动态特性,为传感器

AI的内部世界的博客 164
上一篇: Kaggle实战:用MMDetection+RTMDet搞定夜间摩托车实例分割(附完整代码)
下一篇: GD32F103CBT6时钟配置避坑指南:如何用8MHz晶振稳定输出108MHz系统时钟
随身带U盘
博客等级 码龄4年 31粉丝 1526原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值