AI 助理
备案控制台
开发者社区 ModelScope模型即服务 文章 正文

【Pytorch神经网络实战案例】17 带W散度的WGAN-div模型生成Fashon-MNST模拟数据

2023-05-10 174
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
模型在线服务 PAI-EAS，A10/V100等 500元 1个月
推荐场景：
基于PAI-EAS挂载OSS部署AIGC服务
交互式建模 PAI-DSW，5000CU*H 3个月
推荐场景：
AIGC Stable Diffusion文生图Lora模型微调实现虚拟上装
模型训练 PAI-DLC，5000CU*H 3个月
推荐场景：
低代码 Lora 微调及部署
简介： W散度的损失函数GAN-dv模型使用了W散度来替换W距离的计算方式，将原有的真假样本采样操作换为基于分布层面的计算。

815902569f6a467a99304f9ac1482386.png


1 WGAN-div 简介


W散度的损失函数GAN-dv模型使用了W散度来替换W距离的计算方式，将原有的真假样本采样操作换为基于分布层面的计算。


2 代码实现


在WGAN-gp的基础上稍加改动来实现，重写损失函数的实现。


2.1 代码实战：引入模块并载入样本----WGAN_div_241.py（第1部分）


import torch
import torchvision
from torchvision import transforms
from torch.utils.data import DataLoader
from torch import nn
import torch.autograd as autograd
import matplotlib.pyplot as plt
import numpy as np
import matplotlib
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
# 1.1 引入模块并载入样本:定义基本函数，加载FashionMNIST数据集
def to_img(x):
    x = 0.5 * (x+1)
    x = x.clamp(0,1)
    x = x.view(x.size(0),1,28,28)
    return x
def imshow(img,filename = None):
    npimg = img.numpy()
    plt.axis('off')
    array = np.transpose(npimg,(1,2,0))
    if filename != None:
        matplotlib.image.imsave(filename,array)
    else:
        plt.imshow(array)
        # plt.savefig(filename) # 保存图片 注释掉，因为会报错，暂时不知道什么原因 2022.3.26 15:20
        plt.show()
img_transform = transforms.Compose(
    [
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.5],std=[0.5])
    ]
)
data_dir = './fashion_mnist'
train_dataset = torchvision.datasets.FashionMNIST(data_dir,train=True,transform=img_transform,download=True)
train_loader = DataLoader(train_dataset,batch_size=1024,shuffle=True)
# 测试数据集
val_dataset = torchvision.datasets.FashionMNIST(data_dir,train=False,transform=img_transform)
test_loader = DataLoader(val_dataset,batch_size=10,shuffle=False)
# 指定设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)


2.2 代码实战：实现生成器和判别器----WGAN_div_241.py（第2部分）


# 1.2 实现生成器和判别器 ：因为复杂部分都放在loss值的计算方面了，所以生成器和判别器就会简单一些。
# 生成器和判别器各自有两个卷积和两个全连接层。生成器最终输出与输入图片相同维度的数据作为模拟样本。
# 判别器的输出不需要有激活函数，并且输出维度为1的数值用来表示结果。
# 在GAN模型中，因判别器的输入则是具体的样本数据，要区分每个数据的分布特征，所以判别器使用实例归一化，
class WGAN_D(nn.Module): # 定义判别器类D ：有两个卷积和两个全连接层
    def __init__(self,inputch=1):
        super(WGAN_D, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(inputch,64,4,2,1), # 输出形状为[batch,64,28,28]
            nn.LeakyReLU(0.2,True),
            nn.InstanceNorm2d(64,affine=True)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(64,128,4,2,1),# 输出形状为[batch,64,14,14]
            nn.LeakyReLU(0.2,True),
            nn.InstanceNorm2d(128,affine=True)
        )
        self.fc = nn.Sequential(
            nn.Linear(128*7*7,1024),
            nn.LeakyReLU(0.2,True)
        )
        self.fc2 = nn.Sequential(
            nn.InstanceNorm1d(1,affine=True),
            nn.Flatten(),
            nn.Linear(1024,1)
        )
    def forward(self,x,*arg): # 正向传播
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0),-1)
        x = self.fc(x)
        x = x.reshape(x.size(0),1,-1)
        x = self.fc2(x)
        return x.view(-1,1).squeeze(1)
