• 深度学习实验总结：PR-曲线、线性回归、卷积神经网络、GAN生成式对抗神经网络

    目录

    0、前言

    1、实验一：环境配置

    （1）本机

            1、Jupyter

            2、Pycharm

    （2）云端

    2、实验二：特征数据集制作和PR曲线

    一、实验目的

    二、实验环境

    三、实验内容及实验步骤  

    3、实验三：线性回归及拟合

    一、实验目的

    二、实验环境

    三、实验内容及实验步骤  

    4、实验四：卷积神经网络应用

    一、实验目的

    二、实验环境

    三、实验内容及实验步骤  

    5、实验五：生成对抗式网络应用

    一、实验目的

    二、实验环境

    三、实验内容及实验步骤  

    6、总结

    0、前言

            本人是深度学习初学者，为了加强对深度学习的认识和应用，搜集整理了几个实验和代码，个人感觉对小白很有帮助，现与大家分享。代码原文链接均已在博客中标注。

    学习资料：

            《深度学习》：

                    github版：https://github.com/exacity/deeplearningbook-chinese

             PDF电子书：

                    链接：https://pan.baidu.com/s/1mN4Mn330M82vnwi6Em1BzQ 
                    提取码：qtex 


            深度学习框架实验：

            Pytorch：Dive-into-DL-PyTorch

            TensorFlow：Dive-into-DL-TF2.0 

            以上资源仅供学习使用，不得用于商业目的。

    1、实验一：环境配置

    环境配置就是你在一个什么样的环境下敲代码做实验，我总结了两种环境，下面一一介绍给大家。

    （1）本机

            在本机上配置深度学习实验环境有两种方法：

            1、Jupyter

                    用法：命令行(cmd)+交互式笔记本(Jupyter)

                    特点：简单方便个人比较推荐。

                    a、安装Anaconda

                    b、conda配置学习环境

                    c、conda切换国内镜像源

                    d、使用Jupyter进行深度学习开发

                    详细教程：深度学习环境配置Anaconda+Jupyter\\Pycharm+Tensorflow-数据集文档类资源-CSDN下载

            2、Pycharm

                    用法：Pycharm编辑器

                    特点：编程老手比较喜欢的工作方式。

                    a、下载

                            地址：Download PyCharm: Python IDE for Professional Developers by JetBrains

                             

                    b、使用

                            

                    c、编写代码（注意：缺少相应的库到终端下载就行了，建议把下载源换成国内镜像源会快很多。）

                            

    （2）云端

                    就是租一台GPU云服务帮助我们快速的跑深度学习代码。我用的是这款：

                    AutoDL-品质GPU租用平台-租GPU就上AutoDL

                    可以看到有很多性能强大的GPU，而且相对比较下来，价格还可以。

                     

                     还有一点就是可以使用别人搭建好的深度学习算法框架，可以直接拿来使用：

                    

                     创建一个实例，点击JupyterLab就可以进行代码编辑了

                    

                     在笔记本编写代码，然后保存为.py文件

                    

                     然后在终端输入指令运行就可以了。

                    

    2、实验二：特征数据集制作和PR曲线

    一、实验目的

    1.掌握数据集的归一化方法；掌握K折交叉验证；

    2.掌握P-R曲线特点及评价指标。

    二、实验环境

    1. 计算机；

    2. TensorFlow环境、Iris（鸢尾花）数据集。

    三、实验内容及实验步骤  

    1.实验内容

    （1）掌握K折交叉验证原理，以及数据集拆分；

     K折交叉验证原理参考：百度安全验证

     K折交叉验证优缺点：【机器学习基础】详细介绍 7 种交叉验证方法！|序列|拟合|样本|算法_网易订阅

    使用临近模型进行交叉验证：机器学习——鸢尾花案例——交叉验证_猿童学的博客-CSDN博客_鸢尾花交叉验证

    验证使用SVC分类器的分类模型

    K折交叉验证_直方大的博客-CSDN博客_k折交叉验证

    了解鸢尾花数据集： 鸢尾花(Iris)数据集_qinzhongyuan的博客-CSDN博客_鸢尾花数据集

    更多分类模型：关于鸢尾花数据集的分析 - 知乎 

    （2）掌握P-R曲线的评价指标和优点。

    分类评价指标了解TP、TN、FP、FN超级详细解析-爱码网

    输出鸢尾花原数据target的分类指标：https://blog.csdn.net/lxt1101/article/details/124280654

    了解P-R曲线：https://blog.csdn.net/b876144622/article/details/80009867

    SVM混淆矩阵：https://blog.csdn.net/Vicky_xiduoduo/article/details/124423779

    2.实验步骤

    （1）完成Iris数据集拆分（五折或十折）；

    a、10折交叉验证LR模型性能：

    1. from sklearn.datasets import load_iris
    2. from sklearn.model_selection import cross_val_score,KFold
    3. from sklearn.linear_model import LogisticRegression
    4. iris=load_iris()
    5. X=iris.data
    6. Y=iris.target
    7. logreg=LogisticRegression(max_iter=10000).fit(X, Y)#限制最大迭代次数
    8. kf=KFold(n_splits=10)
    9. score=cross_val_score(logreg,X,Y,cv=kf)
    10. print("Cross Validation Scores are {}".format(score))
    11. print("Average Cross Validation score :{}".format(score.mean()))

    输出：

    该模型的泛化能力可达0.947

    什么是LR模型：Kaggle知识点：sklearn模型迭代训练|bat|维度|神经网络_网易订阅

    b、10折交叉验证KNN临近模型性能：

    1. from sklearn.datasets import load_iris
    2. from sklearn.neighbors import KNeighborsClassifier
    3. from sklearn.model_selection import cross_val_score
    4. import matplotlib.pyplot as plt;
    5. iris=load_iris()
    6. X=iris.data
    7. y=iris.target
    8.  
    9. knn=KNeighborsClassifier(n_neighbors=5)
    10. scores = cross_val_score(knn,X,y,cv=10,scoring='accuracy')
    11. print(scores)
    12. print(scores.mean())
    13. k_range=range(1,31)
    14. k_scores=[]
    15. for k in k_range:
    16.     knn=KNeighborsClassifier(n_neighbors=k)
    17.     scores=cross_val_score(knn,X,y,cv=10,scoring='accuracy')
    18.     k_scores.append(scores.mean())
    19. print(k_scores)
    20. k_range=range(1,31)
    21. k_scores=[]
    22. for k in k_range:
    23.     knn=KNeighborsClassifier(n_neighbors=k)
    24.     scores=cross_val_score(knn,X,y,cv=10,scoring='accuracy')
    25.     k_scores.append(scores.mean())
    26. print(k_scores)
    27. plt.plot(k_range,k_scores)
    28. plt.xlabel('The value of the k in KNN')
    29. plt.ylabel('accuracy')
    30. plt.show()

    输出：

    该模型的最优泛华能力可达0.98

    c、验证SVC分类模型

    1. # 导入鸢尾花数据集
    2. from sklearn.datasets import load_iris
    3. from sklearn.model_selection import cross_val_score
    4. # 导入用于分类的svc分类器
    5. from sklearn.svm import SVC
    6.  
    7. iris = load_iris()
    8. x, y = iris.data, iris.target
    9.  
    10. svc = SVC(kernel='linear')
    11. # cv 为迭代次数， 这里设置为5
    12. scores = cross_val_score(svc, x, y, cv=5)
    13. # 5次，每次的结果
    14. print("交叉验证得分: %.4f %.4f %.4f %.4f %.4f" % (scores[0], scores[1], scores[2], scores[3], scores[4]))
    15. # 用得分均值作为最终得分
    16. print("res： %.4f" % (scores.mean()))

     输出：

    （2）采用分类算法（SVM、贝叶斯、或其它分类方法均可）对数据集进行分类；并记录TP、TN、FN和FP等参数；

    采用SVM支持向量机对数据进行分类：https://zhuanlan.zhihu.com/p/356445360

            1、导入需要的包 

    1. import tensorflow as tf
    2. import pandas as pd
    3. import numpy as np
    4. import matplotlib.pyplot as plt
    5. #设置显示中文
    6. plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
    7. plt.rcParams['axes.unicode_minus']=False #用来正常显示负号 #有中文出现的情况，需要u'内容'
    8. #导入鸢尾花数据集包
    9. from sklearn.datasets import load_iris
    10. #导入矩阵运算库
    11. import numpy as np
    12. #导入label_binarize()
    13. from sklearn.preprocessing import label_binarize
    14. #导入train_test_split
    15. from sklearn.model_selection import train_test_split
    16. #导入OneVsRestClassifier
    17. from sklearn.multiclass import OneVsRestClassifier
    18. #导入支持向量机
    19. from sklearn import svm,datasets
    20. from sklearn.svm import SVC
    21.  
    22. from itertools import cycle
    23. from sklearn.metrics import precision_recall_curve
    24. from sklearn.linear_model import LogisticRegression 
    25. from sklearn import metrics

            2、载入鸢尾花数据集

    1. #载入鸢尾花数据集并显示
    2. iris = load_iris()
    3. print(iris)

            输出数据集：

            3、下载数据并给重新定义数据

    1. #鸢尾花数据集
    2. TRAIN_URL = 'http://download.tensorflow.org/data/iris_training.csv' #数据下载地址
    3. train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1], TRAIN_URL)  #下载数据，并返回路径（默认路径）
    4. title = '鸢尾花数据集'
    5. names = ['花萼长度','花萼宽度','花瓣长度','花瓣宽度','品种']  #自定义列标题
    6. df_iris = pd.read_csv(train_path,header=0, names=names) #names指定的列标题会替代header指定的列标题
    7. #df_iris.head()   #读取前5行，参数n可以指定行数   tail（n）函数读取后n行数据

             4、鸢尾花数据集可视化函数

    1. #鸢尾花数据集可视化函数
    2. def draw_data(train_path,names,df_iris):
    3.     #可视化
    4.     fig = plt.figure('Iris Data', figsize=(15,15))
    5.     plt.suptitle('鸢尾花数据集\nBule->Setosa | Red->Versicolor | Green->Virginica', fontsize = 30)
    6.     for i in range(4):
    7.         for j in range(4):
    8.             plt.subplot(4,4, 4*i+(j+1))  #创建4*4的子画布，一行一行的循环画，其中每个子图的索引为 4*i+(j+1)
    9.             if i ==j:
    10.                 plt.text(0.3,0.5, names[i], fontsize = 25) #正对角线上的子图只显示标签
    11.             else:
    12.                 plt.scatter(np.array(df_iris)[:,j], np.array(df_iris)[:,i], c=np.array(df_iris)[:,4], cmap = 'brg')
    13.             if i == 0:
    14.                 plt.title(names[j], fontsize= 20)  #为了美观，把title当X轴标签
    15.             if j == 0:
    16.                 plt.ylabel(names[i], fontsize = 20) #设置Y轴标签
    17.  
    18.     plt.tight_layout(rect=[0,0,1,0.9])  #自动调整子图布局，设置0.9是为了给全局标题一点空间，避免拥挤
    19.     plt.savefig('Iris.jpg')
    20.     plt.show()
    21.     return;

             5、输出可视化数据集

    draw_data(train_path,names,df_iris)

             输出数据集：

            6、数据预处理

    1. #数据预处理
    2. '''
    3. 在开始对模型的训练之前，我们需要将数据集进行一定的处理。
    5. 我们需要将数据集分割为训练集和测试集两部分，同时加入噪音（noise），对于SVM模型，我们还需要将标签二值化，以便使用之后封装好的求值函数。
    7. 对于svm模型的数据集，我们使用：
    8. '''
    9. #获取鸢尾花数据集的特征和标签
    10. iris_feature = iris.data
    11. iris_label = iris.target
    12. #将标签二值化
    13. iris_label_res = label_binarize(iris_label,classes=[0,1,2])
    14. #得到标签的类别数
    15. n_classes = iris_label_res.shape[1]
    16. #加入噪音
    17. random_state = np.random.RandomState(0)
    18. n_samples, n_features = iris_feature.shape
    19. iris_feature_rand = np.c_[iris_feature, random_state.randn(n_samples, 200 * n_features)]
    20. #分割数据集，训练集与测试集比为1：1
    21. X_trainS, X_testS, y_trainS, y_testS = train_test_split(iris_feature_rand, iris_label_res, test_size=0.5, random_state=random_state)

            7、SVM模型训练

    1. #SVM模型训练
    2. #建立支持向量机
    3. clf1 = OneVsRestClassifier(svm.LinearSVC(random_state=random_state))
    4. #训练
    5. clf1.fit(X_trainS,y_trainS)

             训练过程

            8、获取预测置信度

    1. #使用测试集验证模型
    2. #得到预测的置信度
    3. y_scoreS=clf1.decision_function(X_testS)

             9、获取模型评测参数

    1. #封装好的方法，用来获取某个模型的P,R,TPR,FPR值
    2. def num_get(y_score,y_test,classes):
    3.     #建立存储字典
    4.     Precision=dict()
    5.     Recall=dict()
    6.     TPR=dict()
    7.     FPR=dict()
    8.     #由于我们是多标签模型，所以循环输出每种标签的值
    9.     for i in range(classes):
    10.         #截取预测结果的第i列，_代表无关变量
    11.         Precision[i],Recall[i],_ = precision_recall_curve(y_test[:,i],y_score[:,i])
    12.         FPR[i],TPR[i],_ = metrics.roc_curve(y_test[:,i], y_score[:,i])
    13.     return Precision,Recall,TPR,FPR

             10、绘图函数

    1. #绘制模型的P-R曲线与ROC曲线
    2. def draw_line(Precision,Recall,TPR,FPR,classes,title): 
    3.     colors = cycle(['navy', 'turquoise', 'darkorange', ])
    4.     plt.figure(figsize=(14, 8))
    5.     plt.suptitle(title+' 的P-R曲线和ROC曲线', fontsize = 30)
    6.     ax1=plt.subplot(1,2,1)
    7.     plt.xlabel("Recall")
    8.     plt.ylabel("Preccision")
    9.     plt.xlim([0.0, 1.0])
    10.     plt.ylim([0.0, 1.05])
    11.     for i, color in zip(range(classes), colors):
    12.         l, = plt.plot(Recall[i], Precision[i], color=color)
    13.     ax2=plt.subplot(1,2,2)
    14.     plt.xlabel("False Positive Rate")
    15.     plt.ylabel("True Positive Rate")
    16.     plt.xlim([0.0, 1.0])
    17.     plt.ylim([0.0, 1.05])
    18.     for i, color in zip(range(classes), colors):
    19.         print(color)
    20.         l, = plt.plot(FPR[i], TPR[i], color=color)
    21.     ax1.set_title("P-R Pic")
    22.     ax2.set_title("ROC Pic")
    23.     plt.savefig(title+'PR-ROC.png')
    24.     plt.show()
    25.     return 0

            11、获取函数返回值

    Precision,Recall,TPR,FPR = num_get(y_scoreS,y_testS,3)

             12、绘制PR、ROC曲线

    1. #SVM模型p-r曲线
    2. draw_line(Precision,Recall,TPR,FPR,3,title)

    （3）绘制P-R曲线，保存曲线图片。

            

    3、实验三：线性回归及拟合

    一、实验目的

    1.掌握二次回归、线性回归的思想；

    2.掌握回归方法的评价R-squared。

    二、实验环境

    1. 计算机；

    2. TensorFlow环境；

    三、实验内容及实验步骤  

    1.实验内容

    （1）掌握二次回归和线性回归的拟合方法，以及对比结果；保存对比结果图；

    机器学习线性回归、多项式回归、逻辑回归总结：

    [Python从零到壹] 十二.机器学习之回归分析万字总结全网首发（线性回归、多项式回归、逻辑回归）_Eastmount的博客-CSDN博客_什么是一元线性回归和多项式回归

    基于sklearn线性回归、二次回归比较：

    使用Sklearn进行线性回归和二次回归的比较（基于jupyter）_叽叽贝贝的博客-CSDN博客_sklearn 二次回归

    （2）实验用数据集，如下：

    表1 实验训练数据集

    数据1

    数据2

    数据3

    数据4

    数据5

    披萨尺寸（X）

    6

    8

    10

    14

    17

    披萨价格（Y）

    7

    9

    13

    17.5

    18

    表2 实验测试集

    数据1

    数据2

    数据3

    数据4

    披萨尺寸（X）

    7

    9

    11

    15

    披萨价格（Y）

    8

    12

    15

    18

    2.实验步骤

    （1）采用二次回归方法绘制回归曲线，保存回归曲线图；

    1. # -*- coding: utf-8 -*-
    2. from sklearn.linear_model import LinearRegression     
    3. from sklearn.preprocessing import PolynomialFeatures
    4. import matplotlib.pyplot as plt       
    5. import numpy as np
    6.  
    7. #X表示披萨尺寸 Y表示披萨价格
    8. X = [[6], [8], [10], [14], [17]]
    9. Y = [[7], [9], [13], [17.5], [18]]
    10. print('数据集X: ', X)
    11. print('数据集Y: ', Y)
    12.  
    13. #第一步 线性回归分析
    14. clf = LinearRegression() 
    15. clf.fit(X, Y)                     
    16. #预测结果
    17. X2 = [[7], [9], [11],[15]]
    18. Y2 = clf.predict(X2)
    19. print(Y2)
    20.  
    21. res = clf.predict(np.array([20]).reshape(-1, 1))[0]   
    22. print('预测披萨尺寸为20的价格：$%.1f' % res) 
    23.  
    24. plt.plot(X, Y, 'ks')    #绘制训练数据集散点图
    25. #plt.plot(X2, Y2, 'g-')  #绘制预测数据集直线 
    26.  
    27. #第二步 多项式回归分析
    28. xx = np.linspace(1,20,10) #1到20等差数列，取20个点
    29. quadratic_featurizer = PolynomialFeatures(degree = 2) #实例化一个二次多项式
    30. x_train_quadratic = quadratic_featurizer.fit_transform(X) #用二次多项式x做变换
    31. X_test_quadratic = quadratic_featurizer.transform(X2)
    32. regressor_quadratic = LinearRegression()
    33. regressor_quadratic.fit(x_train_quadratic, Y)
    34.  
    35. #把训练好X值的多项式特征实例应用到一系列点上,形成矩阵
    36. xx_quadratic = quadratic_featurizer.transform(xx.reshape(xx.shape[0], 1))
    37. plt.plot(xx, regressor_quadratic.predict(xx_quadratic), "r--",
    38.          label="$y = ax^2 + bx + c$",linewidth=2)
    39. plt.legend()
    40. plt.show()

    绘制二次回归曲线

    （2）求解线性回归（一次~五次）和二次回归的R-squared参数，保存参数结果；

    一次线性回归：

    1. # -*- coding: utf-8 -*-
    2. from sklearn import linear_model     #导入线性模型
    3. import matplotlib.pyplot as plt       
    4. import numpy as np
    5.  
    6. #X表示披萨尺寸 Y表示披萨价格
    7. X = [[6], [8], [10], [14], [17]]
    8. Y = [[7], [9], [13], [17.5], [18]]
    9. print('数据集X: ', X)
    10. print('数据集Y: ', Y)
    11.  
    12. #回归训练
    13. clf = linear_model.LinearRegression() 
    14. clf.fit(X, Y)
    15.  
    16. #预测结果
    17. X2 = [[7], [9], [11],[15]]
    18. Y2 = clf.predict(X2)
    19. print(Y2)
    20. res = clf.predict(np.array([20]).reshape(-1, 1))[0]   
    21. print('预测披萨尺寸为20的价格：$%.1f' % res) 
    22.  
    23. #绘制线性回归图形
    24. plt.plot(X, Y, 'ks')                 #绘制训练数据集散点图
    25. plt.plot(X2, Y2, 'g-')               #绘制预测数据集直线
    26. plt.show()
    27. print('1 r-squared', clf.score(X, Y))

    输出图像和参数：

     

     二次回归：

    1. # -*- coding: utf-8 -*-
    2. from sklearn.linear_model import LinearRegression     
    3. from sklearn.preprocessing import PolynomialFeatures
    4. import matplotlib.pyplot as plt       
    5. import numpy as np
    6.  
    7. #X表示披萨尺寸 Y表示披萨价格
    8. X = [[6], [8], [10], [14], [17]]
    9. Y = [[7], [9], [13], [17.5], [18]]
    10. print('数据集X: ', X)
    11. print('数据集Y: ', Y)
    12.  
    13. #第一步 线性回归分析
    14. clf = LinearRegression() 
    15. clf.fit(X, Y)                     
    16. #预测结果
    17. X2 = [[7], [9], [11],[15]]
    18. Y2 = clf.predict(X2)
    19. print(Y2)
    20.  
    21. res = clf.predict(np.array([20]).reshape(-1, 1))[0]   
    22. print('预测披萨尺寸为20的价格：$%.1f' % res) 
    23.  
    24. plt.plot(X, Y, 'ks')    #绘制训练数据集散点图
    25. #plt.plot(X2, Y2, 'g-')  #绘制预测数据集直线 
    26.  
    27. #第二步 多项式回归分析
    28. xx = np.linspace(1,20,10) #1到20等差数列，取20个点
    29. quadratic_featurizer = PolynomialFeatures(degree = 2) #实例化一个二次多项式
    30. x_train_quadratic = quadratic_featurizer.fit_transform(X) #用二次多项式x做变换
    31. X_test_quadratic = quadratic_featurizer.transform(X2)
    32. regressor_quadratic = LinearRegression()
    33. regressor_quadratic.fit(x_train_quadratic, Y)
    34.  
    35. #把训练好X值的多项式特征实例应用到一系列点上,形成矩阵
    36. xx_quadratic = quadratic_featurizer.transform(xx.reshape(xx.shape[0], 1))
    37. plt.plot(xx, regressor_quadratic.predict(xx_quadratic), "r--",
    38.          label="$y = ax^2 + bx + c$",linewidth=2)
    39. plt.legend()
    40. plt.show()    
    41. print('2 r-squared', regressor_quadratic.score(x_train_quadratic, Y))

    输出图像及参数：

    三次回归：

    1. # -*- coding: utf-8 -*-
    2. from sklearn.linear_model import LinearRegression     
    3. from sklearn.preprocessing import PolynomialFeatures
    4. import matplotlib.pyplot as plt       
    5. import numpy as np
    6.  
    7. #X表示披萨尺寸 Y表示披萨价格
    8. X = [[6], [8], [10], [14], [17]]
    9. Y = [[7], [9], [13], [17.5], [18]]
    10. print('数据集X: ', X)
    11. print('数据集Y: ', Y)
    12.  
    13. #第一步 线性回归分析
    14. clf = LinearRegression() 
    15. clf.fit(X, Y)                     
    16. #预测结果
    17. X2 = [[7], [9], [11],[15]]
    18. Y2 = clf.predict(X2)
    19. print(Y2)
    20.  
    21. res = clf.predict(np.array([20]).reshape(-1, 1))[0]   
    22. print('预测披萨尺寸为20的价格：$%.1f' % res) 
    23.  
    24. plt.plot(X, Y, 'ks')    #绘制训练数据集散点图
    25. #plt.plot(X2, Y2, 'g-')  #绘制预测数据集直线 
    26.  
    27. #第二步 多项式回归分析
    28. xx = np.linspace(1,20,10) #1到20等差数列，取20个点
    29. quadratic_featurizer = PolynomialFeatures(degree = 3) #实例化一个二次多项式
    30. x_train_quadratic = quadratic_featurizer.fit_transform(X) #用二次多项式x做变换
    31. X_test_quadratic = quadratic_featurizer.transform(X2)
    32. regressor_quadratic = LinearRegression()
    33. regressor_quadratic.fit(x_train_quadratic, Y)
    34.  
    35. #把训练好X值的多项式特征实例应用到一系列点上,形成矩阵
    36. xx_quadratic = quadratic_featurizer.transform(xx.reshape(xx.shape[0], 1))
    37. plt.plot(xx, regressor_quadratic.predict(xx_quadratic), "r--",
    38.          label="$y = ax^3 + bx^2 + cx+d$",linewidth=3)
    39. plt.legend()
    40. plt.show()    
    41. print('2 r-squared', regressor_quadratic.score(x_train_quadratic, Y))

     图像及参数：

    四次回归：

    1. # -*- coding: utf-8 -*-
    2. from sklearn.linear_model import LinearRegression     
    3. from sklearn.preprocessing import PolynomialFeatures
    4. import matplotlib.pyplot as plt       
    5. import numpy as np
    6.  
    7. #X表示披萨尺寸 Y表示披萨价格
    8. X = [[6], [8], [10], [14], [17]]
    9. Y = [[7], [9], [13], [17.5], [18]]
    10. print('数据集X: ', X)
    11. print('数据集Y: ', Y)
    12.  
    13. #第一步 线性回归分析
    14. clf = LinearRegression() 
    15. clf.fit(X, Y)                     
    16. #预测结果
    17. X2 = [[7], [9], [11],[15]]
    18. Y2 = clf.predict(X2)
    19. print(Y2)
    20.  
    21. res = clf.predict(np.array([20]).reshape(-1, 1))[0]   
    22. print('预测披萨尺寸为20的价格：$%.1f' % res) 
    23.  
    24. plt.plot(X, Y, 'ks')    #绘制训练数据集散点图
    25. #plt.plot(X2, Y2, 'g-')  #绘制预测数据集直线 
    26.  
    27. #第二步 多项式回归分析
    28. xx = np.linspace(1,20,10) #1到20等差数列，取20个点
    29. quadratic_featurizer = PolynomialFeatures(degree = 4) #实例化一个二次多项式
    30. x_train_quadratic = quadratic_featurizer.fit_transform(X) #用二次多项式x做变换
    31. X_test_quadratic = quadratic_featurizer.transform(X2)
    32. regressor_quadratic = LinearRegression()
    33. regressor_quadratic.fit(x_train_quadratic, Y)
    34.  
    35. #把训练好X值的多项式特征实例应用到一系列点上,形成矩阵
    36. xx_quadratic = quadratic_featurizer.transform(xx.reshape(xx.shape[0], 1))
    37. plt.plot(xx, regressor_quadratic.predict(xx_quadratic), "r--",
    38.          label="$y = ax^4 + bx^3 + cx^2+dx+e$",linewidth=4)
    39. plt.legend()
    40. plt.show()    
    41. print('4 r-squared', regressor_quadratic.score(x_train_quadratic, Y))

     图像及参数：

    五次回归：

    1. # -*- coding: utf-8 -*-
    2. from sklearn.linear_model import LinearRegression     
    3. from sklearn.preprocessing import PolynomialFeatures
    4. import matplotlib.pyplot as plt       
    5. import numpy as np
    6.  
    7. #X表示披萨尺寸 Y表示披萨价格
    8. X = [[6], [8], [10], [14], [17]]
    9. Y = [[7], [9], [13], [17.5], [18]]
    10. print('数据集X: ', X)
    11. print('数据集Y: ', Y)
    12.  
    13. #第一步 线性回归分析
    14. clf = LinearRegression() 
    15. clf.fit(X, Y)                     
    16. #预测结果
    17. X2 = [[7], [9], [11],[15]]
    18. Y2 = clf.predict(X2)
    19. print(Y2)
    20.  
    21. res = clf.predict(np.array([20]).reshape(-1, 1))[0]   
    22. print('预测披萨尺寸为20的价格：$%.1f' % res) 
    23.  
    24. plt.plot(X, Y, 'ks')    #绘制训练数据集散点图
    25. #plt.plot(X2, Y2, 'g-')  #绘制预测数据集直线 
    26.  
    27. #第二步 多项式回归分析
    28. xx = np.linspace(1,20,10) #1到20等差数列，取20个点
    29. quadratic_featurizer = PolynomialFeatures(degree = 5) #实例化一个二次多项式
    30. x_train_quadratic = quadratic_featurizer.fit_transform(X) #用二次多项式x做变换
    31. X_test_quadratic = quadratic_featurizer.transform(X2)
    32. regressor_quadratic = LinearRegression()
    33. regressor_quadratic.fit(x_train_quadratic, Y)
    34.  
    35. #把训练好X值的多项式特征实例应用到一系列点上,形成矩阵
    36. xx_quadratic = quadratic_featurizer.transform(xx.reshape(xx.shape[0], 1))
    37. plt.plot(xx, regressor_quadratic.predict(xx_quadratic), "r--",
    38.          label="$y = ax^5 + bx^4 + cx^3+dx^2+ex+f$",linewidth=5)
    39. plt.legend()
    40. plt.show()    
    41. print('5 r-squared', regressor_quadratic.score(x_train_quadratic, Y))

    图像及参数：

    （3）对比R-squared参数，说明披萨尺寸和价格关系的回归曲线具有优势。

    数据显示：

    1 r-squared 
    0.9401041666666667
    2 r-squared 
    0.98230094001666
    3 r-squared 
    0.9953548068462904
    4 r-squared 
    1.0
    5 r-squared 
    1.0

                    从数据显示来看，多项式越多且最高次幂越大，回归效果越好。但是本次实验数据较少，如果数据增多，肯能会存在峰值效应。

    4、实验四：卷积神经网络应用

    一、实验目的

    1.掌握卷积神经网络（Convolutional Neural Networks, CNN）的结构；

    2.掌握卷积层、池化层和全连接层的功能；

    3.掌握卷积神经网络的基本功能。

    二、实验环境

    1. 计算机；

    2. TensorFlow环境，手写数字（mnist）数据集。

    mnist手写数据集：https://blog.csdn.net/OpenDataLab/article/details/125716623

    三、实验内容及实验步骤  

    1. 实验内容

    （1）搭建CNN网络；

    CNN详解：CNN（卷积神经网络）介绍 - 知乎

    搭建CNN进行MNIST手写数字识别模型训练：https://blog.csdn.net/qq_43673118/article/details/102992944

    （2）识别手写数字。

     对手写模型进行测试：

    keras搭建神经网络实验（二）：CNN识别手写数字_矢三郎的狸猫的博客-CSDN博客

    2. 实验步骤

    （1）搭建CNN网络，设置核函数数量及参数；按顺序建立卷积层和池化层；

    1、导包

    1. import keras
    2. from keras.models import model_from_json
    3. from keras.models import Sequential
    4. from keras.layers import Dense,Dropout,Flatten,Conv2D,MaxPooling2D
    5. from keras.datasets import mnist
    6. from keras.utils import np_utils
    7. import numpy as np
    8. import h5py
    9. from keras.models import load_model
    10. import matplotlib.pyplot as plt
    11. import os
    12. import cv2
    13. from PIL import Image
    14. num_classes = 10

     2、加载数据

    1. # Load data
    2. path='mnist.npz'
    3. f = np.load(path)
    4. x_train, y_train = f['x_train'], f['y_train']
    5. x_test, y_test = f['x_test'], f['y_test']
    6. f.close()

     3、数据预处理

    1. x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32')
    2. x_test = x_test.reshape(x_test.shape[0], 28, 28, 1).astype('float32')
    3. x_train /= 255
    4. x_test /= 255
    5. print(x_train.shape[0], 'train samples')
    6. print(x_test.shape[0], 'test samples')
    7.  
    8. y_train = keras.utils.to_categorical(y_train, num_classes)
    9. y_test = keras.utils.to_categorical(y_test, num_classes)

    4、搭建CNN模型

    1. # Build CNN
    2. model = Sequential()
    3. model.add(Conv2D(filters=16,
    4.                  kernel_size=(5,5),
    5.                  padding='same',
    6.                  input_shape=(28,28,1), 
    7.                  activation='relu'))
    8. model.add(MaxPooling2D(pool_size=(2, 2)))
    9. model.add(Conv2D(filters=36,
    10.                  kernel_size=(5,5),
    11.                  padding='same',
    12.                  activation='relu'))
    13. model.add(MaxPooling2D(pool_size=(2, 2)))
    14. model.add(Dropout(0.25))
    15. model.add(Flatten())
    16. model.add(Dense(128, activation='relu'))
    17. model.add(Dropout(0.5))
    18. model.add(Dense(10,activation='softmax'))

     5、模型训练

    1. # Train model
    2. model.compile(loss='categorical_crossentropy',
    3.               optimizer='adam',metrics=['accuracy'])
    4. model.fit(x_train,y_train,batch_size=100,epochs=20)
    5. result = model.evaluate(x_test,y_test)
    6. print ('\nTest Acc:',result[1])
    7. result = model.evaluate(x_train,y_train)
    8. print ('\nTrain Acc:',result[1])

    6、进行手写识别测试

    （1）在项目环境中创建文件夹—testnumbers

    （2）添加手写测试文件：

    打开画图软件自己手写0·9的图片保存在文件夹中即可。

    1. # Load Image
    2. file_name = '0.png'
    3. img = Image.open('./testnumbers/'+file_name)
    4. im_arr = np.array(img.convert("L"))
    5. im_arr = im_arr.astype('float32')/255
    6. im_arr = 1-im_arr  #灰度反转
    7. print('\n输入：'+file_name)

    7、处理图像数组

    1. #resize图片大小 先将原本的(224,222,3) ---> (28,28,3)
    2. im_arr = cv2.resize(im_arr,(28,28))                          
    3. #转换np数组格式
    4. im_arr = np.array(im_arr)

     8、进行预测

    1. # predict
    2. predict = model.predict(im_arr.reshape(1,28,28,1))
    3. print('识别为：')
    4. print(np.where(predict[0]==np.max(predict[0]))[0][0])
    5. plt.imshow(im_arr, cmap='gray')
    6. plt.show()

    （2）识别手写数字，并保存代码执行过程中的重要结果图，计算识别率；

    （3）改变核函数、卷积层数量和池化层数量，重新计算识别率，并与之前结果比较。

    修改模型：将卷积大小改为4*4，去去掉池化层。

    1. # Build CNN
    2. model = Sequential()
    3. model.add(Conv2D(filters=16,
    4.                  kernel_size=(4,4),
    5.                  padding='same',
    6.                  input_shape=(28,28,1), 
    7.                  activation='relu'))
    8. model.add(Dropout(0.25))
    9. model.add(Flatten())
    10. model.add(Dense(128, activation='relu'))
    11. model.add(Dropout(0.5))
    12. model.add(Dense(10,activation='softmax'))

    输出结果：

     

    代码附录：

    1、CNN模型代码：

    1. #导入模块
    2. import tensorflow as tf
    3. #导入数据集
    4. mnist = tf.keras.datasets.mnist
    5. (x_train, y_train), (x_test, y_test) = mnist.load_data()
    6. #Reshape
    7. x_train4D = x_train.reshape(x_train.shape[0],28,28,1).astype('float32') 
    8. x_test4D = x_test.reshape(x_test.shape[0],28,28,1).astype('float32') 
    9. #像素标准化
    10. x_train, x_test = x_train4D / 255.0, x_test4D / 255.0
    11. model = tf.keras.models.Sequential([
    12.     tf.keras.layers.Conv2D(filters=16, kernel_size=(5,5), padding='same',
    13.                  input_shape=(28,28,1),  activation='relu'),
    14.     tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
    15.     tf.keras.layers.Conv2D(filters=36, kernel_size=(5,5), padding='same', 
    16.     			 activation='relu'),
    17.     tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
    18.     tf.keras.layers.Dropout(0.25),
    19.     tf.keras.layers.Flatten(),
    20.     tf.keras.layers.Dense(128, activation='relu'),
    21.     tf.keras.layers.Dropout(0.5),
    22.     tf.keras.layers.Dense(10,activation='softmax')
    23. ])
    24.  
    25. #打印模型
    26. print(model.summary())
    27. #训练配置
    28. model.compile(loss='sparse_categorical_crossentropy',
    29.               optimizer='adam', metrics=['accuracy']) 
    30. #开始训练
    31. model.fit(x=x_train, y=y_train, validation_split=0.2, 
    32.                         epochs=20, batch_size=300, verbose=2)

    输出模型：

     训练结果：

    2、 保存h5模型文件：

    1. import keras
    2. from keras.models import model_from_json
    3. from keras.models import Sequential
    4. from keras.layers import Dense,Dropout,Flatten,Conv2D,MaxPooling2D
    5. from keras.datasets import mnist
    6. from keras.utils import np_utils
    7. import numpy as np
    8. import h5py
    9. from keras.models import load_model
    10. import matplotlib.pyplot as plt
    11. import os
    12. import cv2
    13. from PIL import Image
    14. num_classes = 10
    15.  
    16. # Load data
    17. path='mnist.npz'
    18. f = np.load(path)
    19. x_train, y_train = f['x_train'], f['y_train']
    20. x_test, y_test = f['x_test'], f['y_test']
    21. f.close()
    22.  
    23. x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32')
    24. x_test = x_test.reshape(x_test.shape[0], 28, 28, 1).astype('float32')
    25. x_train /= 255
    26. x_test /= 255
    27. print(x_train.shape[0], 'train samples')
    28. print(x_test.shape[0], 'test samples')
    29.  
    30. y_train = keras.utils.to_categorical(y_train, num_classes)
    31. y_test = keras.utils.to_categorical(y_test, num_classes)
    32.  
    33. # Build CNN
    34. model = Sequential()
    35. model.add(Conv2D(filters=16,
    36.                  kernel_size=(5,5),
    37.                  padding='same',
    38.                  input_shape=(28,28,1), 
    39.                  activation='relu'))
    40. model.add(MaxPooling2D(pool_size=(2, 2)))
    41. model.add(Conv2D(filters=36,
    42.                  kernel_size=(5,5),
    43.                  padding='same',
    44.                  activation='relu'))
    45. model.add(MaxPooling2D(pool_size=(2, 2)))
    46. model.add(Dropout(0.25))
    47. model.add(Flatten())
    48. model.add(Dense(128, activation='relu'))
    49. model.add(Dropout(0.5))
    50. model.add(Dense(10,activation='softmax'))
    51.  
    52. # Train model
    53. model.compile(loss='categorical_crossentropy',
    54.               optimizer='adam',metrics=['accuracy'])
    55. model.fit(x_train,y_train,batch_size=100,epochs=20)
    56. result = model.evaluate(x_test,y_test)
    57. print ('\nTest Acc:',result[1])
    58. result = model.evaluate(x_train,y_train)
    59. print ('\nTrain Acc:',result[1])
    60.  
    61. # save model
    62. model_json = model.to_json()
    63. with open('cnn_model.json','w') as json_file:
    64.     json_file.write(model_json)
    65. # serialize weight to HDF5
    66. model.save_weights('cnn_model.h5')
    67. print('Save ,odel to disk')

    3、调用模型h5文件：

    1. #导入h5模型进行测试
    2. from keras.models import model_from_json
    3. from keras.models import load_model
    4. import keras
    5. import numpy as np
    6. import matplotlib.pyplot as plt
    7. import os
    8. import cv2
    9. from PIL import Image
    10.  
    11. # load json and create model
    12. json_file = open('cnn_model.json', 'r')
    13. loaded_model_json = json_file.read()
    14. json_file.close()
    15. loaded_model = model_from_json(loaded_model_json)
    16. # load weights into new model
    17. loaded_model.load_weights("cnn_model.h5")
    18. print("Loaded model from disk")
    19.  
    20. loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    21.  
    22. # Load Image
    23. file_name = '0.png'
    24. img = Image.open('./testnumbers/'+file_name)
    25. im_arr = np.array(img.convert("L"))
    26. im_arr = im_arr.astype('float32')/255
    27. im_arr = 1-im_arr  #灰度反转
    28. print('\n输入：'+file_name)
    29.  
    30. #resize图片大小 先将原本的(224,222,3) ---> (28,28,3)
    31. im_arr = cv2.resize(im_arr,(28,28))                          
    32. #转换np数组格式
    33. im_arr = np.array(im_arr)   
    34.  
    35. # predict
    36. predict = loaded_model.predict(im_arr.reshape(1,28,28,1))
    37. print('识别为：')
    38. print(np.where(predict[0]==np.max(predict[0]))[0][0])
    39. plt.imshow(im_arr, cmap='gray')
    40. plt.show()

    5、实验五：生成对抗式网络应用

    一、实验目的

    1.掌握生成式对抗网络（）基本结构和功能；

    2.掌握GAN网络的基本应用。

    二、实验环境

    1. 计算机；

    2. Pytorch环境或Jupyter环境。

    三、实验内容及实验步骤  

    1. 实验内容

    （1）搭建GAN网络；

    （2）采用GAN网络生成数据。

    参考文章1：https://blog.csdn.net/fuxun222/article/details/126714792

    参考文章2：https://blog.csdn.net/soih0718/article/details/121585655

    2. 实验步骤

    （1）搭建GAN网络，配置Pytorch环境或Jupyter环境；

    1、导库

    1. import torch 
    2. import torch.nn as nn
    3. import pandas as pd
    4. import matplotlib.pyplot as plt
    5. import random
    6. import numpy

    2、构建真实数据源

    1. def generate_real():
    2.     real_data = torch.FloatTensor([random.uniform(0.8,1.0),
    3.     random.uniform(0.0,0.2),
    4.     random.uniform(0.8,1.0),
    5.     random.uniform(0.0,0.2),
    6.     ])
    7.     return real_data

    3、 创建一个函数生成随机噪声模式

    1. def generate_random(size):
    2.     random_data = torch.rand(size)
    3.     return random_data

     4、构建鉴别器

    1. class Discriminator(nn.Module):
    2.  
    3.     def __init__(self):
    4.         # 初始化 PyTorch 父类
    5.         super().__init__()
    6.         
    7.         # 定义神经网络各层：线性层-sigmoid函数-线性层-sigmoid函数
    8.         self.model = nn.Sequential(
    9.             nn.Linear(4, 3),
    10.             nn.Sigmoid(),
    11.             nn.Linear(3, 1),
    12.             nn.Sigmoid()
    13.         )
    14.         # 使用均方值误差作为损失函数
    15.         self.loss_function = nn.MSELoss()
    16.         # 使用随机梯度下降（SGD）创建优化器
    17.         self.optimiser = torch.optim.SGD(self.parameters(), lr=0.01)
    18.         # 计数器和累加器，用于流程控制和显示
    19.         self.counter = 0
    20.         self.progress = []
    21.         pass
    22.  
    23.     def forward(self,inputs):
    24.         return self.model(inputs)
    25.     
    26.     def train(self, inputs, targets):
    27.         # 计算网络的输出
    28.         outputs = self.forward(inputs) 
    29.         # 计算损失值
    30.         loss = self.loss_function(outputs, targets)
    31.         # 每运行10次，增加计数器和累加器
    32.         self.counter += 1
    33.         if (self.counter % 10 == 0):
    34.             self.progress.append(loss.item())
    35.             pass
    36.         if (self.counter % 10000 == 0):
    37.             print("counter = ", self.counter)
    38.             pass
    39.         # 将梯度置零，并运行反向更新权重
    40.         self.optimiser.zero_grad()
    41.         loss.backward()
    42.         self.optimiser.step()
    43.         pass
    44.  
    45.     def plot_progress(self):
    46.         df = pd.DataFrame(self.progress, columns=['loss'])
    47.         fig = df.plot(ylim=(0, 1.0), figsize=(16, 8), alpha=0.1, marker='.', grid=True, yticks=(0, 0.25, 0.5))
    48.         fig.figure.savefig('../root/1121_.png')
    49.         pass

    5、测试鉴别器

    D=Discriminator()

    6、训练循环10000次

    1. for i in range(10000):
    2.     D.train(generate_real(),torch.FloatTensor([1.0]))
    3.     D.train(generate_random(4),torch.FloatTensor([0.0]))

    7、绘制损失值图像

    D.plot_progress()

    输出：

    8、构建生成器

    1. class Generator(nn.Module):
    2.     def __init__(self):
    3.         super().__init__()
    4.         self.model=nn.Sequential(
    5.             nn.Linear(1,3),
    6.             nn.Sigmoid(),
    7.             nn.Linear(3,4),
    8.             nn.Sigmoid()
    9.         )
    10.         self.optimiser = torch.optim.SGD(self.parameters(), lr=0.01)
    11.         self.counter=0
    12.         self.progress=[]
    13.         pass
    14.     
    15.     def forward(self, inputs):
    16.             # 简单的运行模型
    17.             return self.model(inputs)
    18.         
    19.     def train(self,D,inputs,targets):
    20.         g_output=self.forward(inputs)
    21.         d_output = D.forward(g_output)
    22.         
    23.         loss=D.loss_function(d_output,targets)
    24.         
    25.         self.counter+=1
    26.         if(self.counter%10==0):
    27.             self.progress.append(loss.item())
    28.             pass
    29.         self.optimiser.zero_grad()
    30.         loss.backward()
    31.         self.optimiser.step()
    32.         pass
    33.     pass
    34.

     9、测试生成器的输出

    1. G=Generator()
    2. G.forward(torch.FloatTensor([0.5]))

    10、训练GAN网络

            通过前面的工作，就做好了使用 3 步训练循环对 GAN 进行训练的准备。

    1. # create Discriminator and Generator
    2.  
    3. D = Discriminator()
    4. G = Generator()
    5.  
    6. image_list = []
    7.  
    8. # train Discriminator and Generator
    9.  
    10. for i in range(10000):
    11.     
    12.     # train discriminator on true
    13.     D.train(generate_real(), torch.FloatTensor([1.0]))
    14.     
    15.     # train discriminator on false
    16.     # use detach() so gradients in G are not calculated
    17.     D.train(G.forward(torch.FloatTensor([0.5])).detach(), torch.FloatTensor([0.0]))
    18.     D
    19.     # train generator
    20.     G.train(D, torch.FloatTensor([0.5]), torch.FloatTensor([1.0]))
    21.     
    22.     # add image to list every 1000
    23.     if (i % 1000 == 0):
    24.         image_list.append( G.forward(torch.FloatTensor([0.5])).detach().numpy() )
    25.     pass

    11、再次观察鉴别器的损失值图像

    1. #使用鉴别器查看损失值
    2. D.plot_progress()

    12、查看训练完第一次生成的数据

    1. #试验训练后第一次生成的数据
    2. G.forward(torch.FloatTensor([0.5]))

    13、为了查看生成器的损失值，在生成器里创建一个画图函数

    1. def plot_progress(self):
    2.         df = pd.DataFrame(self.progress, columns=['loss'])
    3.         fig = df.plot(ylim=(0, 1.0), figsize=(16, 8), alpha=0.1, marker='.', grid=True, yticks=(0, 0.25, 0.5))
    4.         fig.figure.savefig('../root/G_loss.png')
    5.         pass

    14、查看生成器损失值

    1. #使用鉴别器查看损失值
    2. G.plot_progress()

     15、最后输出1010格式规律在训练过程中是如何演变的

    1. plt.figure(figsize = (16,8))
    2. plt.imshow(numpy.array(image_list).T, interpolation='none', cmap='Blues')
    3. plt.savefig('../root/result.png')

    （2）采用GAN网络生成[1  0  1  0]结构的数据，保存实验重要过程及结果。

    这个图表清楚地显示出随着时间改变，生成器如何改进的。 

     完整代码：

    1. import torch 
    2. import torch.nn as nn
    3. import pandas as pd
    4. import matplotlib.pyplot as plt
    5. import random
    6. import numpy
    7.  
    8. def generate_real():
    9.     real_data = torch.FloatTensor([random.uniform(0.8,1.0),
    10.     random.uniform(0.0,0.2),
    11.     random.uniform(0.8,1.0),
    12.     random.uniform(0.0,0.2),
    13.     ])
    14.     return real_data
    15.  
    16. def generate_random(size):
    17.     random_data = torch.rand(size)
    18.     return random_data
    19.  
    20.  
    21. class Discriminator(nn.Module):
    22.  
    23.     def __init__(self):
    24.         # 初始化 PyTorch 父类
    25.         super().__init__()
    26.         
    27.         # 定义神经网络各层：线性层-sigmoid函数-线性层-sigmoid函数
    28.         self.model = nn.Sequential(
    29.             nn.Linear(4, 3),
    30.             nn.Sigmoid(),
    31.             nn.Linear(3, 1),
    32.             nn.Sigmoid()
    33.         )
    34.         # 使用均方值误差作为损失函数
    35.         self.loss_function = nn.MSELoss()
    36.         # 使用随机梯度下降（SGD）创建优化器
    37.         self.optimiser = torch.optim.SGD(self.parameters(), lr=0.01)
    38.         # 计数器和累加器，用于流程控制和显示
    39.         self.counter = 0
    40.         self.progress = []
    41.         pass
    42.  
    43.     def forward(self,inputs):
    44.         return self.model(inputs)
    45.     
    46.     def train(self, inputs, targets):
    47.         # 计算网络的输出
    48.         outputs = self.forward(inputs) 
    49.         # 计算损失值
    50.         loss = self.loss_function(outputs, targets)
    51.         # 每运行10次，增加计数器和累加器
    52.         self.counter += 1
    53.         if (self.counter % 10 == 0):
    54.             self.progress.append(loss.item())
    55.             pass
    56.         if (self.counter % 10000 == 0):
    57.             print("counter = ", self.counter)
    58.             pass
    59.         # 将梯度置零，并运行反向更新权重
    60.         self.optimiser.zero_grad()
    61.         loss.backward()
    62.         self.optimiser.step()
    63.         pass
    64.  
    65.     def plot_progress(self):
    66.         df = pd.DataFrame(self.progress, columns=['loss'])
    67.         fig = df.plot(ylim=(0, 1.0), figsize=(16, 8), alpha=0.1, marker='.', grid=True, yticks=(0, 0.25, 0.5))
    68.         fig.figure.savefig('../root/D_loss.png')
    69.         pass    
    70.  
    71. D=Discriminator()
    72.  
    73. for i in range(10000):
    74.     D.train(generate_real(),torch.FloatTensor([1.0]))
    75.     D.train(generate_random(4),torch.FloatTensor([0.0]))
    76.  
    77. D.plot_progress()
    78.  
    79. class Generator(nn.Module):
    80.     def __init__(self):
    81.         super().__init__()
    82.         self.model=nn.Sequential(
    83.             nn.Linear(1,3),
    84.             nn.Sigmoid(),
    85.             nn.Linear(3,4),
    86.             nn.Sigmoid()
    87.         )
    88.         self.optimiser = torch.optim.SGD(self.parameters(), lr=0.01)
    89.         self.counter=0
    90.         self.progress=[]
    91.         pass
    92.     
    93.     def forward(self, inputs):
    94.             # 简单的运行模型
    95.             return self.model(inputs)
    96.         
    97.     def train(self,D,inputs,targets):
    98.         g_output=self.forward(inputs)
    99.         d_output = D.forward(g_output)
    100.         
    101.         loss=D.loss_function(d_output,targets)
    102.         
    103.         self.counter+=1
    104.         if(self.counter%10==0):
    105.             self.progress.append(loss.item())
    106.             pass
    107.         self.optimiser.zero_grad()
    108.         loss.backward()
    109.         self.optimiser.step()
    110.         pass
    111.     def plot_progress(self):
    112.         df = pd.DataFrame(self.progress, columns=['loss'])
    113.         fig = df.plot(ylim=(0, 1.0), figsize=(16, 8), alpha=0.1, marker='.', grid=True, yticks=(0, 0.25, 0.5))
    114.         fig.figure.savefig('../root/G_loss.png')
    115.         pass    
    116.     pass
    117.  
    118.  
    119. G=Generator()
    120. G.forward(torch.FloatTensor([0.5]))
    121.  
    122.  
    123. # create Discriminator and Generator
    124.  
    125. D = Discriminator()
    126. G = Generator()
    127.  
    128. image_list = []
    129.  
    130. # train Discriminator and Generator
    131.  
    132. for i in range(10000):
    133.     
    134.     # train discriminator on true
    135.     D.train(generate_real(), torch.FloatTensor([1.0]))
    136.     
    137.     # train discriminator on false
    138.     # use detach() so gradients in G are not calculated
    139.     D.train(G.forward(torch.FloatTensor([0.5])).detach(), torch.FloatTensor([0.0]))
    140.     D
    141.     # train generator
    142.     G.train(D, torch.FloatTensor([0.5]), torch.FloatTensor([1.0]))
    143.     
    144.     # add image to list every 1000
    145.     if (i % 1000 == 0):
    146.         image_list.append( G.forward(torch.FloatTensor([0.5])).detach().numpy() )
    147.     pass
    148.  
    149. #使用鉴别器查看损失值
    150. D.plot_progress()
    151. #试验训练后第一次生成的数据
    152. G.forward(torch.FloatTensor([0.5]))
    153. #查看生成器的损失值
    154. G.plot_progress()
    155.  
    156. plt.figure(figsize = (16,8))
    157. plt.imshow(numpy.array(image_list).T, interpolation='none', cmap='Blues')
    158. plt.savefig('../root/result.png')

    6、总结

    个人版实验报告：

    https://download.csdn.net/download/qq_51701007/87015804?spm=1001.2014.3001.5501

  • 相关阅读:
    基于哈尔小波基的一维密度估计（Python）
    二维码智慧门牌管理系统升级解决方案：查询功能大提升，让地址查找变得轻松便捷！
    单例模式——C++版本
    GPT4 Plugins 插件 WebPilot 生成抖音文案
    完美运营版商城/拼团/团购/秒杀/积分/砍价/实物商品/虚拟商品等全功能商城
    配置服务器实现无缝连接
    构造方法与方法调用指令分析 || JVM类加载与字节码技术
    优化SOCKS5的方法
    3.6 cache 存储器【计算机组成原理】
    国际知名商学院复旦大学EMBA荣登全球第8位，中文项目国内居首
  • 原文地址：https://blog.csdn.net/qq_51701007/article/details/127858897