求一个做美食视频的网站北京市朝阳区最新消息

求一个做美食视频的网站,北京市朝阳区最新消息,网站建设公司 2018,淘宝网站小视频怎么做的Autoencoder与降维技术#xff1a;从PCA到变分自编码器 引言 在处理高维数据时#xff0c;我们经常面临维度灾难的挑战。降维技术能够帮助我们提取数据的核心特征#xff0c;减少计算复杂度#xff0c;同时保留最重要的信息。自编码器#xff08;Autoencoder从PCA到变分自编码器引言在处理高维数据时我们经常面临维度灾难的挑战。降维技术能够帮助我们提取数据的核心特征减少计算复杂度同时保留最重要的信息。自编码器Autoencoder作为一种强大的神经网络架构不仅能实现数据降维还能用于特征学习、数据压缩和异常检测等任务。本文将深入探讨从传统降维方法到现代自编码器的演进过程。传统降维方法主成分分析PCA主成分分析是最经典的无监督降维技术通过线性变换将数据投影到低维空间同时保留最大方差。importnumpyasnpimportmatplotlib.pyplotaspltfromsklearn.datasetsimportmake_blobs,load_digitsfromsklearn.preprocessingimportStandardScalerimporttorchimporttorch.nnasnnimporttorch.optimasoptimclassPCA:主成分分析实现def__init__(self,n_components):self.n_componentsn_components self.componentsNoneself.meanNoneself.explained_varianceNonedeffit(self,X):拟合PCA模型# 中心化数据self.meannp.mean(X,axis0)X_centeredX-self.mean# 计算协方差矩阵cov_matrixnp.cov(X_centered.T)# 特征分解eigenvalues,eigenvectorsnp.linalg.eigh(cov_matrix)# 按特征值降序排序idxnp.argsort(eigenvalues)[::-1]eigenvalueseigenvalues[idx]eigenvectorseigenvectors[:,idx]# 选择前n_components个主成分self.componentseigenvectors[:,:self.n_components]self.explained_varianceeigenvalues[:self.n_components]deftransform(self,X):将数据转换到低维空间X_centeredX-self.meanreturnnp.dot(X_centered,self.components)definverse_transform(self,X_transformed):从低维空间重构原始数据returnnp.dot(X_transformed,self.components.T)self.meandeffit_transform(self,X):拟合并转换数据self.fit(X)returnself.transform(X)defget_explained_variance_ratio(self):获取解释方差比例returnself.explained_variance/np.sum(self.explained_variance)# 示例使用PCA降维# 生成示例数据np.random.seed(42)X,_make_blobs(n_samples500,n_features10,centers3,cluster_std2.0,random_state42)# 标准化数据scalerStandardScaler()X_scaledscaler.fit_transform(X)# 应用PCApcaPCA(n_components2)X_pcapca.fit_transform(X_scaled)# 可视化结果plt.figure(figsize(12,5))plt.subplot(1,2,1)plt.scatter(X[:,0],X[:,1],alpha0.6)plt.title(原始数据前两个特征)plt.xlabel(特征1)plt.ylabel(特征2)plt.subplot(1,2,2)plt.scatter(X_pca[:,0],X_pca[:,1],alpha0.6)plt.title(PCA降维结果)plt.xlabel(主成分1)plt.ylabel(主成分2)plt.tight_layout()plt.show()# 显示解释方差比例explained_ratiopca.get_explained_variance_ratio()print(f前两个主成分解释的方差比例:{explained_ratio})print(f累积解释方差比例:{np.sum(explained_ratio):.2%})t-SNEt-Distributed Stochastic Neighbor Embeddingt-SNE是一种非线性降维技术特别适合可视化高维数据。classTSNE:简化的t-SNE实现def__init__(self,n_components2,perplexity30,learning_rate200,n_iter1000):self.n_componentsn_components self.perplexityperplexity self.learning_ratelearning_rate self.n_itern_iterdef_pairwise_distances(self,X):计算成对距离sum_Xnp.sum(np.square(X),axis1)distancesnp.add(np.add(-2*np.dot(X,X.T),sum_X).T,sum_X)returndistancesdef_compute_pij(self,distances):计算高维空间的联合概率P_ij# 转换为相似度Pnp.exp(-distances/(2*self.perplexity**2))np.fill_diagonal(P,0)# 归一化PP/np.sum(P)returnPdef_compute_qij(self,Y):计算低维空间的联合概率Q_ijdistancesself._pairwise_distances(Y)Q1/(1distances)np.fill_diagonal(Q,0)QQ/np.sum(Q)returnQdeffit_transform(self,X):拟合t-SNE并转换数据n_samplesX.shape[0]# 初始化低维表示Ynp.random.randn(n_samples,self.n_components)*0.0001# 计算高维空间的联合概率distancesself._pairwise_distances(X)Pself._compute_pij(distances)# 优化过程foriterationinrange(self.n_iter):# 计算低维空间的联合概率Qself._compute_qij(Y)# 计算梯度PQP-Qforiinrange(n_samples):gradnp.zeros(self.n_components)forjinrange(n_samples):ifi!j:diffY[i]-Y[j]factor4*(PQ[i,j]*diff)/(1np.sum(diff**2))gradfactor# 更新位置Y[i]-self.learning_rate*grad# 早停检查简化版ifiteration%1000anditeration0:costnp.sum(P*np.log(P/(Q1e-12)))print(fIteration{iteration}: Cost {cost:.4f})returnY# 使用t-SNE降维tsneTSNE(n_components2,perplexity30,n_iter500)X_tsnetsne.fit_transform(X_scaled)# 可视化plt.figure(figsize(10,5))plt.subplot(1,2,1)plt.scatter(X_pca[:,0],X_pca[:,1],alpha0.6)plt.title(PCA降维)plt.subplot(1,2,2)plt.scatter(X_tsne[:,0],X_tsne[:,1],alpha0.6)plt.title(t-SNE降维)plt.tight_layout()plt.show()自编码器基础基本自编码器架构自编码器由编码器Encoder和解码器Decoder两部分组成通过学习重构输入数据来学习有效的表示。importtorch.nnasnnimporttorch.optimasoptimfromtorch.utils.dataimportDataLoader,TensorDatasetclassAutoencoder(nn.Module):基础自编码器def__init__(self,input_dim,hidden_dims,latent_dim):super(Autoencoder,self).__init__()# 编码器encoder_layers[]prev_diminput_dimforhidden_diminhidden_dims:encoder_layers.append(nn.Linear(prev_dim,hidden_dim))encoder_layers.append(nn.ReLU())prev_dimhidden_dim encoder_layers.append(nn.Linear(prev_dim,latent_dim))self.encodernn.Sequential(*encoder_layers)# 解码器decoder_layers[]prev_dimlatent_dimforhidden_diminreversed(hidden_dims):decoder_layers.append(nn.Linear(prev_dim,hidden_dim))decoder_layers.append(nn.ReLU())prev_dimhidden_dim decoder_layers.append(nn.Linear(prev_dim,input_dim))self.decodernn.Sequential(*decoder_layers)defforward(self,x):前向传播encodedself.encoder(x)decodedself.decoder(encoded)returndecodeddefencode(self,x):编码returnself.encoder(x)defdecode(self,z):解码returnself.decoder(z)# 示例训练自编码器classAutoencoderTrainer:def__init__(self,model,learning_rate0.001):self.modelmodel self.devicetorch.device(cudaiftorch.cuda.is_available()elsecpu)self.model.to(self.device)self.optimizeroptim.Adam(self.model.parameters(),lrlearning_rate)self.criterionnn.MSELoss()self.train_losses[]deftrain(self,data_loader,epochs50):训练自编码器self.model.train()forepochinrange(epochs):total_loss0forbatchindata_loader:xbatch[0].to(self.device)# 前向传播reconstructedself.model(x)lossself.criterion(reconstructed,x)# 反向传播self.optimizer.zero_grad()loss.backward()self.optimizer.step()total_lossloss.item()avg_losstotal_loss/len(data_loader)self.train_losses.append(avg_loss)ifepoch%100:print(fEpoch{epoch}, Loss:{avg_loss:.4f})defvisualize_reconstruction(self,test_loader,num_samples5):可视化重构效果self.model.eval()withtorch.no_grad():# 获取测试样本data_iteriter(test_loader)x_batchnext(data_iter)[0][:num_samples].to(self.device)# 重构reconstructedself.model(x_batch)# 转换为numpy用于可视化x_batchx_batch.cpu().numpy()reconstructedreconstructed.cpu().numpy()# 可视化plt.figure(figsize(12,4))foriinrange(num_samples):plt.subplot(2,num_samples,i1)ifx_batch.shape[1]64:# 假设是8x8图像plt.imshow(x_batch[i].reshape(8,8),cmapgray)else:plt.plot(x_batch[i])plt.title(Original)plt.axis(off)plt.subplot(2,num_samples,num_samplesi1)ifreconstructed.shape[1]64:plt.imshow(reconstructed[i].reshape(8,8),cmapgray)else:plt.plot(reconstructed[i])plt.title(Reconstructed)plt.axis(off)plt.tight_layout()plt.show()# 准备数据使用手写数字数据集digitsload_digits()datadigits.data.astype(np.float32)/16.0# 归一化# 创建数据加载器datasetTensorDataset(torch.FloatTensor(data))data_loaderDataLoader(dataset,batch_size32,shuffleTrue)# 创建和训练自编码器autoencoderAutoencoder(input_dim64,# 8x8图像hidden_dims[32,16],latent_dim8)trainerAutoencoderTrainer(autoencoder,learning_rate0.001)trainer.train(data_loader,epochs100)# 可视化重构效果test_loaderDataLoader(dataset,batch_size5,shuffleFalse)trainer.visualize_reconstruction(test_loader)# 绘制训练损失plt.figure(figsize(8,4))plt.plot(trainer.train_losses)plt.title(Autoencoder Training Loss)plt.xlabel(Epoch)plt.ylabel(MSE Loss)plt.grid(True)plt.show()卷积自编码器Convolutional Autoencoder对于图像数据使用卷积层可以更好地捕获空间特征。classConvAutoencoder(nn.Module):卷积自编码器def__init__(self):super(ConvAutoencoder,self).__init__()# 编码器self.encodernn.Sequential(# 输入: 1 x 28 x 28nn.Conv2d(1,16,kernel_size3,stride2,padding1),# 16 x 14 x 14nn.ReLU(),nn.Conv2d(16,32,kernel_size3,stride2,padding1),# 32 x 7 x 7nn.ReLU(),nn.Conv2d(32,64,kernel_size3),# 64 x 5 x 5nn.ReLU())# 解码器self.decodernn.Sequential(# 输入: 64 x 5 x 5nn.ConvTranspose2d(64,32,kernel_size3,stride2),# 32 x 11 x 11nn.ReLU(),nn.ConvTranspose2d(32,16,kernel_size3,stride2),# 16 x 23 x 23nn.ReLU(),nn.ConvTranspose2d(16,1,kernel_size4,stride2),# 1 x 48 x 48nn.ReLU(),nn.Conv2d(1,1,kernel_size3,padding20),# 1 x 28 x 28nn.Sigmoid())defforward(self,x):encodedself.encoder(x)decodedself.decoder(encoded)returndecodeddefencode(self,x):获取编码特征returnself.encoder(x)# 创建更大的示例图像数据defcreate_mnist_like_data(n_samples1000):创建类似MNIST的数据集fromsklearn.datasetsimportmake_blobs# 创建特征X,_make_blobs(n_samplesn_samples,n_features64,centers10,cluster_std1.5)# 转换为图像格式images[]forfeaturesinX:# 创建8x8的数字图像imgfeatures.reshape(8,8)# 放大到28x28img_largenp.kron(img,np.ones((3,3),dtypeimg.dtype))[:28,:28]images.append(img_large)returnnp.array(images)# 创建卷积自编码器的训练数据conv_datacreate_mnist_like_data(1000)conv_dataconv_data.reshape(-1,1,28,28).astype(np.float32)# 创建数据加载器conv_datasetTensorDataset(torch.FloatTensor(conv_data))conv_data_loaderDataLoader(conv_dataset,batch_size32,shuffleTrue)# 创建和训练卷积自编码器conv_autoencoderConvAutoencoder()conv_trainerAutoencoderTrainer(conv_autoencoder,learning_rate0.001)conv_trainer.modelconv_autoencoder conv_trainer.train(conv_data_loader,epochs50)# 可视化卷积自编码器的结果conv_test_loaderDataLoader(conv_dataset,batch_size3,shuffleFalse)conv_trainer.visualize_reconstruction(conv_test_loader,num_samples3)变分自编码器Variational Autoencoder, VAE变分自编码器通过引入概率框架学习数据的潜在分布从而能够生成新的样本。VAE的理论基础VAE的目标是最大化数据的对数似然下界ELBOLEq(z∣x)[log⁡p(x∣z)]−βDKL(q(z∣x)∣∣p(z))\mathcal{L} \mathbb{E}_{q(z|x)}[\log p(x|z)] - \beta D_{KL}(q(z|x) || p(z))LEq(z∣x)​[logp(x∣z)]−βDKL​(q(z∣x)∣∣p(z))classVAE(nn.Module):变分自编码器def__init__(self,input_dim,hidden_dims,latent_dim,beta1.0):super(VAE,self).__init__()self.latent_dimlatent_dim self.betabeta# KL损失的权重# 编码器encoder_layers[]prev_diminput_dimforhidden_diminhidden_dims:encoder_layers.append(nn.Linear(prev_dim,hidden_dim))encoder_layers.append(nn.ReLU())prev_dimhidden_dim self.encodernn.Sequential(*encoder_layers)# 均值和方差层self.fc_munn.Linear(prev_dim,latent_dim)self.fc_varnn.Linear(prev_dim,latent_dim)# 解码器decoder_layers[]prev_dimlatent_dimforhidden_diminreversed(hidden_dims):decoder_layers.append(nn.Linear(prev_dim,hidden_dim))encoder_layers.append(nn.ReLU())prev_dimhidden_dim decoder_layers.append(nn.Linear(prev_dim,input_dim))self.decodernn.Sequential(*decoder_layers)defencode(self,x):编码返回均值和方差hself.encoder(x)muself.fc_mu(h)log_varself.fc_var(h)returnmu,log_vardefreparameterize(self,mu,log_var):重参数化技巧stdtorch.exp(0.5*log_var)epstorch.randn_like(std)returnmueps*stddefdecode(self,z):解码returnself.decoder(z)defforward(self,x):前向传播mu,log_varself.encode(x)zself.reparameterize(mu,log_var)reconstructedself.decode(z)returnreconstructed,mu,log_vardefsample(self,num_samples):从潜在空间生成样本self.eval()withtorch.no_grad():ztorch.randn(num_samples,self.latent_dim).to(next(self.parameters()).device)samplesself.decode(z)returnsamplesclassVAETrainer:VAE训练器def__init__(self,model,learning_rate0.001):self.modelmodel self.devicetorch.device(cudaiftorch.cuda.is_available()elsecpu)self.model.to(self.device)self.optimizeroptim.Adam(self.model.parameters(),lrlearning_rate)self.train_losses[]self.recon_losses[]self.kl_losses[]defloss_function(self,reconstructed,x,mu,log_var):VAE损失函数# 重构损失recon_lossnn.functional.mse_loss(reconstructed,x,reductionsum)# KL散度kl_loss-0.5*torch.sum(1log_var-mu.pow(2)-log_var.exp())# 总损失total_lossrecon_lossself.model.beta*kl_lossreturntotal_loss,recon_loss,kl_lossdeftrain(self,data_loader,epochs100):训练VAEself.model.train()forepochinrange(epochs):total_loss0total_recon_loss0total_kl_loss0forbatchindata_loader:xbatch[0].to(self.device)# 前向传播reconstructed,mu,log_varself.model(x)# 计算损失loss,recon_loss,kl_lossself.loss_function(reconstructed,x,mu,log_var)# 反向传播self.optimizer.zero_grad()loss.backward()self.optimizer.step()total_lossloss.item()total_recon_lossrecon_loss.item()total_kl_losskl_loss.item()avg_losstotal_loss/len(data_loader.dataset)avg_recontotal_recon_loss/len(data_loader.dataset)avg_kltotal_kl_loss/len(data_loader.dataset)self.train_losses.append(avg_loss)self.recon_losses.append(avg_recon)self.kl_losses.append(avg_kl)ifepoch%100:print(fEpoch{epoch}, Loss:{avg_loss:.4f}, fRecon:{avg_recon:.4f}, KL:{avg_kl:.4f})defvisualize_latent_space(self,test_loader):可视化潜在空间self.model.eval()latent_vectors[]labels[]withtorch.no_grad():forx,yintest_loader:xx.to(self.device)mu,_self.model.encode(x)latent_vectors.append(mu.cpu().numpy())labels.append(y.numpy())latent_vectorsnp.concatenate(latent_vectors,axis0)labelsnp.concatenate(labels,axis0)# 使用PCA降到2维进行可视化pcaPCA(n_components2)latent_2dpca.fit_transform(latent_vectors)plt.figure(figsize(10,8))scatterplt.scatter(latent_2d[:,0],latent_2d[:,1],clabels,cmaptab10,alpha0.6)plt.colorbar(scatter)plt.title(VAE Latent Space Visualization)plt.xlabel(Latent Dimension 1)plt.ylabel(Latent Dimension 2)plt.show()defgenerate_samples(self,num_samples16):生成新样本generatedself.model.sample(num_samples)generatedgenerated.cpu().numpy()# 可视化生成的样本plt.figure(figsize(8,8))foriinrange(min(num_samples,16)):plt.subplot(4,4,i1)ifgenerated.shape[1]64:plt.imshow(generated[i].reshape(8,8),cmapgray)plt.axis(off)plt.suptitle(Generated Samples from VAE)plt.show()# 创建带标签的数据集用于可视化ydigits.target labeled_datasetTensorDataset(torch.FloatTensor(data),torch.LongTensor(y))labeled_data_loaderDataLoader(labeled_dataset,batch_size32,shuffleTrue)labeled_test_loaderDataLoader(labeled_dataset,batch_size32,shuffleFalse)# 创建和训练VAEvaeVAE(input_dim64,hidden_dims[32,16],latent_dim10,beta1.0)vae_trainerVAETrainer(vae,learning_rate0.001)vae_trainer.train(labeled_data_loader,epochs100)# 可视化训练过程plt.figure(figsize(12,4))plt.subplot(1,3,1)plt.plot(vae_trainer.train_losses)plt.title(Total Loss)plt.subplot(1,3,2)plt.plot(vae_trainer.recon_losses)plt.title(Reconstruction Loss)plt.subplot(1,3,3)plt.plot(vae_trainer.kl_losses)plt.title(KL Divergence Loss)plt.tight_layout()plt.show()# 可视化潜在空间vae_trainer.visualize_latent_space(labeled_test_loader)# 生成新样本vae_trainer.generate_samples(16)稀疏自编码器稀疏自编码器通过在潜在表示上添加稀疏约束来学习更鲁棒的特征。classSparseAutoencoder(nn.Module):稀疏自编码器def__init__(self,input_dim,hidden_dims,latent_dim,sparsity_param0.05,beta3):super(SparseAutoencoder,self).__init__()self.sparsity_paramsparsity_param# 期望的稀疏度self.betabeta# 稀疏惩罚的权重# 编码器encoder_layers[]prev_diminput_dimforhidden_diminhidden_dims:encoder_layers.append(nn.Linear(prev_dim,hidden_dim))encoder_layers.append(nn.ReLU())prev_dimhidden_dim encoder_layers.append(nn.Linear(prev_dim,latent_dim))encoder_layers.append(nn.ReLU())self.encodernn.Sequential(*encoder_layers)# 解码器decoder_layers[]prev_dimlatent_dimforhidden_diminreversed(hidden_dims):decoder_layers.append(nn.Linear(prev_dim,hidden_dim))decoder_layers.append(nn.ReLU())prev_dimhidden_dim decoder_layers.append(nn.Linear(prev_dim,input_dim))self.decodernn.Sequential(*decoder_layers)# 记录激活值用于计算稀疏性self.activationsNonedefforward(self,x):前向传播encodedself.encoder(x)# 记录潜在层的激活值self.activationsencoded.detach()decodedself.decoder(encoded)returndecodeddefsparse_loss(self):计算稀疏性损失KL散度# 计算平均激活度rho_hattorch.mean(self.activations,dim0)# KL散度rhoself.sparsity_param kl_divrho*torch.log(rho/(rho_hat1e-10))\(1-rho)*torch.log((1-rho)/(1-rho_hat1e-10))returnself.beta*torch.sum(kl_div)# 训练稀疏自编码器classSparseAutoencoderTrainer(AutoencoderTrainer):稀疏自编码器训练器deftrain(self,data_loader,epochs100):训练稀疏自编码器self.model.train()forepochinrange(epochs):total_loss0recon_loss0forbatchindata_loader:xbatch[0].to(self.device)# 前向传播reconstructedself.model(x)# 计算重构损失reconself.criterion(reconstructed,x)# 计算稀疏性损失sparseself.model.sparse_loss()# 总损失lossreconsparse# 反向传播self.optimizer.zero_grad()loss.backward()self.optimizer.step()total_lossloss.item()recon_lossrecon.item()avg_losstotal_loss/len(data_loader)avg_reconrecon_loss/len(data_loader)self.train_losses.append(avg_loss)ifepoch%100:print(fEpoch{epoch}, Total Loss:{avg_loss:.4f}, fRecon Loss:{avg_recon:.4f})# 创建和训练稀疏自编码器sparse_autoencoderSparseAutoencoder(input_dim64,hidden_dims[32,16],latent_dim8,sparsity_param0.05,beta3)sparse_trainerSparseAutoencoderTrainer(sparse_autoencoder,learning_rate0.001)sparse_trainer.modelsparse_autoencoder sparse_trainer.train(data_loader,epochs100)# 比较不同自编码器的潜在表示defcompare_latent_representations(models,test_data,model_names):比较不同模型的潜在表示plt.figure(figsize(15,5))foridx,(model,name)inenumerate(zip(models,model_names)):model.eval()withtorch.no_grad():test_tensortorch.FloatTensor(test_data[:100]).to(next(model.parameters()).device)ifhasattr(model,encode):latentmodel.encode(test_tensor).cpu().numpy()else:# 对于稀疏自编码器latentmodel.encoder(test_tensor).cpu().numpy()# 使用PCA降到2维pcaPCA(n_components2)latent_2dpca.fit_transform(latent)plt.subplot(1,3,idx1)plt.scatter(latent_2d[:,0],latent_2d[:,1],alpha0.6)plt.title(f{name}Latent Space)plt.xlabel(Component 1)plt.ylabel(Component 2)plt.tight_layout()plt.show()# 比较三种自编码器models[autoencoder,vae,sparse_autoencoder]model_names[Autoencoder,VAE,Sparse Autoencoder]test_datadata[:1000]compare_latent_representations(models,test_data,model_names)降维技术应用异常检测自编码器可以用于异常检测通过重构误差来识别异常样本。classAnomalyDetector:基于自编码器的异常检测器def__init__(self,autoencoder,threshold_percentile95):self.autoencoderautoencoder self.threshold_percentilethreshold_percentile self.thresholdNonedeffit(self,normal_data):训练异常检测器# 获取正常数据的重构误差self.autoencoder.eval()withtorch.no_grad():normal_tensortorch.FloatTensor(normal_data).to(next(self.autoencoder.parameters()).device)reconstructedself.autoencoder(normal_tensor)errorstorch.mean((normal_tensor-reconstructed)**2,dim1)self.thresholdnp.percentile(errors.cpu().numpy(),self.threshold_percentile)print(fAnomaly threshold set at:{self.threshold:.4f})defdetect(self,test_data):检测异常self.autoencoder.eval()withtorch.no_grad():test_tensortorch.FloatTensor(test_data).to(next(self.autoencoder.parameters()).device)reconstructedself.autoencoder(test_tensor)errorstorch.mean((test_tensor-reconstructed)**2,dim1)errorserrors.cpu().numpy()anomalieserrorsself.thresholdreturnanomalies,errors# 创建异常检测示例defcreate_anomaly_data():创建包含异常的数据集# 正常数据normal_data,_make_blobs(n_samples900,n_features64,centers5,cluster_std1.0,random_state42)# 异常数据远离正常簇anomaliesnp.random.uniform(low-10,high10,size(100,64))# 合并数据all_datanp.vstack([normal_data,anomalies])labelsnp.array([0]*900[1]*100)# 0: 正常, 1: 异常returnall_data,labels,normal_data,anomalies# 生成数据all_data,labels,normal_data,anomaliescreate_anomaly_data()scalerStandardScaler()all_data_scaledscaler.fit_transform(all_data)normal_data_scaledscaler.transform(normal_data)# 训练异常检测器detectorAnomalyDetector(autoencoder,threshold_percentile95)detector.fit(normal_data_scaled)# 检测异常predicted_anomalies,errorsdetector.detect(all_data_scaled)# 评估性能fromsklearn.metricsimportaccuracy_score,precision_score,recall_score,f1_score accuracyaccuracy_score(labels,predicted_anomalies)precisionprecision_score(labels,predicted_anomalies)recallrecall_score(labels,predicted_anomalies)f1f1_score(labels,predicted_anomalies)print(f\nAnomaly Detection Performance:)print(fAccuracy:{accuracy:.2%})print(fPrecision:{precision:.2%})print(fRecall:{recall:.2%})print(fF1 Score:{f1:.2%})# 可视化检测效果plt.figure(figsize(12,5))plt.subplot(1,2,1)plt.scatter(errors[labels0],np.zeros(np.sum(labels0)),alpha0.6,labelNormal)plt.scatter(errors[labels1],np.zeros(np.sum(labels1)),alpha0.6,labelAnomaly)plt.axvline(xdetector.threshold,colorr,linestyle--,labelThreshold)plt.title(Reconstruction Error Distribution)plt.xlabel(Reconstruction Error)plt.legend()plt.yticks([])plt.subplot(1,2,2)plt.scatter(all_data[:,0],all_data[:,1],cpredicted_anomalies,cmapcoolwarm,alpha0.6)plt.title(Anomaly Detection Results)plt.xlabel(Feature 1)plt.ylabel(Feature 2)plt.colorbar(labelPredicted Anomaly)plt.tight_layout()plt.show()特征提取与迁移学习自编码器学习到的特征可以用于下游任务。classFeatureExtractor:基于自编码器的特征提取器def__init__(self,autoencoder):self.autoencoderautoencoder# 冻结自编码器参数forparaminself.autoencoder.parameters():param.requires_gradFalsedefextract_features(self,data):提取特征self.autoencoder.eval()withtorch.no_grad():data_tensortorch.FloatTensor(data).to(next(self.autoencoder.parameters()).device)featuresself.autoencoder.encode(data_tensor)returnfeatures.cpu().numpy()# 使用提取的特征进行分类fromsklearn.linear_modelimportLogisticRegressionfromsklearn.model_selectionimporttrain_test_split# 提取特征extractorFeatureExtractor(autoencoder)featuresextractor.extract_features(data)# 分割数据X_train,X_test,y_train,y_testtrain_test_split(features,digits.target,test_size0.2,random_state42)# 训练分类器classifierLogisticRegression(max_iter1000)classifier.fit(X_train,y_train)# 评估train_accclassifier.score(X_train,y_train)test_accclassifier.score(X_test,y_test)print(f\nClassification with Autoencoder Features:)print(fTrain Accuracy:{train_acc:.2%})print(fTest Accuracy:{test_acc:.2%})# 与原始数据对比X_train_orig,X_test_orig,y_train_orig,y_test_origtrain_test_split(data,digits.target,test_size0.2,random_state42)classifier_origLogisticRegression(max_iter1000)classifier_orig.fit(X_train_orig,y_train_orig)train_acc_origclassifier_orig.score(X_train_orig,y_train_orig)test_acc_origclassifier_orig.score(X_test_orig,y_test_orig)print(f\nClassification with Original Features:)print(fTrain Accuracy:{train_acc_orig:.2%})print(fTest Accuracy:{test_acc_orig:.2%})总结本文深入探讨了Autoencoder和各种降维技术包括传统降维方法PCA和t-SNE的原理与实现基础自编码器架构设计和训练过程卷积自编码器处理图像数据的改进版本变分自编码器引入概率框架的生成模型稀疏自编码器通过稀疏约束学习鲁棒特征实际应用异常检测、特征提取等降维技术和自编码器在现代机器学习中扮演着重要角色。它们不仅能够处理高维数据的复杂性还能学习数据的有意义表示。从线性PCA到非线性VAE这些技术为我们提供了强大的工具来理解、压缩和生成数据。未来发展方向更高效的架构减少计算复杂度的同时保持性能解耦表示学习学习可解释的独立特征条件生成根据给定条件生成特定类型的数据跨模态学习在不同数据类型间学习共享表示联邦学习中的降维在保护隐私的同时学习有效表示实践建议根据数据特点选择合适的降维方法注意标准化预处理的重要性调整网络架构和超参数以获得最佳性能使用正则化技术防止过拟合可视化学习到的表示以理解模型行为