# 在GAN模型中，因生成器的初始输入是随机值，所以生成器使用批量归一化。
class WGAN_G(nn.Module): # 定义生成器类G：有两个卷积和两个全连接层
    def __init__(self,input_size,input_n=1):
        super(WGAN_G, self).__init__()
        self.fc1 = nn.Sequential(
            nn.Linear(input_size * input_n,1024),
            nn.ReLU(True),
            nn.BatchNorm1d(1024)
        )
        self.fc2 = nn.Sequential(
            nn.Linear(1024,7*7*128),
            nn.ReLU(True),
            nn.BatchNorm1d(7*7*128)
        )
        self.upsample1 = nn.Sequential(
            nn.ConvTranspose2d(128,64,4,2,padding=1,bias=False), # 输出形状为[batch,64,14,14]
            nn.ReLU(True),
            nn.BatchNorm2d(64)
        )
        self.upsample2 = nn.Sequential(
            nn.ConvTranspose2d(64,1,4,2,padding=1,bias=False), # 输出形状为[batch,64,28,28]
            nn.Tanh()
        )
    def forward(self,x,*arg): # 正向传播
        x = self.fc1(x)
        x = self.fc2(x)
        x = x.view(x.size(0),128,7,7)
        x = self.upsample1(x)
        img = self.upsample2(x)
        return img


2.3 代码实战：计算w散度(WGAN-gp基础新增)----WGAN_div_241.py（第3部分）


# 1.3 计算w散度：返回值充当WGAN-gp中的惩罚项，用于计算判别器的损失
def compute_w_div(real_samples,real_out,fake_samples,fake_out):
    # 定义参数
    k = 2
    p = 6
    # 计算真实空间的梯度
    weight = torch.full((real_samples.size(0),),1,device=device)
    real_grad = autograd.grad(outputs=real_out,
                              inputs=real_samples,
                              grad_outputs=weight,
                              create_graph=True,
                              retain_graph=True,
                              only_inputs=True)[0]
    # L2范数
    real_grad_norm = real_grad.view(real_grad.size(0),-1).pow(2).sum(1)
    # 计算模拟空间的梯度
    fake_grad = autograd.grad(outputs=fake_out,
                              inputs=fake_samples,
                              grad_outputs=weight,
                              create_graph=True,
                              retain_graph=True,
                              only_inputs=True)[0]
    # L2范数
    fake_grad_norm = fake_grad.view(fake_grad.size(0),-1).pow(2).sum(1)
    # 计算W散度距离
    div_gp = torch.mean(real_grad_norm **(p/2)+fake_grad_norm**(p/2))*k/2
    return div_gp


2.4 代码实战：定义模型的训练函数(WGAN-gp基础修改)----WGAN_div_241.py（第4部分）


