企业官网建设流程全解析

中建国际建设有限公司网站,网址怎么申请注册,wordpress描述,当前网站开发用什么软件标题 引言生成式AI基础什么是生成模型#xff1f; 生成对抗网络#xff08;GAN#xff09;GAN的基本原理DCGAN#xff1a;深度卷积生成对抗网络 改进的GAN变体WGAN#xff08;Wasserstein GAN#xff09; 扩散模型#xff08;Diffusion Models#xff09;扩散模型的基本…标题引言生成式AI基础什么是生成模型生成对抗网络GANGAN的基本原理DCGAN深度卷积生成对抗网络改进的GAN变体WGANWasserstein GAN扩散模型Diffusion Models扩散模型的基本原理高级扩散模型技术条件扩散模型实战项目图像去噪比较GAN和扩散模型生成式AI的应用1. 文本到图像生成2. 图像编辑总结未来发展方向实践建议引言生成式人工智能Generative AI是近年来AI领域最引人注目的技术之一它能够创造全新的、以前不存在的内容。从图像生成到文本创作从音乐合成到视频生成生成式AI正在改变我们对创造力的理解。本文将深入探讨两种最重要的生成模型生成对抗网络GAN和扩散模型Diffusion Models。生成式AI基础什么是生成模型生成模型的目标是学习数据的真实分布从而能够生成新的、与训练数据相似但不完全相同的样本。与判别模型用于分类或回归不同生成模型专注于创造和理解数据分布。importnumpyasnpimportmatplotlib.pyplotaspltfromscipy.statsimportmultivariate_normalclassSimpleGenerator:简单的2D数据生成器示例def__init__(self):# 定义两个不同的数据分布self.distribution1multivariate_normal([2,2],[[1,0.5],[0.5,1]])self.distribution2multivariate_normal([-2,-2],[[1,-0.5],[-0.5,1]])defgenerate_samples(self,n_samples,modemixed):生成样本ifmodemixed:# 混合两个分布masknp.random.rand(n_samples)0.5samples1self.distribution1.rvs(np.sum(mask))samples2self.distribution2.rvs(n_samples-np.sum(mask))samplesnp.zeros((n_samples,2))samples[mask]samples1 samples[~mask]samples2elifmodedist1:samplesself.distribution1.rvs(n_samples)else:samplesself.distribution2.rvs(n_samples)returnsamplesdefvisualize_distributions(self):可视化数据分布xnp.linspace(-5,5,100)ynp.linspace(-5,5,100)X,Ynp.meshgrid(x,y)posnp.dstack((X,Y))plt.figure(figsize(12,5))# 分布1plt.subplot(1,2,1)Z1self.distribution1.pdf(pos)plt.contour(X,Y,Z1,levels10,alpha0.8)samples1self.generate_samples(500,dist1)plt.scatter(samples1[:,0],samples1[:,1],alpha0.5,s10)plt.title(Distribution 1)plt.xlabel(X)plt.ylabel(Y)plt.grid(True,alpha0.3)# 分布2plt.subplot(1,2,2)Z2self.distribution2.pdf(pos)plt.contour(X,Y,Z2,levels10,alpha0.8)samples2self.generate_samples(500,dist2)plt.scatter(samples2[:,0],samples2[:,1],alpha0.5,s10)plt.title(Distribution 2)plt.xlabel(X)plt.grid(True,alpha0.3)plt.tight_layout()plt.show()# 创建并可视化生成器generatorSimpleGenerator()generator.visualize_distributions()生成对抗网络GANGAN的基本原理生成对抗网络由Ian Goodfellow在2014年提出包含两个相互竞争的神经网络生成器Generator尝试生成逼真的数据判别器Discriminator区分真实数据和生成数据这两个网络通过博弈论的方式相互对抗共同进步。importtorchimporttorch.nnasnnimporttorch.optimasoptimimporttorch.nn.functionalasFfromtorch.utils.dataimportDataset,DataLoaderclassGenerator(nn.Module):GAN的生成器def__init__(self,input_dim100,output_dim2,hidden_dim128):super(Generator,self).__init__()self.modelnn.Sequential(nn.Linear(input_dim,hidden_dim),nn.LeakyReLU(0.2,inplaceTrue),nn.BatchNorm1d(hidden_dim),nn.Linear(hidden_dim,hidden_dim*2),nn.LeakyReLU(0.2,inplaceTrue),nn.BatchNorm1d(hidden_dim*2),nn.Linear(hidden_dim*2,output_dim),nn.Tanh()# 输出范围[-1, 1])defforward(self,z):returnself.model(z)classDiscriminator(nn.Module):GAN的判别器def__init__(self,input_dim2,hidden_dim128):super(Discriminator,self).__init__()self.modelnn.Sequential(nn.Linear(input_dim,hidden_dim),nn.LeakyReLU(0.2,inplaceTrue),nn.Dropout(0.3),nn.Linear(hidden_dim,hidden_dim*2),nn.LeakyReLU(0.2,inplaceTrue),nn.Dropout(0.3),nn.Linear(hidden_dim*2,1),nn.Sigmoid()# 输出概率)defforward(self,x):returnself.model(x)classGAN:完整的GAN实现def__init__(self,input_dim100,output_dim2,lr0.0002):self.devicetorch.device(cudaiftorch.cuda.is_available()elsecpu)# 创建生成器和判别器self.generatorGenerator(input_dim,output_dim).to(self.device)self.discriminatorDiscriminator(output_dim).to(self.device)# 优化器self.g_optimizeroptim.Adam(self.generator.parameters(),lrlr,betas(0.5,0.999))self.d_optimizeroptim.Adam(self.discriminator.parameters(),lrlr,betas(0.5,0.999))# 损失函数self.criterionnn.BCELoss()# 训练历史self.g_losses[]self.d_losses[]deftrain_step(self,real_data,batch_size):单步训练# 准备真实和假的标签real_labelstorch.ones(batch_size,1).to(self.device)fake_labelstorch.zeros(batch_size,1).to(self.device)# 训练判别器self.d_optimizer.zero_grad()# 真实数据real_datareal_data.to(self.device)real_outputsself.discriminator(real_data)d_loss_realself.criterion(real_outputs,real_labels)# 生成假数据ztorch.randn(batch_size,100).to(self.device)fake_dataself.generator(z)fake_outputsself.discriminator(fake_data.detach())d_loss_fakeself.criterion(fake_outputs,fake_labels)# 判别器总损失d_lossd_loss_reald_loss_fake d_loss.backward()self.d_optimizer.step()# 训练生成器self.g_optimizer.zero_grad()# 生成器希望判别器认为其输出是真实的ztorch.randn(batch_size,100).to(self.device)fake_dataself.generator(z)fake_outputsself.discriminator(fake_data)g_lossself.criterion(fake_outputs,real_labels)g_loss.backward()self.g_optimizer.step()returng_loss.item(),d_loss.item()deftrain(self,real_data_loader,epochs100):训练GANprint(开始训练GAN...)forepochinrange(epochs):epoch_g_loss0epoch_d_loss0forbatch_idx,real_datainenumerate(real_data_loader):g_loss,d_lossself.train_step(real_data,len(real_data))epoch_g_lossg_loss epoch_d_lossd_loss# 记录平均损失self.g_losses.append(epoch_g_loss/len(real_data_loader))self.d_losses.append(epoch_d_loss/len(real_data_loader))ifepoch%100:print(fEpoch{epoch}: G_Loss {self.g_losses[-1]:.4f}, D_Loss {self.d_losses[-1]:.4f})# 定期可视化生成结果ifepoch%200:self.visualize_samples(epoch,real_data_loader.dataset.data)defgenerate_samples(self,n_samples1000):生成样本self.generator.eval()withtorch.no_grad():ztorch.randn(n_samples,100).to(self.device)samplesself.generator(z).cpu().numpy()self.generator.train()returnsamplesdefvisualize_samples(self,epoch,real_data):可视化生成样本与真实数据plt.figure(figsize(12,5))# 真实数据plt.subplot(1,2,1)plt.scatter(real_data[:,0],real_data[:,1],alpha0.5,s10,labelReal Data)plt.title(Real Data Distribution)plt.xlabel(X)plt.ylabel(Y)plt.grid(True,alpha0.3)plt.legend()# 生成数据plt.subplot(1,2,2)generated_samplesself.generate_samples(1000)plt.scatter(generated_samples[:,0],generated_samples[:,1],alpha0.5,s10,cred,labelGenerated Data)plt.title(fGenerated Data (Epoch{epoch}))plt.xlabel(X)plt.ylabel(Y)plt.grid(True,alpha0.3)plt.legend()plt.tight_layout()plt.show()# 准备数据real_datagenerator.generate_samples(2000,mixed)real_datatorch.FloatTensor(real_data)# 创建数据加载器datasettorch.utils.data.TensorDataset(real_data)data_loaderDataLoader(dataset,batch_size64,shuffleTrue)# 创建并训练GANganGAN(input_dim100,output_dim2)gan.train(data_loader,epochs200)# 可视化训练过程plt.figure(figsize(10,5))plt.plot(gan.g_losses,labelGenerator Loss)plt.plot(gan.d_losses,labelDiscriminator Loss)plt.title(GAN Training Loss)plt.xlabel(Epoch)plt.ylabel(Loss)plt.legend()plt.grid(True,alpha0.3)plt.show()# 最终可视化gan.visualize_samples(Final,real_data.numpy())DCGAN深度卷积生成对抗网络DCGAN将卷积神经网络引入GAN用于图像生成任务。classDCGANGenerator(nn.Module):DCGAN生成器用于图像生成def__init__(self,nz100,ngf64,nc3):super(DCGANGenerator,self).__init__()self.mainnn.Sequential(# 输入: nz x 1 x 1nn.ConvTranspose2d(nz,ngf*8,4,1,0,biasFalse),nn.BatchNorm2d(ngf*8),nn.ReLU(True),# 状态: (ngf*8) x 4 x 4nn.ConvTranspose2d(ngf*8,ngf*4,4,2,1,biasFalse),nn.BatchNorm2d(ngf*4),nn.ReLU(True),# 状态: (ngf*4) x 8 x 8nn.ConvTranspose2d(ngf*4,ngf*2,4,2,1,biasFalse),nn.BatchNorm2d(ngf*2),nn.ReLU(True),# 状态: (ngf*2) x 16 x 16nn.ConvTranspose2d(ngf*2,ngf,4,2,1,biasFalse),nn.BatchNorm2d(ngf),nn.ReLU(True),# 状态: (ngf) x 32 x 32nn.ConvTranspose2d(ngf,nc,4,2,1,biasFalse),nn.Tanh()# 输出: nc x 64 x 64)defforward(self,input):returnself.main(input)classDCGANDiscriminator(nn.Module):DCGAN判别器def__init__(self,nc3,ndf64):super(DCGANDiscriminator,self).__init__()self.mainnn.Sequential(# 输入: nc x 64 x 64nn.Conv2d(nc,ndf,4,2,1,biasFalse),nn.LeakyReLU(0.2,inplaceTrue),# 状态: ndf x 32 x 32nn.Conv2d(ndf,ndf*2,4,2,1,biasFalse),nn.BatchNorm2d(ndf*2),nn.LeakyReLU(0.2,inplaceTrue),# 状态: (ndf*2) x 16 x 16nn.Conv2d(ndf*2,ndf*4,4,2,1,biasFalse),nn.BatchNorm2d(ndf*4),nn.LeakyReLU(0.2,inplaceTrue),# 状态: (ndf*4) x 8 x 8nn.Conv2d(ndf*4,ndf*8,4,2,1,biasFalse),nn.BatchNorm2d(ndf*8),nn.LeakyReLU(0.2,inplaceTrue),# 状态: (ndf*8) x 4 x 4nn.Conv2d(ndf*8,1,4,1,0,biasFalse),nn.Sigmoid())defforward(self,input):returnself.main(input).view(-1,1).squeeze(1)# 创建DCGAN示例defcreate_sample_images(generator,n_samples16):生成示例图像generator.eval()withtorch.no_grad():# 生成随机噪声noisetorch.randn(n_samples,100,1,1)# 生成图像generated_imagesgenerator(noise)# 将图像从[-1, 1]转换到[0, 1]generated_images(generated_images1)/2generator.train()returngenerated_images# DCGAN的训练框架classDCGAN:def__init__(self,nz100,ngf64,ndf64,nc3):self.devicetorch.device(cudaiftorch.cuda.is_available()elsecpu)# 创建网络self.netGDCGANGenerator(nz,ngf,nc).to(self.device)self.netDDCGANDiscriminator(nc,ndf).to(self.device)# 初始化权重self.weights_init(self.netG)self.weights_init(self.netD)# 损失函数和优化器self.criterionnn.BCELoss()self.optimizerGoptim.Adam(self.netG.parameters(),lr0.0002,betas(0.5,0.999))self.optimizerDoptim.Adam(self.netD.parameters(),lr0.0002,betas(0.5,0.999))# 固定噪声用于可视化self.fixed_noisetorch.randn(64,nz,1,1,deviceself.device)defweights_init(self,m):自定义权重初始化classnamem.__class__.__name__ifclassname.find(Conv)!-1:nn.init.normal_(m.weight.data,0.0,0.02)elifclassname.find(BatchNorm)!-1:nn.init.normal_(m.weight.data,1.0,0.02)nn.init.constant_(m.bias.data,0)defvisualize_generated(self,epoch):可视化生成的图像withtorch.no_grad():fakeself.netG(self.fixed_noise).detach().cpu()# 将图像从[-1,1]转换到[0,1]fake(fake1)/2plt.figure(figsize(8,8))plt.axis(off)plt.title(fGenerated Images - Epoch{epoch})# 显示8x8网格的图像plt.imshow(np.transpose(torchvision.utils.make_grid(fake,padding2,normalizeTrue),(1,2,0)))plt.show()# 注意实际使用DCGAN需要真实的图像数据集# 这里仅展示框架代码print(DCGAN框架代码已准备就绪需要真实图像数据集进行训练)改进的GAN变体WGANWasserstein GANWGAN通过使用Wasserstein距离代替JS散度来改善训练稳定性。classWGANDiscriminator(nn.Module):WGAN的判别器称为Criticdef__init__(self,input_dim2,hidden_dim128):super(WGANDiscriminator,self).__init__()self.modelnn.Sequential(nn.Linear(input_dim,hidden_dim),nn.LeakyReLU(0.2,inplaceTrue),nn.Linear(hidden_dim,hidden_dim*2),nn.LeakyReLU(0.2,inplaceTrue),nn.Linear(hidden_dim*2,hidden_dim*2),nn.LeakyReLU(0.2,inplaceTrue),nn.Linear(hidden_dim*2,1)# 不使用Sigmoid输出实数值)defforward(self,x):returnself.model(x)classWGAN:Wasserstein GAN实现def__init__(self,input_dim2,latent_dim100,hidden_dim128,lr0.00005):self.devicetorch.device(cudaiftorch.cuda.is_available()elsecpu)# 网络结构self.generatorGenerator(latent_dim,input_dim,hidden_dim).to(self.device)self.criticWGANDiscriminator(input_dim,hidden_dim).to(self.device)# 优化器使用RMSpropself.g_optimizeroptim.RMSprop(self.generator.parameters(),lrlr)self.c_optimizeroptim.RMSprop(self.critic.parameters(),lrlr)# 权重裁剪参数self.clip_value0.01# 训练历史self.g_losses[]self.c_losses[]deftrain_step(self,real_data,batch_size):WGAN训练步骤# 训练Criticn_critic次for_inrange(5):# 通常n_critic5self.c_optimizer.zero_grad()# 真实数据real_datareal_data.to(self.device)real_outputself.critic(real_data)# 生成假数据ztorch.randn(batch_size,100).to(self.device)fake_dataself.generator(z)fake_outputself.critic(fake_data.detach())# Wasserstein损失c_loss-torch.mean(real_output)torch.mean(fake_output)c_loss.backward()self.c_optimizer.step()# 权重裁剪forpinself.critic.parameters():p.data.clamp_(-self.clip_value,self.clip_value)# 训练Generatorself.g_optimizer.zero_grad()ztorch.randn(batch_size,100).to(self.device)fake_dataself.generator(z)fake_outputself.critic(fake_data)# 生成器希望最大化Critic的输出g_loss-torch.mean(fake_output)g_loss.backward()self.g_optimizer.step()returng_loss.item(),c_loss.item()deftrain(self,data_loader,epochs100):训练WGANprint(开始训练WGAN...)forepochinrange(epochs):epoch_g_loss0epoch_c_loss0forreal_dataindata_loader:g_loss,c_lossself.train_step(real_data,len(real_data))epoch_g_lossg_loss epoch_c_lossc_loss self.g_losses.append(epoch_g_loss/len(data_loader))self.c_losses.append(epoch_c_loss/len(data_loader))ifepoch%100:print(fEpoch{epoch}: G_Loss {self.g_losses[-1]:.4f}, C_Loss {self.c_losses[-1]:.4f})# 训练WGANwganWGAN()wgan.train(data_loader,epochs200)# 可视化结果plt.figure(figsize(12,5))plt.subplot(1,2,1)plt.scatter(real_data.numpy()[:,0],real_data.numpy()[:,1],alpha0.5,s10,labelReal)plt.title(Real Data)plt.legend()plt.subplot(1,2,2)generated_sampleswgan.generate_samples(1000)plt.scatter(generated_samples[:,0],generated_samples[:,1],alpha0.5,s10,cred,labelGenerated)plt.title(WGAN Generated Data)plt.legend()plt.show()扩散模型Diffusion Models扩散模型的基本原理扩散模型是一种新兴的生成模型通过逐步添加噪声然后学习逆转这个过程来生成数据。importmathclassDiffusionProcess:扩散过程的前向和反向过程def__init__(self,num_timesteps1000,beta_start1e-4,beta_end0.02):self.num_timestepsnum_timesteps# beta schedule噪声调度self.betastorch.linspace(beta_start,beta_end,num_timesteps)self.alphas1.0-self.betas self.alphas_cumprodtorch.cumprod(self.alphas,axis0)self.alphas_cumprod_prevF.pad(self.alphas_cumprod[:-1],(1,0),value1.0)# 预计算常量self.sqrt_alphas_cumprodtorch.sqrt(self.alphas_cumprod)self.sqrt_one_minus_alphas_cumprodtorch.sqrt(1.0-self.alphas_cumprod)self.sqrt_recip_alphastorch.sqrt(1.0/self.alphas)# 后验方差self.posterior_variance(self.betas*(1.0-self.alphas_cumprod_prev)/(1.0-self.alphas_cumprod))defq_sample(self,x_start,t,noiseNone):前向过程q(x_t | x_0)ifnoiseisNone:noisetorch.randn_like(x_start)sqrt_alphas_cumprod_tself._extract(self.sqrt_alphas_cumprod,t,x_start.shape)sqrt_one_minus_alphas_cumprod_tself._extract(self.sqrt_one_minus_alphas_cumprod,t,x_start.shape)returnsqrt_alphas_cumprod_t*x_startsqrt_one_minus_alphas_cumprod_t*noisedefp_sample(self,model,x,t):反向过程p(x_{t-1} | x_t)# 预测噪声predicted_noisemodel(x,t)# 计算均值sqrt_recip_alphas_tself._extract(self.sqrt_recip_alphas,t,x.shape)betas_tself._extract(self.betas,t,x.shape)sqrt_one_minus_alphas_cumprod_tself._extract(self.sqrt_one_minus_alphas_cumprod,t,x.shape)posterior_variance_tself._extract(self.posterior_variance,t,x.shape)model_meansqrt_recip_alphas_t*(x-betas_t*predicted_noise/sqrt_one_minus_alphas_cumprod_t)ift[0]0:returnmodel_meanelse:noisetorch.randn_like(x)returnmodel_meantorch.sqrt(posterior_variance_t)*noisedef_extract(self,a,t,x_shape):从a中提取特定时间步的值batch_sizet.shape[0]outa.to(t.device).gather(0,t)returnout.reshape(batch_size,*((1,)*(len(x_shape)-1)))# 简单的UNet模型用于扩散模型classSimpleUNet(nn.Module):简化的UNet模型def__init__(self,input_dim2,hidden_dim128):super(SimpleUNet,self).__init__()# 时间嵌入self.time_embednn.Sequential(nn.Linear(128,hidden_dim),nn.SiLU(),nn.Linear(hidden_dim,hidden_dim))# 编码器self.encodernn.Sequential(nn.Linear(input_dimhidden_dim,hidden_dim),nn.SiLU(),nn.Linear(hidden_dim,hidden_dim*2),nn.SiLU(),nn.Linear(hidden_dim*2,hidden_dim*2))# 解码器self.decodernn.Sequential(nn.Linear(hidden_dim*2,hidden_dim*2),nn.SiLU(),nn.Linear(hidden_dim*2,hidden_dim),nn.SiLU(),nn.Linear(hidden_dim,input_dim))deftimestep_embedding(self,timesteps,dim,max_period10000):时间步嵌入halfdim//2freqstorch.exp(-math.log(max_period)*torch.arange(start0,endhalf,dtypetorch.float32)/half).to(timesteps.device)argstimesteps[:,None].float()*freqs[None]embeddingtorch.cat([torch.cos(args),torch.sin(args)],dim-1)ifdim%2:embeddingtorch.cat([embedding,torch.zeros_like(embedding[:,:1])],dim-1)returnembeddingdefforward(self,x,t):# 时间嵌入t_embself.timestep_embedding(t,128)t_embself.time_embed(t_emb)# 拼接输入和时间嵌入xtorch.cat([x,t_emb],dim-1)# 编码hself.encoder(x)# 解码outputself.decoder(h)returnoutputclassDiffusionModel:完整的扩散模型实现def__init__(self,input_dim2,hidden_dim128,num_timesteps1000):self.devicetorch.device(cudaiftorch.cuda.is_available()elsecpu)# 扩散过程self.diffusionDiffusionProcess(num_timesteps)# 噪声预测网络self.modelSimpleUNet(input_dim,hidden_dim).to(self.device)# 优化器self.optimizeroptim.Adam(self.model.parameters(),lr0.001)# 训练历史self.losses[]deftrain_step(self,x0):单步训练# 采样时间步batch_sizex0.shape[0]ttorch.randint(0,self.diffusion.num_timesteps,(batch_size,),deviceself.device)# 添加噪声noisetorch.randn_like(x0)xtself.diffusion.q_sample(x0,t,noise)# 预测噪声predicted_noiseself.model(xt,t)# 计算损失lossF.mse_loss(predicted_noise,noise)# 反向传播self.optimizer.zero_grad()loss.backward()self.optimizer.step()returnloss.item()deftrain(self,data_loader,epochs100):训练扩散模型print(开始训练扩散模型...)forepochinrange(epochs):epoch_loss0forbatchindata_loader:batchbatch[0].to(self.device)lossself.train_step(batch)epoch_lossloss avg_lossepoch_loss/len(data_loader)self.losses.append(avg_loss)ifepoch%100:print(fEpoch{epoch}: Loss {avg_loss:.4f})defsample(self,n_samples1000):从扩散模型采样self.model.eval()withtorch.no_grad():# 从纯噪声开始xtorch.randn(n_samples,2).to(self.device)# 反向扩散过程fortinreversed(range(self.diffusion.num_timesteps)):t_batchtorch.full((n_samples,),t,deviceself.device,dtypetorch.long)xself.diffusion.p_sample(self.model,x,t_batch)self.model.train()returnx.cpu().numpy()defvisualize_diffusion_process(self,data):可视化扩散过程datadata[:1].to(self.device)# 只取一个样本# 采样几个时间步timesteps[0,100,300,500,700,999]plt.figure(figsize(15,3))fori,tinenumerate(timesteps):t_tensortorch.full((1,),t,deviceself.device)xtself.diffusion.q_sample(data,t_tensor)plt.subplot(1,len(timesteps),i1)ift0:plt.scatter(data[0,0].cpu(),data[0,1].cpu(),s100,cblue)plt.title(Original (t0))else:plt.scatter(xt[0,0].cpu(),xt[0,1].cpu(),s100,cred)plt.title(ft{t})plt.xlim(-4,4)plt.ylim(-4,4)plt.grid(True,alpha0.3)plt.suptitle(Forward Diffusion Process)plt.show()# 训练扩散模型diffusion_modelDiffusionModel(input_dim2,hidden_dim128)diffusion_model.train(data_loader,epochs200)# 可视化扩散过程sample_datareal_data[:1]diffusion_model.visualize_diffusion_process(sample_data)# 生成新样本generated_samplesdiffusion_model.sample(1000)# 可视化生成结果plt.figure(figsize(12,5))plt.subplot(1,2,1)plt.scatter(real_data.numpy()[:,0],real_data.numpy()[:,1],alpha0.5,s10,labelReal Data)plt.title(Real Data Distribution)plt.legend()plt.subplot(1,2,2)plt.scatter(generated_samples[:,0],generated_samples[:,1],alpha0.5,s10,cred,labelGenerated)plt.title(Diffusion Model Generated Data)plt.legend()plt.show()# 绘制训练损失plt.figure(figsize(10,5))plt.plot(diffusion_model.losses)plt.title(Diffusion Model Training Loss)plt.xlabel(Epoch)plt.ylabel(MSE Loss)plt.grid(True,alpha0.3)plt.show()高级扩散模型技术条件扩散模型条件扩散模型允许根据条件信息生成数据。classConditionalDiffusionModel(DiffusionModel):条件扩散模型def__init__(self,input_dim2,condition_dim2,hidden_dim128,num_timesteps1000):super().__init__(input_dim,hidden_dim,num_timesteps)self.condition_dimcondition_dim# 条件UNet模型self.modelConditionalUNet(input_dim,condition_dim,hidden_dim).to(self.device)deftrain_step(self,x0,condition):条件训练步骤batch_sizex0.shape[0]ttorch.randint(0,self.diffusion.num_timesteps,(batch_size,),deviceself.device)# 添加噪声noisetorch.randn_like(x0)xtself.diffusion.q_sample(x0,t,noise)# 带条件的噪声预测predicted_noiseself.model(xt,t,condition)lossF.mse_loss(predicted_noise,noise)self.optimizer.zero_grad()loss.backward()self.optimizer.step()returnloss.item()defsample(self,condition,n_samples1):条件采样self.model.eval()withtorch.no_grad():xtorch.randn(n_samples,2).to(self.device)fortinreversed(range(self.diffusion.num_timesteps)):t_batchtorch.full((n_samples,),t,deviceself.device,dtypetorch.long)xself.diffusion.conditional_p_sample(self.model,x,t_batch,condition)self.model.train()returnx.cpu().numpy()classConditionalUNet(nn.Module):条件UNet模型def__init__(self,input_dim,condition_dim,hidden_dim):super(ConditionalUNet,self).__init__()# 时间嵌入self.time_embednn.Sequential(nn.Linear(128,hidden_dim),nn.SiLU(),nn.Linear(hidden_dim,hidden_dim))# 条件嵌入self.condition_embednn.Sequential(nn.Linear(condition_dim,hidden_dim),nn.SiLU(),nn.Linear(hidden_dim,hidden_dim))# 主网络self.networknn.Sequential(nn.Linear(input_dimhidden_dim*2,hidden_dim*2),nn.SiLU(),nn.Linear(hidden_dim*2,hidden_dim*2),nn.SiLU(),nn.Linear(hidden_dim*2,hidden_dim),nn.SiLU(),nn.Linear(hidden_dim,input_dim))deftimestep_embedding(self,timesteps,dim,max_period10000):halfdim//2freqstorch.exp(-math.log(max_period)*torch.arange(start0,endhalf,dtypetorch.float32)/half).to(timesteps.device)argstimesteps[:,None].float()*freqs[None]embeddingtorch.cat([torch.cos(args),torch.sin(args)],dim-1)ifdim%2:embeddingtorch.cat([embedding,torch.zeros_like(embedding[:,:1])],dim-1)returnembeddingdefforward(self,x,t,condition):# 嵌入t_embself.timestep_embedding(t,128)t_embself.time_embed(t_emb)c_embself.condition_embed(condition)# 拼接所有信息xtorch.cat([x,t_emb,c_emb],dim-1)# 通过网络outputself.network(x)returnoutput# 创建条件生成示例print(\n条件扩散模型示例:)print(可以基于给定的条件如类别标签生成特定类型的数据)实战项目图像去噪使用扩散模型进行图像去噪任务。classImageDenoisingDiffusion:图像去噪扩散模型def__init__(self,image_size28,channels1):self.image_sizeimage_size self.channelschannels self.devicetorch.device(cudaiftorch.cuda.is_available()elsecpu)# 扩散过程self.diffusionDiffusionProcess(num_timesteps1000)# UNet架构用于图像self.modelImageUNet(channels,channels).to(self.device)# 优化器self.optimizeroptim.Adam(self.model.parameters(),lr0.0001)defadd_noise(self,images,noise_level0.1):向图像添加噪声noisetorch.randn_like(images)*noise_level noisy_imagesimagesnoisereturnnoisy_images.clamp(-1,1),noisedeftrain(self,clean_images,epochs50):训练去噪模型print(开始训练图像去噪模型...)forepochinrange(epochs):epoch_loss0forbatchinclean_images:batchbatch.to(self.device)# 添加噪声noisy_images,noiseself.add_noise(batch,noise_level0.3)# 训练lossself.train_step(noisy_images,batch)epoch_lossloss avg_lossepoch_loss/len(clean_images)print(fEpoch{epoch}: Loss {avg_loss:.4f})deftrain_step(self,noisy_images,clean_images):单步训练batch_sizenoisy_images.shape[0]ttorch.randint(0,self.diffusion.num_timesteps,(batch_size,),deviceself.device)# 进一步扩散xtself.diffusion.q_sample(clean_images,t)# 添加噪声noisetorch.randn_like(xt)xt_noisyself.diffusion.q_sample(xt,torch.zeros_like(t),noise)# 预测噪声predicted_noiseself.model(xt_noisy,t)lossF.mse_loss(predicted_noise,noise)self.optimizer.zero_grad()loss.backward()self.optimizer.step()returnloss.item()defdenoise(self,noisy_image,num_steps50):去噪图像self.model.eval()withtorch.no_grad():xnoisy_image.unsqueeze(0).to(self.device)# 从高噪声逐步去噪fortinreversed(range(num_steps)):t_batchtorch.full((1,),t,deviceself.device,dtypetorch.long)xself.diffusion.p_sample(self.model,x,t_batch)self.model.train()returnx.squeeze(0).cpu()classImageUNet(nn.Module):用于图像的简化UNetdef__init__(self,in_channels,out_channels):super(ImageUNet,self).__init__()# 编码器self.enc1self.conv_block(in_channels,64)self.enc2self.conv_block(64,128)self.enc3self.conv_block(128,256)# 中间层self.middleself.conv_block(256,512)# 解码器self.dec3self.conv_block(256512,256)self.dec2self.conv_block(128256,128)self.dec1self.conv_block(64128,64)# 输出层self.outnn.Conv2d(64,out_channels,kernel_size1)# 时间嵌入self.time_embednn.Sequential(nn.Linear(128,512),nn.SiLU(),nn.Linear(512,512))defconv_block(self,in_channels,out_channels):returnnn.Sequential(nn.Conv2d(in_channels,out_channels,kernel_size3,padding1),nn.GroupNorm(8,out_channels),nn.SiLU(),nn.Conv2d(out_channels,out_channels,kernel_size3,padding1),nn.GroupNorm(8,out_channels),nn.SiLU())deftimestep_embedding(self,timesteps,dim,max_period10000):halfdim//2freqstorch.exp(-math.log(max_period)*torch.arange(start0,endhalf,dtypetorch.float32)/half).to(timesteps.device)argstimesteps[:,None].float()*freqs[None]embeddingtorch.cat([torch.cos(args),torch.sin(args)],dim-1)ifdim%2:embeddingtorch.cat([embedding,torch.zeros_like(embedding[:,:1])],dim-1)returnembeddingdefforward(self,x,t):# 时间嵌入t_embself.timestep_embedding(t,128)t_embself.time_embed(t_emb)# 编码e1self.enc1(x)e2self.enc2(F.avg_pool2d(e1,2))e3self.enc3(F.avg_pool2d(e2,2))# 中间层middleself.middle(F.avg_pool2d(e3,2))# 解码d3self.dec3(torch.cat([F.interpolate(middle,scale_factor2),e3],dim1))d2self.dec2(torch.cat([F.interpolate(d3,scale_factor2),e2],dim1))d1self.dec1(torch.cat([F.interpolate(d2,scale_factor2),e1],dim1))# 输出returnself.out(d1)# 模拟图像去噪示例print(\n图像去噪扩散模型示例:)print(该模型可以去除图像中的噪声恢复清晰图像)# 创建模拟图像数据defcreate_test_images(n_images10,size28):创建测试图像images[]for_inrange(n_images):# 创建简单的几何形状imgtorch.zeros(1,size,size)# 添加随机形状xnp.random.randint(5,size-5)ynp.random.randint(5,size-5)rnp.random.randint(3,8)cv2.circle(img[0].numpy(),(x,y),r,1.0,-1)images.append(img)returnimages# 生成测试图像test_imagescreate_test_images(5,64)# 添加噪声noisy_images[]noise_level0.3forimgintest_images:noisetorch.randn_like(img)*noise_level noisyimgnoise noisy_images.append(noisy.clamp(-1,1))# 可视化去噪效果plt.figure(figsize(15,5))foriinrange(3):plt.subplot(1,3,i1)plt.imshow(test_images[i][0],cmapgray)plt.title(fClean Image{i1})plt.axis(off)plt.show()plt.figure(figsize(15,5))foriinrange(3):plt.subplot(1,3,i1)plt.imshow(noisy_images[i][0],cmapgray)plt.title(fNoisy Image{i1})plt.axis(off)plt.show()print(扩散模型可以学习从噪声中恢复清晰图像)比较GAN和扩散模型defcompare_models():比较GAN和扩散模型的特性comparison{特性:[训练稳定性,生成质量,采样速度,训练难度,理论保证,并行训练,条件生成,模式崩溃风险],GAN:[中等,高,快,高,弱,是,支持,存在],扩散模型:[高,极高,慢,中等,强,是,支持,极低]}# 打印比较表格print(\nGAN vs 扩散模型比较:)print(-*60)foriinrange(len(comparison[特性])):print(f{comparison[特性][i]:12}| GAN:{comparison[GAN][i]:8}| 扩散:{comparison[扩散模型][i]:8})# 生成质量趋势图plt.figure(figsize(10,5))years[2014,2015,2017,2019,2021,2023]gan_quality[20,40,60,75,85,90]diffusion_quality[0,0,10,50,85,95]plt.plot(years,gan_quality,b-o,labelGAN,linewidth2)plt.plot(years,diffusion_quality,r-s,labelDiffusion Models,linewidth2)plt.title(生成质量发展趋势)plt.xlabel(年份)plt.ylabel(生成质量评分)plt.grid(True,alpha0.3)plt.legend()plt.show()compare_models()生成式AI的应用1. 文本到图像生成classTextToImageGenerator:文本到图像生成器的概念实现def__init__(self):print(文本到图像生成器框架)print(- 需要CLIP模型编码文本)print(- 需要扩散模型生成图像)print(- 需要大规模配对数据集训练)defgenerate_from_text(self,text_prompt):从文本生成图像概念print(f\n生成图像文本提示: {text_prompt})print(步骤1: 使用CLIP编码文本)print(步骤2: 使用扩散模型生成图像)print(步骤3: 调整以匹配文本语义)print([图像生成完成])# 示例t2iTextToImageGenerator()t2i.generate_from_text(一只可爱的小猫坐在花园里)2. 图像编辑classImageEditor:基于生成模型的图像编辑器def__init__(self):self.edit_modes[inpainting,outpainting,style_transfer,image_to_image]defedit_image(self,image,mode,instruction):编辑图像print(f\n编辑模式:{mode})print(f编辑指令:{instruction})print(处理中...)ifmodeinpainting:print(图像修复/填充使用生成模型填充缺失区域)elifmodeoutpainting:print(图像扩展生成超出原始边界的内容)elifmodestyle_transfer:print(风格迁移改变图像的艺术风格)elifmodeimage_to_image:print(图像转换根据指令改变图像内容)print(编辑完成!)# 示例editorImageEditor()editor.edit_image(image.jpg,inpainting,修复图像中的损坏区域)总结本文深入探讨了生成式AI的两种主要技术GAN和扩散模型涵盖了生成模型基础理解生成式AI的核心概念GAN技术从基础GAN到DCGAN、WGAN等改进版本扩散模型新兴的强大生成技术实际应用图像生成、去噪、编辑等任务技术比较GAN和扩散模型的优缺点对比生成式AI正在快速演进从最初简单的GAN到今天强大的扩散模型我们已经能够生成高质量、多样化的内容。未来随着技术的进一步发展生成式AI将在更多领域发挥重要作用。未来发展方向更高效的采样方法加速扩散模型的生成过程多模态生成统一文本、图像、音频、视频的生成可控生成更精确地控制生成内容的属性3D内容生成直接生成3D模型和场景实时生成实现实时的内容生成和编辑实践建议从简单的数据集和模型开始理解数学原理特别是概率论和扩散过程利用预训练模型进行微调注意计算资源需求扩散模型尤其需要大量算力关注伦理问题避免生成有害内容