人工智能开发框架应用 课后练习题及答案汇 项目1-9

项目1深度学习概述1.简述机器学习和深度学习的关系。2.简述机器学习算法中监督学习、无监督学习、半监督学习和强化学习的区别。无监督学习是指从未标记的训练数据中学习模式和规律，而无需提供标签或输出值。在无监督学习中，算法通过发现数据中的隐藏结构或模式来进行聚类、降维、异常检测等任务。（奖励或惩罚）来调整自己的行为策略。3.简述Tensorflow、Caffe和PyTorch三者的特点和应用场景。Tensorflow、Caffe和PyTorch三者是目前最常用的深度学习框架。TensorflowPythonJavaScriptC++JavaSwiftRTensorFlow的主要应用场景包括：图像识别、自然语言处理、语音识别和推荐系统等。CaffeCC++PythonMatlabCaffe应用场景是图像分类、物体检测、人脸识别等场景。API设计非常简洁，提供了非常丰富的模型组件，能够快速构建深度学习模型；所构建的动态神经网络使得其训练周期大大缩短。PyTorch的应用场景主要包括图像识别、自然语言处理、计算机视觉等。项目2PyTorch环境配置与基本应用一、简答题1.简述PyTorch核心功能和设计理念。PyTorch提供两个核心功能：一是支持GPU加速的张量计算；二是方便优化网络的自动微分机制。PyTorch的设计理念主要体现在动态计算图、易用性和灵活性，以及强大的生态系统。二、实操题1.Miniconda、CPUGPU版本（推荐。参考《搭建虚拟环境和安装开发工具》项目实战实施书。2.创建一个形状为[43]对象进行切片索引、1的对象相乘的操作。参考答案：1）创建Tensort_data_1，代码如下importnumpyasnpimporttorchn_array=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])t_data_1=torch.from_numpy(n_array)t_data_12）获取Tensor的形状、维度和数据类型针对t_data_1对象，获取其形状、维度和数据类型，代码如下。t_data_1.shapet_data_1.dtype3）对于Tensor进行切片索引针对t_data_1对象，获取第1维度上第3个数组，代码如下：t_data_1[2]4）对于Tensor进行形状变换针对t_data_1对象，将其形状改为[3,4]，代码如下。data=t_data_1.view(3,4)5）与全1的Tensor对象相乘t_data_2=torch.ones(4,3) #创建全1的对象，类型为float32result=t_data_1.mul(t_data_2) #t_data_1和t_data_2相乘项目3基于机器学习逻辑回归实现分类预测一、简答题1.简述回归和分类各自的含义，以及两者的区别。回归和分类是机器学习中常见的两种任务，它们分别用于预测数值型和类别型的输出。两者区别：（1）输出类型：回归问题预测连续型的输出值，而分类问题预测离散的类别型输出。（2）学习目标：回归问题旨在学习输入与输出之间的函数关系，以获得连续型输出的（3）模型选择：回归问题常用的模型包括线性回归、多项式回归等，而分类问题常用的模型包括逻辑回归、决策树等。（4）评估指标：回归问题的评估指标通常使用均方误差等连续性指标来度量预测值与二、实操题1.利用Sklearn库的网络模型，实现逻辑回归网络的搭建和训练。参考答案：importpandasaspdimporttorchfromtorchimportnnfromsklearn.linear_modelimportLogisticRegression#导入Sklearn库LogisticRegressionimportmatplotlib.pyplotasplt#引入train_test_split，用于划分数据集fromsklearn.model_selectionimporttrain_test_split#语句1拆分训练集和测试集x,x_test,y,y_test=train_test_split(inputs,targets.ravel(),test_size=0.3,random_state=1)#语句2创建逻辑回归网络model=LogisticRegression()model.fit(x,target_y)model.score(x_test,target_y_test)项目4基于线性回归网络实现房价预测一、简答题1.简述单层感知机和多层感知机的区别。2.简述深度学习工作流程。1）数据加载：深度学习模型训练需要依赖于大量数据，可使用框架自带数据集或是文件数据集。2）数据预处理：由于原始数据集的数据可能不一定规范和完整，需要对数据进行初步分析或探索，然后根据探索结果与问题目标，确定数据预处理方案。3）构建神经网络：根据问题的需要，选择神经网络结构，搭建神经网络。4）训练配置：设置损失函数和优化器等相关参数才可以输入训练数据，进行网络训练。5）训练网络：将数据样本传入网络，对于网络进行训练。在训练网络过程中，可通过调整迭代次数、批大小等参数的值，对网络训练过程进行优化。6）模型评估：网络训练完毕后，需要利用测试集来评估训练的效果如何，所得到的模型指标是否达标。7）模型保存与调用 为了方便使用通常将训练好的神经网络模型以文件形式保存，使用时直接加载保存的模型模型保存的方式分为两种保存模型参数和保存整个模型两种方式。二、实操题1.Linear网络模型，实现线性回归模型的搭建和训练。4.1、4.2、4.3，核心实现代码：importpandasaspdimportmatplotlib.pyplotaspltimportseabornassns #导入Seaborn库fromsklearn.datasetsimportfetch_california_housing #导入数据集importtorchfromtorchimportnnfromsklearn.metricsimportr2_scorehousing=fetch_california_housing()#以data属性为数据、feature_names属性为标题，创建DataFrame对象df=pd.DataFrame(data=housing['data'],columns=housing['feature_names'])#将target属性列作为新增列加到df最后一列df['MedHouseVal']=housing['target']#语句1定义图形窗口，设置其宽和高均为12，分辨率为300，#返回3x3的子图坐标数组对象axsfig,axs=plt.subplots(3,3,figsize=(12,12),dpi=300)#语句2将axs展开为1维数组axs=axs.flatten()#遍历数据集中所有属性列fori,colinenumerate(df.columns[:-1]):#绘制第i个散点子图，描述第col个属性列与房价中位数的关系axs[i].scatter(df[col],df['MedHouseVal'],s=1)#设置x轴axs[i].set_xlabel(col)#设置y轴axs[i].set_ylabel('MedHouseVal')#调整子图，以填充整个图形窗口plt.tight_layout()#保存所绘制的图形plt.savefig('../tmp/加州房价数据集各属性与目标属性的关系.jpg')#显示图形plt.show()#定义去除异常值函数defremove_outliers(data,col,threshold=3):"""去除指定列中的异常值，使用3sigma原则。参数：data:pandas.DataFrame，数据集。col:str，需要去除异常值的列名。threshold:int，标准差的阈值，默认为3。返回值：pandas.DataFrame，去除异常值后的数据集。"""#计算指定列的均值和标准差mean=data[col].mean()std=data[col].std()#计算异常值的阈值范围lower=mean-threshold*stdupper=mean+threshold*std#去除异常值data=data[(data[col]>=lower)&(data[col]<=upper)]returndata#去除异常值处理clean_list=['AveRooms','AveBedrms','Population','AveOccup']df_new=df#遍历clean_list数组foriinclean_list:#调用remove_outliers函数，对第i个特征属性进行异常值去除处理df_new=remove_outliers(df_new,i,3)#计算数据集中各属性间的相关性，返回矩阵结果集corr_matrix=df_new.corr()#定义图形窗口，设置宽和高均为8plt.figure(figsize=(8,8))#对ormaixcmap选用“coolam#设置annot为True，每个单元格写入相关性的值，#设置square为True，x、y轴方向设置相等，使得每个单元格为方形sns.heatmap(corr_matrix,cmap='coolwarm',annot=True,square=True)#设置图形的标题plt.title('CorrelationbetweenfeaturesandMedHouseVal')#显示图形plt.show()#获取各属性与MedHouseVal属性的相关性系数tmp=corr_matrix['MedHouseVal']#选择相关系数绝对值大于0.1的特征属性tmp=tmp[abs(tmp)>0.1]#获取相关系数绝对值大于0.1的特征属性的标题titles=tmp.index[:-1]#从数据集中获取相关系数绝对值大于0.1的特征属性x=df_new[titles]#从数据集中获取房价中位数属性y=df_new['MedHouseVal'].values#导入Sklearn库train_test_split函数fromsklearn.model_selectionimporttrain_test_split#划分训练集和测试集，其中测试集占比为20%，随机数种子为42X_train,X_test,y_train,y_test=train_test_split(x,y,test_size=0.2,random_state=42)#导入Sklearn库StandardScaler函数fromsklearn.preprocessingimportStandardScaler#定义标准缩放器对象scaler=StandardScaler()#找出X_train的均值和标准差，并基于此将数据进行标准化X_train=scaler.fit_transform(X_train)#对于X_test进行标准化处理X_test=scaler.transform(X_test)#1X_trainfloat32X_traintorch.tensor(X_train).float()#2y_train1float32y_train=torch.tensor(y_train.reshape(-11)).float()X_test=torch.tensor(X_test).float()y_test=torch.tensor(y_test.reshape(-1,1)).float()#语句1定义网络model=nn.Linear(X_train.shape[1],1)#定义损失函数criterion=nn.MSELoss()#定义优化器optimizer=torch.optim.Adam(model.parameters(),lr=0.05)#定义批次数n_epochs=100#在训练数据集上进行n_epochs次训练forepochinrange(n_epochs):#前向传播，在训练集上进行预测y_pred=model(X_train)#根据预测结果计算损失loss=criterion(y_pred,y_train)#语句1将参数梯度置零optimizer.zero_grad()#反向传播，求解参数梯度loss.backward()#更新模型参数optimizer.step()# R方if(epoch+1)%5==0:#语句2计算R方r2=r2_score(y_train.numpy(),y_pred.detach().numpy())print(f'Epoch{epoch+1},trainingloss:{loss.item():.4f},trainingR-squared:{r2:.4f}')5LetNet-51.简述卷积层和池化层的作用卷积层和池化层是深度学习中常用的两种层结构，它们在卷积神经网络中起着不同的作用。卷积层主要用于提取输入数据中的特征。它通过定义一组卷积核，对输入数据进行卷积2.简述欠拟合和过拟合产生的原因，以及解决方法。二、实操题1.5.1、5.25.3LetNet-5实现手写数字图像分类模型的搭建和训练。5.1、5.25.3的实施，核心代码如下：importtorchvisionfromtorchvisionimportdatasets,transformsimporttorchfromtorch.utils.dataimportDataLoaderimportmatplotlib.pyplotaspltimportnumpyasnpimporttorchimporttorch.nnasnn#导入Torch库的optimimporttorch.optimasoptim#获取MNIST数据集中的训练集，对其进行归一化、标准化和图像增广train_ds=torchvision.datasets.MNIST('../data/',train=True,download=True,transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,)),transforms.RandomRotation(degrees=(-60,60))]))#获取MNIST数据集中的测试集，对其进行归一化、标准化test_ds=torchvision.datasets.MNIST('../data/',train=False,download=Truetransform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))]))#设置每批次（Batch）样本中的数据个数BATCH_SIZE=512#通过DataLoader函数对数据集加载，并将其划分为若干个批次train_loader=DataLoader(train_ds,batch_size=BATCH_SIZE,shuffle=True)test_loader=DataLoader(test_ds,batch_size=batch)classLeNet5(nn.Module):#构造方法初始化definit(self):#调用父类构造方法super().init()#定义C1层-卷积层self.conv1=nn.Conv2d(in_channels=1,out_channels=6,kernel_size=(5,5))#定义S2层-池化层self.maxpool1=nn.MaxPool2d(kernel_size=(2,2))#定义C3层-卷积层self.conv2=nn.Conv2d(in_channels=6,out_channels=16,kernel_size=(5,5))#定义S4层-池化层self.maxpool2=nn.MaxPool2d(kernel_size=(2,2))#定义C5层-全连接层self.fc1=nn.Linear(16*5*5,120)#定义F6层-全连接层self.fc2=nn.Linear(120,84)#定义Output层-全连接层self.fc3=nn.Linear(84,10)#利用nn.Module内置激活函数ReLU定义ReLU层self.relu=nn.ReLU()#利用nn.Module内置激活函数LogSoftmax定义Softmax层self.softmax=nn.LogSoftmax(dim=1)#定义前向传播的计算过程defforward(self,x):#C1层：调用conv1，对输入进行卷积操作x=self.conv1(x)#S2层：调用maxpool1，对C1卷积层做下采样处理x=self.maxpool1(x)#调用relu，对S2层的结果进行激活处理x=self.relu(x)#C3层：调用conv2，以S2层结果为输入，进行卷积操作x=self.conv2(x)#S4层：调用maxpool1，对C3卷积层做下采样处理x=self.maxpool2(x)#调用relu，对S4层的结果进行激活处理x=self.relu(x)#将S4层输出的二维图像转为一维，即对其进行展平操作x=torch.flatten(x,1)#C5层：调用fc1，以S4层结果为输入，进行线性处理x=self.fc1(x)#调用relu，对C5层结果进行激活处理x=self.relu(x)#F6层：调用fc2，以C5层结果为输入，进行线性处理x=self.fc2(x)#调用relu，对F6层结果进行激活处理x=self.relu(x)#Output层：调用fc3，以F6层结果为输入，进行线性处理x=self.fc3(x)#调用LogSoftmax，对Output层结果进行激活处理，#以确定当前图像是0~9的每个数的概率output=self.softmax(x)returnoutput#语句1指定模型或数据所使用的设备配置（CPU或GPU）DEVICE=torch.device('cuda'iftorch.cuda.is_available()else'cpu')#创建LeNet5类的实例model=LeNet5()#将model加载到设备配置DEVICE上model=model.to(DEVICE)#定义损失函数loss_fn=nn.NLLLoss()#定义Adam优化器optimizer=optim.Adam(model.parameters())deftrain(model,device,train_loader,optimizer,loss_fn,epoch):#设置为训练模式model.train()#获取总的批次数total_batchs=len(train_loader)#获取总的样本数total_datas=len(train_loader.dataset)#初始化正确数、损失值correct=0.0train_loss=0.0#enumerate函数迭代已加载的数据集，并获取数据和数据下标，#每次循环处理一个批次的样本fori,datainenumerate(train_loader):inputs,labels=data#把数据加载到device上inputs,labels=inputs.to(device),labels.to(device)#初始化网络参数的梯度为零optimizer.zero_grad()#前向传播，使用网络进行预测outputs=model(inputs)#计算损失loss=loss_fn(outputs,labels)#反向传播，计算网络参数的梯度loss.backward()#更新网络参数optimizer.step()#设置禁用梯度计算withtorch.no_grad():#获取最大概率的预测结果，dim=1表示获取列下标predict=outputs.argmax(dim=1)#累计每个Batch的正确数correct+=(predict==labels).sum().item()#累计每个Batch的损失值train_loss+=loss.item()#每训练一个Batch的30%时，打印当前Batch损失值if(i+1)%30==0:print('TrainEpoch:{}[{}/{}({:.0f}%)]\tLoss:{:.6f}%'.format(epoch,i*len(data[0]),total_datas,100.*i/total_batchs,loss.item()))#计算一次训练过程（Epoch）的正确率correct/=total_datas#计算一次Epoch的损失train_loss/=total_batchs#返回一次Epoch的损失值和正确率returntrain_loss,correctdeftest(model,device,test_loader,loss_fn,epoch):#设置测试模式model.eval()#获取总的批次数total_batchslen(test_loader) #总的批次数#获取总的样本数total_dataslen(test_loader.dataset) #len(train_loader.dataset)#初始化正确数、损失值correct=0.0#total=0test_loss=0.0#设置禁用梯度计算withtorch.no_grad():forinput,labelintest_loader:input,label=input.to(device),label.to(device)output=model(input)test_loss+=loss_fn(output,label).item()predict=output.argmax(dim=1)correct+=(predict==label).sum().item()#计算一次Epoch的损失test_loss/=len(test_loader)#计算一次Epoch的正确率correct/=len(test_loader.dataset)#打印一次Epoch的损失值和正确率print('\nTestset:Averageloss:{:.4f},Accuracy:{}/{}({:.0f}%)\n'.format(test_loss,correct,total_datas,100.*correct))#返回一次Epoch的损失值和正确率returntest_loss,correct#设置总共训练批次EPOCHS=20#初始化训练集的正确率train_acc=[]#初始化训练集的损失值train_loss=[]#初始化测试集的正确率test_acc=[]#初始化测试集的损失值test_loss=[]#对LetNet-5网络进行EPOCHS次训练forepochinrange(1,EPOCHS+1):#调用训练函数，对训练集进行训练，返回其损失值和正确数epoch_train_loss,epoch_train_acc=train(model,DEVICE,train_loader,optimizer,loss_fn,epoch)#调用测试函数，对测试集进行验证，返回其损失值和正确率epoch_test_loss,epoch_test_acc=test(model,DEVICE,test_loader,loss_fn,epoch)#将训练集的损失值，加入train_loss数组train_loss.append(epoch_train_loss)#将测试集的正确率，加入train_acc数组train_acc.append(epoch_train_acc)#将训练集的损失值，加入test_loss数组test_loss.append(epoch_test_loss)#将测试集的正确率，加入test_acc数组test_acc.append(epoch_test_acc)项目6基于LSTM实现股票价格预测一、简答题1.简述循环神经网络的应用场景。2）语音识别：循环神经网络在语音识别领域广泛应用。2.简述与传统循环神经网络相比，LSTM具有哪些优势。与传统的循环神经网络（RNN）相比，长短期记忆网络（LSTM）具有以下几个显著的优势：1）处理长期依赖性：LSTM通过引入门控机制，能够更好地处理长期依赖性，避免梯度消失和梯度爆炸问题，从而更有效地捕捉和利用时间序列中的长期依赖信息。2）LSTM中引入了输入门、遗忘门和输出门等门控结构，能够自适LSTM能够更好地保持和更新长期记忆，同时防止过度记忆或遗忘。4）LSTM通过遗忘门和输入门的控制，能够自适应地处理总之，相较于传统的循环神经网络，LSTM通过引入门控结构，能够更好地处理长期依二、实操题1.6.1、6.26.3LSTM模型实现股票价格预测模型的搭建和训练。6.1、6.26.3实施，核心代码如下：importnumpyasnpimportpandasaspdimportmatplotlib.pyplotaspltimporttorchfromtorch.utils.dataimportDataset,DataLoaderimporttorch.nnasnnimportpickle#300DataFramedfdfpd.read_csv('../data/stock_price.csv')#构建数据集defgetData(df,column,train_end=-300,days_before=7,return_all=True,generate_index=False):'''读取原始数据，并生成训练样本df :原始数据column :要处理的列train_end :训练集的终点days_before :设置历史天数return_all :是否返回所有数据，默认generate_index :是否生成索引'''#datetimeindexdf['datetime'pd.to_datetime(df['datetime'])df=df.set_index('datetime')#生成仅包括column属性列的数据集series=df[column].copy()#划分数据为训练数据和测试数据train_series,test_series=series[:train_end],series[train_end-days_before:]#创建训练集train_data=pd.DataFrame()#通过滑动窗口，创建历史天数days_before天的数据foriinrange(days_before):#设置滑动窗口大小为7，步长为1，构建训练样本#c%d'%i为c开头的列标题，如c0、c1train_data['c%d'%i]=train_series.tolist()[i:-days_before+i]#获取对应的标签train_data['y']=train_series.tolist()[days_before:]#是否生成indexifgenerate_index:train_data.index=train_series.index[n:]ifreturn_all:returntrain_data,series,df.index.tolist()returntrain_data#调用getData函数，生成训练集、数据集及其索引train_data,all_series,df_index=getData(df,'high')#将数据集all_series转为numpy.ndarray类型all_series=np.array(all_series.tolist())#绘制沪深300指数原始数据的股票价格变化曲线plt.figure(figsize=(12,6))plt.plot(df_index,all_series,label='沪深300指数原始数据')plt.legend()plt.show()#定义数据集类classTrainSet(Dataset):definit(selfdata): #data#data取当天的前7天的数据，label取当天的数据self.data,self.label=data[:,:-1].float(),data[:,-1].float()defgetitem(self,index):returnself.data[index],self.label[index]”””