## 1.4 定义模型的训练函数
# 定义函数train()，实现模型的训练过程。
# 在函数train()中，按照对抗神经网络专题（一）中的式（8-24）实现模型的损失函数。
# 判别器的loss为D(fake_samples)-D(real_samples)再加上联合分布样本的梯度惩罚项gradient_penalties，其中fake_samples为生成的模拟数据，real_Samples为真实数据，
# 生成器的loss为-D(fake_samples)。
def train(D,G,outdir,z_dimension,num_epochs=30):
    d_optimizer = torch.optim.Adam(D.parameters(),lr=0.001) # 定义优化器
    g_optimizer = torch.optim.Adam(G.parameters(),lr=0.001)
    os.makedirs(outdir,exist_ok=True) # 创建输出文件夹
    # 在函数train()中，判别器和生成器是分开训练的。让判别器学习的次数多一些，判别器每训练5次，生成器优化1次。
    # WGAN_gp不会因为判别器准确率太高而引起生成器梯度消失的问题，所以好的判别器会让生成器有更好的模拟效果。
    for epoch in range(num_epochs):
        for i,(img,lab) in enumerate(train_loader):
            num_img = img.size(0)
            # 训练判别器
            real_img = img.to(device)
            y_one_hot = torch.zeros(lab.shape[0],10).scatter_(1,lab.view(lab.shape[0],1),1).to(device)
            for ii in range(5): # 循环训练5次
                d_optimizer.zero_grad() # 梯度清零
                real_img = real_img.requires_grad_(True) # 在WGAN-gp基础上新增，将输入参数real_img设置为可导
                # 对real_img进行判别
                real_out = D(real_img, y_one_hot)
                # 生成随机值
                z = torch.randn(num_img, z_dimension).to(device)
                fake_img = G(z, y_one_hot)  # 生成fake_img
                fake_out = D(fake_img, y_one_hot)  # 对fake_img进行判别
                # 计算梯度惩罚项
                gradient_penalty_div = compute_w_div(real_img, real_out, fake_img, fake_out) # 使用gradient_penalty_div()求梯度
                # 计算判别器的loss
                d_loss = -torch.mean(real_out) + torch.mean(fake_out) + gradient_penalty_div
                d_loss.backward()
                d_optimizer.step()
            # 训练生成器
            for ii in range(1):
                g_optimizer.zero_grad()  # 梯度清0
                z = torch.randn(num_img, z_dimension).to(device)
                fake_img = G(z, y_one_hot)
                fake_out = D(fake_img, y_one_hot)
                g_loss = -torch.mean(fake_out)
                g_loss.backward()
                g_optimizer.step()
        # 输出可视化结果
        fake_images = to_img(fake_img.cpu().data)
        real_images = to_img(real_img.cpu().data)
        rel = torch.cat([to_img(real_images[:10]), fake_images[:10]], axis=0)
        imshow(torchvision.utils.make_grid(rel, nrow=10), os.path.join(outdir, 'fake_images-{}.png'.format(epoch + 1)))
        # 输出训练结果
        print('Epoch [{}/{}], d_loss: {:.6f}, g_loss: {:.6f} ''D real: {:.6f}, D fake: {:.6f}'.format(epoch, num_epochs,
                                                                                                      d_loss.data,
                                                                                                      g_loss.data,
                                                                                                      real_out.data.mean(),
                                                                                                      fake_out.data.mean()))
    # 保存训练模型
    torch.save(G.state_dict(), os.path.join(outdir, 'div-generator.pth'))
    torch.save(D.state_dict(), os.path.join(outdir, 'div-discriminator.pth'))


2.5 代码实战：实现可视化模型结果----WGAN_div_241.py（第5部分）


# 1.5 定义函数，实现可视化模型结果：获取一部分测试数据，显示由模型生成的模拟数据。
def displayAndTest(D,G,z_dimension):    # 可视化结果
    sample = iter(test_loader)
    images, labels = sample.next()
    y_one_hot = torch.zeros(labels.shape[0], 10).scatter_(1,labels.view(labels.shape[0], 1), 1).to(device)
    num_img = images.size(0) # 获取样本个数
    with torch.no_grad():
        z = torch.randn(num_img, z_dimension).to(device) # 生成随机数
        fake_img = G(z, y_one_hot)
    fake_images = to_img(fake_img.cpu().data) # 生成模拟样本
    rel = torch.cat([to_img(images[:10]), fake_images[:10]], axis=0)
    imshow(torchvision.utils.make_grid(rel, nrow=10))
    print(labels[:10])


2.6 代码实战：调用函数并训练模型----WGAN_div_241.py（第6部分）


# 1.6 调用函数并训练模型：实例化判别器和生成器模型，并调用函数进行训练
if __name__ == '__main__':
    z_dimension = 40  # 设置输入随机数的维度
    D = WGAN_D().to(device)  # 实例化判别器
    G = WGAN_G(z_dimension).to(device)  # 实例化生成器
    train(D, G, './w_img', z_dimension) # 训练模型
    displayAndTest(D, G, z_dimension) # 输出可视化


结果：


WGAN-dⅳ模型也会输出非常清晰的模拟样本。在有关WGAN-div的论文中，曾拿WGAN-div模型与WGAN-gp模型进行比较，发现WGAN-diⅳ模型的FID分数更高一些（FID是评价GAN生成图片质量的一种指标)。



0799060c29fa43aea80bc4b12a5a13d9.png


1003546381f5465f903ab82abeb8b0ac.png


3 代码总览（WGAN_div_241.py）


import torch
import torchvision
from torchvision import transforms
from torch.utils.data import DataLoader
from torch import nn
import torch.autograd as autograd
import matplotlib.pyplot as plt
import numpy as np
import matplotlib
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
# 1.1 引入模块并载入样本:定义基本函数，加载FashionMNIST数据集
def to_img(x):
    x = 0.5 * (x+1)
    x = x.clamp(0,1)
    x = x.view(x.size(0),1,28,28)
    return x
def imshow(img,filename = None):
    npimg = img.numpy()
    plt.axis('off')
    array = np.transpose(npimg,(1,2,0))
    if filename != None:
        matplotlib.image.imsave(filename,array)
    else:
        plt.imshow(array)
        # plt.savefig(filename) # 保存图片 注释掉，因为会报错，暂时不知道什么原因 2022.3.26 15:20
        plt.show()
img_transform = transforms.Compose(
    [
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.5],std=[0.5])
    ]
)
data_dir = './fashion_mnist'
train_dataset = torchvision.datasets.FashionMNIST(data_dir,train=True,transform=img_transform,download=True)
train_loader = DataLoader(train_dataset,batch_size=1024,shuffle=True)
# 测试数据集
val_dataset = torchvision.datasets.FashionMNIST(data_dir,train=False,transform=img_transform)
test_loader = DataLoader(val_dataset,batch_size=10,shuffle=False)
# 指定设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
# 1.2 实现生成器和判别器 ：因为复杂部分都放在loss值的计算方面了，所以生成器和判别器就会简单一些。
# 生成器和判别器各自有两个卷积和两个全连接层。生成器最终输出与输入图片相同维度的数据作为模拟样本。
# 判别器的输出不需要有激活函数，并且输出维度为1的数值用来表示结果。
# 在GAN模型中，因判别器的输入则是具体的样本数据，要区分每个数据的分布特征，所以判别器使用实例归一化，
class WGAN_D(nn.Module): # 定义判别器类D ：有两个卷积和两个全连接层
    def __init__(self,inputch=1):
        super(WGAN_D, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(inputch,64,4,2,1), # 输出形状为[batch,64,28,28]
            nn.LeakyReLU(0.2,True),
            nn.InstanceNorm2d(64,affine=True)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(64,128,4,2,1),# 输出形状为[batch,64,14,14]
            nn.LeakyReLU(0.2,True),
            nn.InstanceNorm2d(128,affine=True)
        )
        self.fc = nn.Sequential(
            nn.Linear(128*7*7,1024),
            nn.LeakyReLU(0.2,True)
        )
        self.fc2 = nn.Sequential(
            nn.InstanceNorm1d(1,affine=True),
            nn.Flatten(),
            nn.Linear(1024,1)
        )
    def forward(self,x,*arg): # 正向传播
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0),-1)
        x = self.fc(x)
        x = x.reshape(x.size(0),1,-1)
        x = self.fc2(x)
        return x.view(-1,1).squeeze(1)
# 在GAN模型中，因生成器的初始输入是随机值，所以生成器使用批量归一化。
class WGAN_G(nn.Module): # 定义生成器类G：有两个卷积和两个全连接层
    def __init__(self,input_size,input_n=1):
        super(WGAN_G, self).__init__()
        self.fc1 = nn.Sequential(
            nn.Linear(input_size * input_n,1024),
            nn.ReLU(True),
            nn.BatchNorm1d(1024)
        )
        self.fc2 = nn.Sequential(
            nn.Linear(1024,7*7*128),
            nn.ReLU(True),
            nn.BatchNorm1d(7*7*128)
        )
        self.upsample1 = nn.Sequential(
            nn.ConvTranspose2d(128,64,4,2,padding=1,bias=False), # 输出形状为[batch,64,14,14]
            nn.ReLU(True),
            nn.BatchNorm2d(64)
        )
        self.upsample2 = nn.Sequential(
            nn.ConvTranspose2d(64,1,4,2,padding=1,bias=False), # 输出形状为[batch,64,28,28]
            nn.Tanh()
        )
    def forward(self,x,*arg): # 正向传播
        x = self.fc1(x)
        x = self.fc2(x)
        x = x.view(x.size(0),128,7,7)
        x = self.upsample1(x)
        img = self.upsample2(x)
        return img