deflen(self):returnlen(self.data)数据归一化处理”””#将train_data转为numpy.array类型train_data_numpy=np.array(train_data)#计算数据集的平均值train_mean=np.mean(train_data_numpy)#计算均方误差train_std =np.std(train_data_numpy)#进行归一化处理train_data_numpy=(train_data_numpy-train_mean)/train_std#将train_data_numpy转为Tensor对象train_data_tensor=torch.Tensor(train_data_numpy)#创建数据集对象train_set=TrainSet(train_data_tensor)#创建Dataloader对象，对数据集对象进行加载train_loader=DataLoader(train_set,batch_size=10,shuffle=True)#LSTM网络类classLSTM(nn.Module):#构造方法初始化definit(self):super(LSTM,self).init()#定义LSTM网络self.lstm=nn.LSTM(input_size=1,hidden_size=64,num_layers=1,batch_first=True)#设置全连接输出层self.out=nn.Sequential(nn.Linear(64,1))#定义前向传播的计算过程defforward(self,x):#调用self.lstm构建LSTM网络#None表示LSMT隐藏层的初始参数h_0和c_0为全0的向量#h_n,c_n分别表示每层最后一个时间步的输出#r_out表示最后一层，每个时间步的输出hr_out,(h_n,c_n)=self.lstm(x,None)#取最后一天股票价格作为输出out=self.out(r_out[:,-1,:])returnout#创建LSTM实例lstm=LSTM()iftorch.cuda.is_available():lstm=lstm.cuda()#设置训练参数LR0.0001 #学习率EPOCH100 #训练次数#定义优化器为Adamoptimizer=torch.optim.Adam(lstm.parameters(),lr=LR)#定义损失函数为均方误差损失函数MSELossloss_func=nn.MSELoss()#在训练集上，进行EPOCH次训练forstepinrange(EPOCH):fortx,tyintrain_loader:#如果GPU可用，则将训练数据加载到GPU上iftorch.cuda.is_available():tx=tx.cuda()ty=ty.cuda()#语句1使用LSTM网络进行股票价格预测output=lstm(torch.unsqueeze(tx,dim=2))#语句2计算预测值与真实值之间的均方误差损失loss=loss_func(torch.squeeze(output),ty)#网络参数的梯度清零optimizer.zero_grad()#反向传播，计算梯度loss.backward()#更新网络参数optimizer.step()#输出本次训练的训练次数和损失值print(step,loss.cpu())#每训练10次保存一次模型ifstep%10==0:torch.save(lstm,'../tmp/lstm%d.pkl'%step)项目7基于DCGAN实现真假图像识别一、简答题1.简述生成对抗网络的结构和应用场景。生成对抗网络是一种由生成器和判别器组成的神经网络框架。GAN的结构包括以下两个主要部分：GAN在许多领域中都有广泛的应用，包括以下几个方面：图像生成、视频生成和处理、自然语言处理、强化学习。2.简述GAN、DCGAN和CGAN网络的异同之处。GAN、DCGAN和CGAN是三种不同类型的神经网络模型，它们在结构和功能上都有所不同。下面是它们的异同之处：GAN的核心思想是通过生成器和判别器之间的对抗训练来提高生成器生成逼真数据的能力。DCGANGANDCGANGAN的基础上增加了卷积神经网络（CNN）结构，并引入了几个重要的改进，如使用BatchNormalization、LeakyReLU激活函数和去掉全连接层等。CGANGAN可以生成特定类别或特定描述的逼真数据样本。二、实操题1.7.1、7.27.3DCGAN模型实现图像生成模型的搭建和训练。7.1、7.27.3实施，核心代码如下：importrandomimportnumpyasnpimportmatplotlib.pyplotaspltimporttorchfromtorch.utils.dataimportDataLoaderfromtorchvisionimportdatasets,transformsimporttorchvision.utilsasutilsimporttorch.nnasnnimporttorch.optimasoptim#获取(1,10000)范围内的随机数manualSeed=random.randint(1,10000)#初始化随机种子random.seed(manualSeed)#设置CPU和GPU随机种子torch.manual_seed(manualSeed)#下载数据，进行数据标准化等预处理dataset=datasets.MNIST(root='../data',download=True,transform=transforms.Compose([transforms.Resize(28),transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))]))#加载数据data_loader=DataLoader(dataset,batch_size=64,shuffle=True,num_workers=2)#指定网络或数据所使用的设备配置（CPU或GPU）DEVICE=torch.device('cuda:0'iftorch.cuda.is_available()else'cpu')#语句1读取一个批次训练数据real_batch=next(iter(data_loader))#提取当前批次中的手写数字图像和标签real_npimgs,real_labels=real_batch#将手写数字图像数据加载到GPU上real_npimgs=real_npimgs.to(DEVICE)#语句2将当前批次中的手写数字图像进行拼接real_npimgs_grid=utils.make_grid(real_npimgs,padding=2,normalize=True)#将手写数字图像数据加载到CPU上real_npimgs_grid=real_npimgs_grid.cpu()#根据plt.imshow要求进行维度转换real_images_grid=np.transpose(real_npimgs_grid,(1,2,0))plt.figure(figsize=(8,8))plt.axis('off')plt.title('TrainingImages')plt.imshow(real_images_grid)plt.show()nc1 #输入图像的通道数ngpu1 GPU的数量nz100 #随机输入的图像大小ngf64 #生成器的卷积核个数ndf64 #判别器的卷积核个数#生成器网络类classGenerator(nn.Module):#构造方法初始化definit(self,nz,ngf,nc):super(Generator,self).init()self.nz=nzself.ngf=ngfself.nc=nc#图像的channels维度变化为100->512->256->128->64->1self.main=nn.Sequential(#定义输入为100的第一个反卷积层nn.ConvTranspose2d(in_channels=self.nz,out_channels=self.ngf*8,kernel_size=4,stride=1,padding=0,bias=False),nn.BatchNorm2d(self.ngf*8),nn.ReLU(True),#定义输入为(ngf*8)x4x4的第二个反卷积层nn.ConvTranspose2d(in_channels=self.ngf*8,out_channels=self.ngf*4,kernel_size=4,stride=2,padding=1,bias=False),nn.BatchNorm2d(self.ngf*4),nn.ReLU(True),#定义输入为(ngf*4)x8x8的第三个反卷积层nn.ConvTranspose2d(in_channels=self.ngf*4,out_channels=self.ngf*2,kernel_size=4,stride=2,padding=1,bias=False),nn.BatchNorm2d(self.ngf*2),nn.ReLU(True),#定义输入为(ngf*2)x16x16的第四个反卷积层nn.ConvTranspose2d(in_channels=self.ngf*2,out_channels=self.ngf,kernel_size=4,stride=2,padding=1,bias=False),nn.BatchNorm2d(self.ngf),nn.ReLU(True),#定义输入为(ngf)x32x32的第五个反卷积层nn.ConvTranspose2d(in_channels=self.ngf,out_channels=self.nc,kernel_size=4,stride=2,padding=1,bias=False),nn.Tanh())#定义前向传播的计算过程defforward(self,input):#调用self.main处理输入，返回(nc)x64x64returnself.main(input)#判别器网络类classDiscriminator(nn.Module):#构造方法初始化definit(self,ndf,nc):super(Discriminator,self).init()self.ndf=ndfself.nc=nc#图像的channels维度变化为1->64->128->256self.main=nn.Sequential(#定义输入为(nc)x64x64的第一个卷积层nn.Conv2d(in_channels=self.nc,out_channels=self.ndf,kernel_size=4,stride=2,padding=1,bias=False),nn.LeakyReLU(0.2,inplace=True),#定义输入为(ndf)x32x32的第二个卷积层nn.Conv2d(in_channels=self.ndf, out_channels=self.ndf*2,kernel_size=4,stride=2,padding=1,bias=False),nn.BatchNorm2d(self.ndf*2),nn.LeakyReLU(0.2,inplace=True),#定义输入为(ndf*2)x16x16的第三个卷积层nn.Conv2d(in_channels=self.ndf*2,out_channels=self.ndf*4,kernel_size=4,stride=2,padding=1,bias=False),nn.BatchNorm2d(self.ndf*4),nn.LeakyReLU(0.2,inplace=True),#定义输入为(ndf*4)x8x8的第四个卷积层nn.Conv2d(in_channels=self.ndf*4,out_channels=1,kernel_size=4,stride=2,padding=1,bias=False),#对于输入为(1)x1x1，定义二分类判断函数nn.Sigmoid())#定义前向传播的计算过程defforward(self,input):#调用self.main处理输入returnself.main(input)#对网络的卷积层和批归一化分别进行初始化defweights_init(m):classname=m.class. name ifclassname.find('Conv')!=-1:nn.init.normal_(m.weight.data,0.00.02) #卷积层elifclassname.find('BatchNorm')!=-1:nn.init.normal_(m.weight.data,1.00.02) #批归一化nn.init.constant_(m.bias.data,0)#创建生成器Generator类的实例netG=Generator(nz,ngf,nc).to(device)#设置生成器网络的初始权重netG.apply(weights_init)#创建判别器Discriminator类的实例netD=Discriminator(ndf,nc).to(device)#设置判别器网络的初始权重netD.apply(weights_init)#定义损失函数criterion=nn.BCELoss()#定义生成器网络优化器optimizerG=optim.Adam(netG.parameters(),lr=0.0002,betas=(0.5,0.999))#定义判别器网络优化器optimizerD=optim.Adam(netD.parameters(),lr=0.0002,betas=(0.5,0.999))#训练函数deftrain(data_loader,num_epochs,device,real_label,fake_label,netG,netD,criterion,opt_G,opt_D,nz,fixed_noise):#获取总的批次数total_batchs=len(data_loader)#初始化损失值Loss_D=0.0Loss_G=0.0fori,datainenumerate(data_loader,0):#############################第一阶段：训练判别器############################从MNIST中读取一个批次真图像数据，加载到device上r_images=data[0].to(device)#获取一个批次的样本数batch_size=r_images.size(0)#构建一个批次的真图像标签r_labels=torch.full((batch_size,),real_label,device=device).float()#将真图像输入判别器，得到真图像的预测结果r_output=netD(r_images).view(-1)#计算判别器在真图像上的损失errD_real=criterion(r_output,r_labels)#计算真图像预测结果平均值D_x=r_output.mean().item()#产生噪声数据noise=torch.randn(batch_size,nz,1,1,device=device)#将噪声输入生成器，生成一个批次的假图像f_images=netG(noise)#构建一个批次的假图像标签f_labels=torch.full((batch_size,),fake_label,device=device).float()#将假图像输入判别器，返回假图像的预测结果f_output=netD(f_images.detach()).view(-1)#计算判别器在假图像上的损失errD_fake=criterion(f_output,f_labels)#计算判别器在真假图像上损失之和errD=errD_real+errD_fake#累计本次训练的判别器损失Loss_D+=errD.item()#计算假图像预测结果平均值D_G_z1=f_output.mean().item()#生成器的优化器梯度清零opt_D.zero_grad()#反向传播errD.backward()#更新判别器的参数opt_D.step()#############################第二阶段：训练生成器############################构建一个批次的真图像标签r_labels_2=torch.full((batch_size,),real_label,device=device).float()#将第一阶段生成的假图像输入判别器，返回假图像的预测结果f_output_2=netD(f_images).view(-1)#计算真图像标签与假图像的误差，得到生成器损失，errG=criterion(f_output_2,r_labels_2)#累计本次训练的生成器损失Loss_G+=errG.item()#假图像预测结果平均值D_G_z2=f_output_2.mean().item()#生成器的优化器梯度清零opt_G.zero_grad()#反向传播errG.backward()#更新生成器的参数opt_G.step()ifi%100==0:print('[%d/%d][%d/%d]Loss_D:%.4fLoss_G:%.4fD(x):%.4fD(G(z)):%.4f/%.4f'%(epoch,num_epochs,i,len(data_loader),errD.item(),errG.item(),D_x,D_G_z1,D_G_z2))#保存真实图像utils.save_image(r_images,'../tmp/real_samples.png',normalize=True)#使用当前训练次数下的生成器，生成假图像fake=netG(fixed_noise)#保存假图像utils.save_image(fake.detach(),'../tmp/fake_samples_epoch_%03d.png'%(epoch),normalize=True)#计算本次训练中生成器和判别器的平均损失Loss_D/=total_batchsLoss_G/=total_batchsreturnLoss_G,Loss_D#初始化噪声数据fixed_noise=torch.randn(100,nz,1,1,device=device)#设置真假图像标签real_label=1fake_label=0#设置训练次数num_epochs=25#初始化生成器和判别器损失值数组G_loss=[]D_loss=[]#对DCGAN进行num_epochs次训练forepochinrange(num_epochs):#调用train函数，进行网络训练epoch_loss_g,epoch_loss_d=train(data_loader,num_epochs,device,real_label,fake_label,netG,netD,criterion,optimizerG,optimizerD,nz,fixed_noise)#将本次训练生成器的损失值加入G_loss数组G_loss.append(epoch_loss_g)#将本次训练判别器的损失值加入D_loss数组D_loss.append(epoch_loss_d)print('Epoch:%dGLoss:%fDLoss:%f'%(epoch,epoch_loss_g,epoch_loss_d))项目8利用CycleGAN模型实现图像风格迁移一、简答题1.简述CycleGAN与DCGAN的异同之处。CycleGAN和DCGAN是两种不同类型的神经网络模型，它们在结构和功能上有一些明显的异同。下面是它们的异同之处：转换、跨域图像转换等任务；DCGAN的目标是学习真实图像的分布，以便生成具有良好质量的合成图像。采用了一个生成器和一个判别器的结构。DCGAN主要用于无监督DCGAN主要用于生成逼真的合成图像。它们在结构、功能上都有一定的差异。二、实操题1.8.1、8.28.3CycleGAN模型实现图像风格迁移模型的搭建和训练。8.1、8.28.3实施，核心代码如下：importtorchfromtorch.utilsimportdataimporttorchvisionfromtorchvisionimporttransformsimportnumpyasnpimportmatplotlib.pyplotaspltimportglobfromPILimportImageimporttorch.nnasnnimporttorch.nn.functionalasFimportitertools#打开第一张苹果图像文件，返回PIL格式图像image=Image.open('../data/trainA/n07740461_6908.jpg')#绘制图像plt.imshow(image)#显示图像plt.show()#获取训练数据集apple_path=glob.glob('../data/trainA/*.jpg')orange_path=glob.glob('../data/trainB/*.jpg')#获取测试数据集apple_test_path=glob.glob('../data/testA/*.jpg')orange_test_path=glob.glob('../data/testB/*.jpg')#定义数据集类classAppleOrangeDataset(data.Dataset):#初始化参数definit(self,img_path):#初始化保存图像路径的数组self.img_path=img_path#定义数据标准化等预处理操作self.transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize(0.50.5) #将图像像素值归一化到[-11]])#获取指定索引的图像数据defgetitem(self,index):#根据索引获取图像路径img_path=self.img_path[index]#以PIL格式读取图像pil_img=Image.open(img_path)#对图像进行标准化等预处理pil_img=self.transform(pil_img)#返回处理后的图像数据returnpil_img#获取数据集的总样本数deflen(self):#返回数组img_path大小returnlen(self.img_path)#创建苹果和橙子图像的数据集对象apple_dataset=AppleOrangeDataset(paint_path)orange_dataset=AppleOrangeDataset(view_path)apple_test_dataset=AppleOrangeDataset(paint_test_path)orange_test_dataset=AppleOrangeDataset(view_test_path)#设置一个批次的样本数batch_size=1#加载训练数据集和测试数据集apple_dl=torch.utils.data.DataLoader(apple_dataset,batch_size=batch_size,shuffle=True)orange_dl=torch.utils.data.DataLoader(orange_dataset,batch_size=batch_size,shuffle=True)apple_test_dl=torch.utils.data.DataLoader(apple_test_dataset,batch_size=batch_size,shuffle=True)orange_test_dl=torch.utils.data.DataLoader(orange_test_dataset,batch_size=batch_size,shuffle=True)#卷积层网络类classDownsample(nn.Module):definit(self,in_channels,out_channels):super(Downsample,self).init()#定义卷积层self.conv_relu=nn.Sequential(nn.Conv2d(in_channels,out_channels,kernel_size=3,stride=2,padding=1),nn.LeakyReLU(inplace=True),)#语句1定义批量归一化self.bn=nn.InstanceNorm2d(out_channels)defforward(self,x,is_bn=True):#调用self.conv_relu函数，进行卷积操作x=self.conv_relu(x)ifis_bn:#调用self.bn函数，进行批量的归一化处理x=self.bn(x)returnx#反卷积层网络类classUpsample(nn.Module):definit(self,in_channels,out_channels):super(Upsample,self).init()#定义反卷积层self.upconv_relu=nn.Sequential(nn.ConvTranspose2d(in_channels,out_channels,kernel_size=3,stride=2,padding=1,output_padding=1),nn.LeakyReLU(inplace=True))#定义批量归一化self.bn=nn.InstanceNorm2d(out_channels)defforward(self,x,is_drop=False):#调用self.upconv_relu函数，进行反卷积操作x=self.upconv_relu(x)#调用self.bn函数，进行批量的归一化处理x=self.bn(x)ifis_drop:#防止过拟合的处理x=F.dropout2d(x)returnx#生成器网络类classGenerator(nn.Module):#构造方法初始化definit(self):super(Generator,self).init()#定义输入为3x256x256的第一个卷积层self.down1=Downsample(3,64)#定义输入为64x128x128的第二个卷积层self.down2=Downsample(64,128)#定义输入为128x64x64的第三个卷积层self.down3=Downsample(128,256)#定义输入为256x32x32的第四个卷积层self.down4=Downsample(256,512)#定义输入为512x16x16的第五个卷积层self.down5=Downsample(512,512)#定义输入为512x8x8的第六个卷积层self.down6=Downsample(512,512)#定义输入为512x4x4的第一个反卷积层self.up1=Upsample(512,512)#定义输入为1024x8x8的第二个反卷积层self.up2=Upsample(1024,512)#定义输入为1024x16x16的第三个反卷积层self.up3=Upsample(1024,256)#定义输入为512x32x32的第四个反卷积层self.up4=Upsample(512,128)#定义输入为256x64x64的第五个反卷积层self.up5=Upsample(256,64)#定义输入为128x128x128的第六个反卷积层self.last=nn.ConvTranspose2d(128,3,kernel_size=3,stride=2,padding=1,output_padding=1)#定义前向传播的计算过程defforward(self,x):#进行第一次卷积，得到64x128x128x1=self.down1(x,is_bn=False)#进行第二次卷积，得到128x64x64x2=self.down2(x1)#进行第三次卷积，得到256x32x32x3=self.down3(x2)#进行第四次卷积，得到512x16x16x4=self.down4(x3)#进行第五次卷积，得到512x8x8x5=self.down5(x4)#进行第六次卷积，得到512x4x4x6=self.down6(x5)#进行第一次反卷积，得到512x8x8x6=self.up1(x6,is_drop=True)#x5x6512x8x81024x8x8，作为下一次输入x6=torch.cat([x5,x6dim=1)#进行第二次反卷积，得到512x16x16x6=self.up2(x6,is_drop=True)#x4x6512x16x161024x16x16，作为下一次输入x6=torch.cat([x4,x6dim=1)#进行第三次反卷积，得到256x32x32x6=self.up3(x6,is_drop=True)#x4x6256x32x32512x32x32，作为下一次输入x6=torch.cat([x3,x6dim=1)#进行第四次反卷积，得到128x64x64x6=self.up4(x6)#x2x6128x64x64256x64x64，作为下一次输入x6=torch.cat([x2,x6dim=1)#进行第五次反卷积，得到64x128x128x6=self.up5(x6)#x1x664x128x128128x128x128，作为下一次输入x6=torch.cat([x1,x6dim=1)#进行第六次反卷积，得到3x256x256x6=torch.tanh(self.last(x6))returnx6#判别器网络类classDiscriminator(nn.Module):#构造方法初始化definit(self):super(Discriminator,self)