# 1.3 计算w散度：返回值充当WGAN-gp中的惩罚项，用于计算判别器的损失
def compute_w_div(real_samples,real_out,fake_samples,fake_out):
    # 定义参数
    k = 2
    p = 6
    # 计算真实空间的梯度
    weight = torch.full((real_samples.size(0),),1,device=device)
    real_grad = autograd.grad(outputs=real_out,
                              inputs=real_samples,
                              grad_outputs=weight,
                              create_graph=True,
                              retain_graph=True,
                              only_inputs=True)[0]
    # L2范数
    real_grad_norm = real_grad.view(real_grad.size(0),-1).pow(2).sum(1)
    # 计算模拟空间的梯度
    fake_grad = autograd.grad(outputs=fake_out,
                              inputs=fake_samples,
                              grad_outputs=weight,
                              create_graph=True,
                              retain_graph=True,
                              only_inputs=True)[0]
    # L2范数
    fake_grad_norm = fake_grad.view(fake_grad.size(0),-1).pow(2).sum(1)
    # 计算W散度距离
    div_gp = torch.mean(real_grad_norm **(p/2)+fake_grad_norm**(p/2))*k/2
    return div_gp
## 1.4 定义模型的训练函数
# 定义函数train()，实现模型的训练过程。
# 在函数train()中，按照对抗神经网络专题（一）中的式（8-24）实现模型的损失函数。
# 判别器的loss为D(fake_samples)-D(real_samples)再加上联合分布样本的梯度惩罚项gradient_penalties，其中fake_samples为生成的模拟数据，real_Samples为真实数据，
# 生成器的loss为-D(fake_samples)。
def train(D,G,outdir,z_dimension,num_epochs=30):
    d_optimizer = torch.optim.Adam(D.parameters(),lr=0.001) # 定义优化器
    g_optimizer = torch.optim.Adam(G.parameters(),lr=0.001)
    os.makedirs(outdir,exist_ok=True) # 创建输出文件夹
    # 在函数train()中，判别器和生成器是分开训练的。让判别器学习的次数多一些，判别器每训练5次，生成器优化1次。
    # WGAN_gp不会因为判别器准确率太高而引起生成器梯度消失的问题，所以好的判别器会让生成器有更好的模拟效果。
    for epoch in range(num_epochs):
        for i,(img,lab) in enumerate(train_loader):
            num_img = img.size(0)
            # 训练判别器
            real_img = img.to(device)
            y_one_hot = torch.zeros(lab.shape[0],10).scatter_(1,lab.view(lab.shape[0],1),1).to(device)
            for ii in range(5): # 循环训练5次
                d_optimizer.zero_grad() # 梯度清零
                real_img = real_img.requires_grad_(True) # 在WGAN-gp基础上新增，将输入参数real_img设置为可导
                # 对real_img进行判别
                real_out = D(real_img, y_one_hot)
                # 生成随机值
                z = torch.randn(num_img, z_dimension).to(device)
                fake_img = G(z, y_one_hot)  # 生成fake_img
                fake_out = D(fake_img, y_one_hot)  # 对fake_img进行判别
                # 计算梯度惩罚项
                gradient_penalty_div = compute_w_div(real_img, real_out, fake_img, fake_out) # 求梯度
                # 计算判别器的loss
                d_loss = -torch.mean(real_out) + torch.mean(fake_out) + gradient_penalty_div
                d_loss.backward()
                d_optimizer.step()
            # 训练生成器
            for ii in range(1):
                g_optimizer.zero_grad()  # 梯度清0
                z = torch.randn(num_img, z_dimension).to(device)
                fake_img = G(z, y_one_hot)
                fake_out = D(fake_img, y_one_hot)
                g_loss = -torch.mean(fake_out)
                g_loss.backward()
                g_optimizer.step()
        # 输出可视化结果
        fake_images = to_img(fake_img.cpu().data)
        real_images = to_img(real_img.cpu().data)
        rel = torch.cat([to_img(real_images[:10]), fake_images[:10]], axis=0)
        imshow(torchvision.utils.make_grid(rel, nrow=10), os.path.join(outdir, 'fake_images-{}.png'.format(epoch + 1)))
        # 输出训练结果
        print('Epoch [{}/{}], d_loss: {:.6f}, g_loss: {:.6f} ''D real: {:.6f}, D fake: {:.6f}'.format(epoch, num_epochs,
                                                                                                      d_loss.data,
                                                                                                      g_loss.data,
                                                                                                      real_out.data.mean(),
                                                                                                      fake_out.data.mean()))
    # 保存训练模型
    torch.save(G.state_dict(), os.path.join(outdir, 'div-generator.pth'))
    torch.save(D.state_dict(), os.path.join(outdir, 'div-discriminator.pth'))
# 1.5 定义函数，实现可视化模型结果：获取一部分测试数据，显示由模型生成的模拟数据。
def displayAndTest(D,G,z_dimension):    # 可视化结果
    sample = iter(test_loader)
    images, labels = sample.next()
    y_one_hot = torch.zeros(labels.shape[0], 10).scatter_(1,labels.view(labels.shape[0], 1), 1).to(device)
    num_img = images.size(0) # 获取样本个数
    with torch.no_grad():
        z = torch.randn(num_img, z_dimension).to(device) # 生成随机数
        fake_img = G(z, y_one_hot)
    fake_images = to_img(fake_img.cpu().data) # 生成模拟样本
    rel = torch.cat([to_img(images[:10]), fake_images[:10]], axis=0)
    imshow(torchvision.utils.make_grid(rel, nrow=10))
    print(labels[:10])
# 1.6 调用函数并训练模型：实例化判别器和生成器模型，并调用函数进行训练
if __name__ == '__main__':
    z_dimension = 40  # 设置输入随机数的维度
    D = WGAN_D().to(device)  # 实例化判别器
    G = WGAN_G(z_dimension).to(device)  # 实例化生成器
    train(D, G, './w_img', z_dimension) # 训练模型
    displayAndTest(D, G, z_dimension) # 输出可视化


文章标签：
函数计算
机器学习/深度学习
算法框架/工具
数据可视化
PyTorch
关键词：
网络模型
网络案例
pytorch神经网络
神经网络数据
pytorch实战
相关实践学习
【文生图】一键部署Stable Diffusion基于函数计算
本实验教你如何在函数计算FC上从零开始部署Stable Diffusion来进行AI绘画创作，开启AIGC盲盒。函数计算提供一定的免费额度供用户使用。本实验答疑钉钉群：29290019867
建立 Serverless 思维
本课程包括： Serverless 应用引擎的概念， 为开发者带来的实际价值， 以及让您了解常见的 Serverless 架构模式
LiBiGo
目录
相关文章
AI之家
|
2天前
|
机器学习/深度学习 人工智能 PyTorch
【深度学习】使用PyTorch构建神经网络：深度学习实战指南
PyTorch是一个开源的Python机器学习库，特别专注于深度学习领域。它由Facebook的AI研究团队开发并维护，因其灵活的架构、动态计算图以及在科研和工业界的广泛支持而受到青睐。PyTorch提供了强大的GPU加速能力，使得在处理大规模数据集和复杂模型时效率极高。
AI之家
112 59
BetterBench
|
12天前
|
算法 前端开发 数据挖掘
【类脑智能】脑网络通信模型分类及量化指标(附思维导图)
本文概述了脑网络通信模型的分类、算法原理及量化指标，介绍了扩散过程、路由协议和参数模型三种通信模型，并详细讨论了它们的性能指标、优缺点以及在脑网络研究中的应用，同时提供了思维导图以帮助理解这些概念。
BetterBench
13 3
【类脑智能】脑网络通信模型分类及量化指标(附思维导图)
游客mldfis24krfue
|
22小时前
|
Kubernetes 负载均衡 安全
在k8S中，网络模型概念是什么？
在k8S中，网络模型概念是什么？
游客mldfis24krfue
12 6
python编程狮
|
12天前
|
机器学习/深度学习 前端开发 数据挖掘
基于Python Django的房价数据分析平台，包括大屏和后台数据管理，有线性、向量机、梯度提升树、bp神经网络等模型
本文介绍了一个基于Python Django框架开发的房价数据分析平台，该平台集成了多种机器学习模型，包括线性回归、SVM、GBDT和BP神经网络，用于房价预测和市场分析，同时提供了前端大屏展示和后台数据管理功能。
python编程狮
40 9
LDG_AGI
|
6天前
|
机器学习/深度学习 PyTorch TensorFlow
【PyTorch】PyTorch深度学习框架实战（一）：实现你的第一个DNN网络
【PyTorch】PyTorch深度学习框架实战（一）：实现你的第一个DNN网络
LDG_AGI
30 1
LDG_AGI
|
6天前
|
机器学习/深度学习 人工智能 PyTorch
AI智能体研发之路-模型篇（五）：pytorch vs tensorflow框架DNN网络结构源码级对比
AI智能体研发之路-模型篇（五）：pytorch vs tensorflow框架DNN网络结构源码级对比
LDG_AGI
20 1
WCGhost-Netsafe
|
14天前
|
机器学习/深度学习 PyTorch 算法框架/工具
PyTorch代码实现神经网络
这段代码示例展示了如何在PyTorch中构建一个基础的卷积神经网络（CNN）。该网络包括两个卷积层，分别用于提取图像特征，每个卷积层后跟一个池化层以降低空间维度；之后是三个全连接层，用于分类输出。此结构适用于图像识别任务，并可根据具体应用调整参数与层数。
WCGhost-Netsafe
45 9
服务端技术栈
|
6天前
|
消息中间件 网络协议 Java
你不得不了解的网络IO模型知识
该文章主要讲述了网络I/O模型的相关知识，包括不同的I/O模型以及它们的特点和应用场景。
服务端技术栈
15 0
你不得不了解的网络IO模型知识
yinying293
|
11天前
|
网络协议 Java 关系型数据库
16 Java网络编程（计算机网络+网络模型OSI/TCP/IP+通信协议等）
16 Java网络编程（计算机网络+网络模型OSI/TCP/IP+通信协议等）
yinying293
41 2
软工菜鸡
|
1天前
|
机器学习/深度学习 API 异构计算
7.1.3.2、使用飞桨实现基于LSTM的情感分析模型的网络定义
该文章详细介绍了如何使用飞桨框架实现基于LSTM的情感分析模型，包括网络定义、模型训练、评估和预测的完整流程，并提供了相应的代码实现。
软工菜鸡
10 0

ModelScope模型即服务

热门文章

最新文章

  • 1
    未来语音交互新纪元：FunAudioLLM技术揭秘与深度评测
  • 2
    multi-agent：多角色Agent协同合作，高效完成复杂任务
  • 3
    Llama 3开源！魔搭社区手把手带你推理，部署，微调和评估
  • 4
    阿里云通义千问向全社会开放！
  • 5
    vanna+qwen实现私有模型的SQL转换
  • 6
    开源版图生视频I2VGen-XL：单张图片生成高质量视频
  • 7
    大模型时代，还缺一只雨燕 ｜ SWIFT：魔搭社区轻量级微调推理框架
  • 8
    多模态AI单词助记模型体验
  • 9
    Phi-3：小模型，大未来！（附魔搭社区推理、微调实战教程）
  • 10
    【RAG实践】Rerank，让RAG更近一步
  • 1
    hyengine 编译问题之结果入栈如何解决
    4
  • 2
    hyengine 编译问题之创建对象异常如何解决
    5
  • 3
    hyengine 编译问题之对象存储入栈如何解决
    5
  • 4
    hyengine 优化问题之特征匹配优化如何解决
    4
  • 5
    hyengine 编译问题之性能优化瓶颈如何解决
    4
  • 6
    hyengine 优化问题之代码耗时如何解决
    5
  • 7
    hyengine 寄存器问题之提升代码性能如何解决
    5
  • 8
    hyengine 寄存器问题之传递参数和接收返回值如何解决
    6
  • 9
    hyengine 代码块问题之跳转目标地址如何解决
    5
  • 10
    hyengine 编译问题之性能差距如何解决
    5

    • 相关课程

    更多
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 云网络白皮书-阿里云网络系列课
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 网络管理者必知-2分钟了解新出台的《网络安全法》
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • Keynote：阿里云网络领域关键创新技术解读
  • 基于神经网络的语言合成
  • 机器能理解上下文吗-RNN和LSTM神经网络的原理及应用

    • 相关实验场景

    更多
  • 使用PAI-快速开始，低代码实现大语言模型微调和部署
  • 如何快速训练大模型
  • AIGC Stable Diffusion文生图Lora模型微调实现虚拟上装
  • 容器的网络入门
  • 容器的自定义网络
  • 容器的共享网络模型

    • 推荐镜像

    更多
  • pytorch-wheels
  • nvidia-cuda
  • blender
    • 下一篇
    通义千问API入门教程