跟着深度学习好书实践tensorflow神经网络

媒介

2024 年诺贝尔物理学奖授予了约翰·霍普菲尔德 （John Hopfield）和图灵奖得主、AI教父杰弗里·辛顿（Geoffrey  Hinton），"以表彰他们使用人工神经网络举行呆板学习的奠基性发现和发明"。

辛顿在担当电话采访时表现，我没有想到（I have no idea that will happen）。

被誉为“AI教父”的杰佛瑞·埃佛勒斯·辛顿（Geoffrey Everest Hinton，1947－），在70多岁时，成为图灵奖和诺贝尔物理学奖双料得主。
远在1986年，辛顿与David Rumelhart和Ronald Williams共同发表了一篇题为“通过反向传播毛病来学习”（Learning representations by back-propagating errors）的论文。
   [1]Home Page of Geoffrey Hinton，https://www.cs.toronto.edu/~hinton/
  [2]David E. Rumelhart, Geoffrey E. Hinton und Ronald J. Williams. Learning representations by back-propagating errors., Nature (London) 323, S. 533-536，http://www.cs.utoronto.ca/~hinton/absps/naturebp.pdf
  三位科学家，并不是第一个提出这种“反向传播”方法的人。但他们将反向传播算法应用于多层神经网络而且证实了这种方法对呆板学习行之有用。他们的论文也证实了，神经网络中的多个潜伏层可以学习任何函数，从而办理了闵斯基等书中提出的单层感知机存在的标题。

同一时期，辛顿与 David Ackley 和 Terry Sejnowski 共同发明确玻尔兹曼机。辛顿1986年有关反向传播算法和波尔兹曼机的两篇紧张文章，研究者们爱好盎然，他们依附自身的信心，扫除嘈杂的干扰而自得其乐，江湖貌似清静但暗流涌动，为人工智能春天之到来做好了准备。正是应了一句名言：“大隐隐于市”。

Hinton在1986年提出的通过反向传播来训练深度网络理论，标志着深度学习发展的一大转机，为比年来人工智能的发展奠基了根本。更现实点说，本日谷歌中通过语音辨认举行图片检索、在手机上把语音转化为笔墨的技能的实现，大部门功劳要归于Hinton博士的研究。他的研究，彻底改变了人工智能，以致整个人类发展的轨迹。

《深度学习的数学》是一本先容深度学习数学原理的册本。本书由日本作者涌井良幸和涌井贞美合著，由杨瑞龙翻译成中文。

作者: [日]涌井良幸 / [日]涌井贞美
出书社: 人民邮电出书社 2019
出品方: 图灵教导
原作名: ディープラーニングがわかる数学入門
译者: 杨瑞龙
出书年: 2019-4
页数: 236
定价: 69.00元
装帧: 平装
丛书: 图灵步伐计划丛书·步伐员的数学
ISBN/ISSN：978-7-115-50934-5
载体形态：225页 :图 ;21cm
中图分类号：TP181

内容简介

《深度学习的数学》基于丰富的图示和详细示例，平常易懂地先容了深度学习干系的数学知识。本书重要分为四个部门：线性代数、微积分、概率论和信息论。每一部门都详细先容了干系的数学知识，并连合深度学习的应用举行讲授。
在线性代数部门，本书讲授了向量、矩阵、线性变动等根本概念，以及它们在深度学习中的应用，如神经网络的表现和运算。
在微积分部门，本书讲授了导数、积分、链式法则等根本概念，以及它们在深度学习中的应用，如优化算法和反向传播算法。
在概率论部门，本书讲授了概率、随机变量、盼望等根本概念，以及它们在深度学习中的应用，如概率图模子和贝叶斯推断。
在信息论部门，本书讲授了信息熵、互信息、条件熵等根本概念，以及它们在深度学习中的应用，如信息论视角下的优化和学习。
第1章先容神经网络的概况；
第2章先容明确神经网络所需的数学根本知识；
第3章先容神经网络的最优化；
第4章先容神经网络和毛病反向传播法；
第5章先容深度学习和卷积神经网络。
书中使用Excel举行理论验证，资助读者直观地体验深度学习的原理。

作者和译者简介

涌井良幸
1950年生于东京，毕业于东京教导大学（现筑波大学）数学系，现为自由职业者。
著有《用Excel学深度学习》（合著）、《统计学有什么用？》等。
涌井贞美
1952年生于东京，完成东京大学理学系研究科硕士课程，现为自由职业者。
著有《用Excel学深度学习》（合著）、《图解贝叶斯统计入门》等。
译者简介：杨瑞龙
1982年生，2008年北京大学数学科学学院硕士毕业，软件开发者，从事软件行业10年。2013年～2016年赴日工作3年，从2016年开始在哆嗒数学网公众号发表《数学上下三万年》等多篇翻译作品。

目次

第1章　神经网络的头脑


1 - 1　神经网络和深度学习　　2
1 - 2　神经元工作的数学表现　　6
1 - 3　激活函数：将神经元的工作一样平常化　　12
1 - 4　什么是神经网络　　18
1 - 5　用恶魔来讲授神经网络的结构　　23
1 - 6　将恶魔的工作翻译为神经网络的语言　　31
1 - 7　网络自学习的神经网络　　36

第2章　神经网络的数学根本


2 - 1　神经网络所需的函数　　40
2 - 2　有助于明确神经网络的数列和递推关系式　　46
2 - 3　神经网络中经常用到的Σ符号　　51
2 - 4　有助于明确神经网络的向量根本　　53
2 - 5　有助于明确神经网络的矩阵根本　　61
2 - 6　神经网络的导数根本　　65
2 - 7　神经网络的偏导数根本　　72
2 - 8　毛病反向传播法必须的链式法则　　76
2 - 9　梯度降落法的根本：多变量函数的近似公式　　80
2 - 10　梯度降落法的寄义与公式　　83
2 - 11　用Excel 体验梯度降落法　　91
2 - 12　最优化标题和回归分析　　94

第3章　神经网络的最优化


3 - 1　神经网络的参数和变量　　102
3 - 2　神经网络的变量的关系式　　111
3 - 3　学习数据和正解　　114
3 - 4　神经网络的代价函数　　119
3 - 5　用Excel体验神经网络　　127

第4章　神经网络和毛病反向传播法


4 - 1　梯度降落法的回顾　　134
4 - 2　神经单元毛病　　141
4 - 3　神经网络和毛病反向传播法　　146
4 - 4　用Excel体验神经网络的毛病反向传播法　　153

第5章　深度学习和卷积神经网络


5 - 1　小恶魔来讲授卷积神经网络的结构　　168
5 - 2　将小恶魔的工作翻译为卷积神经网络的语言　　174
5 - 3　卷积神经网络的变量关系式　　180
5 - 4　用Excel体验卷积神经网络　　193
5 - 5　卷积神经网络和毛病反向传播法　　200
5 - 6　用Excel体验卷积神经网络的毛病反向传播法　　212

附录


A　训练数据（1）　　222
B　训练数据（2）　　223
C　用数学式表现模式的相似度　　225

小试牛刀

使用清华镜像开源获取anaconda安装软件
   https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2024.06-1-Windows-x86_64.exe
  安装乐成后，打开Prompt，设置环境

由于TensorFlow大概必要使用某些特定版本的库，而这些库与您的体系上的其他应用步伐大概存在辩说，使用假造环境可以隔离TensorFlow和其他应用步伐之间的库，从而克制辩说，以是先为TensorFlow创建一个假造环境。

在Anaconda Prompt终端中，运行以下下令以创建名为“py39tf210_env”的假造环境：
conda create --name py39tf210_env
激活假造环境
在创建假造环境之后，您必要激该死假造环境。在Anaconda Prompt终端中，运行以下下令：
conda activate py39tf210_env
查察当前已有环境，激活的环境
conda env list
安装TensorFlow，打开anaconda prompt，然后输入在内里输入以下下令：
   conda install pip
  更新
  python -m pip install --upgrade pip
  
   nvidia显卡驱动下载
https://www.nvidia.cn/content/DriverDownloads/confirmation.php?url=/Windows/460.89/460.89-desktop-win10-64bit-international-dch-whql.exe&lang=cn&type=GeForce
  

  
   cuda下载
https://developer.nvidia.com/cuda-toolkit
https://developer.nvidia.com/cuda-11.2.0-download-archive
  

   cudnn下载
https://developer.nvidia.com/rdp/cudnn-archive
  

下载的cudnn文件夹，将bin、include、lib归并到CUDA对应版本文件夹

TensorFlow 2.10.0官方要求CUDA 11.2和cuDNN 8.1
1. 安装CUDA 11.2工具包
2. 安装cuDNN 8.1（与CUDA 11.2兼容）
3. 更新体系环境变量
在文件夹NVIDIA GPU Computing Toolkit\CUDA\v11.2\extras\demo_suite CMD下令窗口，查抄CUDA安装是否乐成
实行bandwidthTest.exe

1. Microsoft Windows [版本 10.0.19045.5011]
2. (c) Microsoft Corporation。保留所有权利。
4. C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2\extras\demo_suite>bandwidthTest.exe
5. [CUDA Bandwidth Test] - Starting...
6. Running on...
8. Device 0: NVIDIA GeForce GTX 1660 Ti
9. Quick Mode
11. Host to Device Bandwidth, 1 Device(s)
12. PINNED Memory Transfers
13.    Transfer Size (Bytes)        Bandwidth(MB/s)
14.    33554432                     6315.2
16. Device to Host Bandwidth, 1 Device(s)
17. PINNED Memory Transfers
18.    Transfer Size (Bytes)        Bandwidth(MB/s)
19.    33554432                     6322.3
21. Device to Device Bandwidth, 1 Device(s)
22. PINNED Memory Transfers
23.    Transfer Size (Bytes)        Bandwidth(MB/s)
24.    33554432                     249160.5
26. Result = PASS
28. NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.

复制代码

实行deviceQuery.exe

1. Microsoft Windows [版本 10.0.19045.5011]
2. (c) Microsoft Corporation。保留所有权利。
4. C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2\extras\demo_suite>deviceQuery.exe
5. deviceQuery.exe Starting...
7. CUDA Device Query (Runtime API) version (CUDART static linking)
9. Detected 1 CUDA Capable device(s)
11. Device 0: "NVIDIA GeForce GTX 1660 Ti"
12.   CUDA Driver Version / Runtime Version          12.0 / 11.2
13.   CUDA Capability Major/Minor version number:    7.5
14.   Total amount of global memory:                 6144 MBytes (6442123264 bytes)
15.   (24) Multiprocessors, ( 64) CUDA Cores/MP:     1536 CUDA Cores
16.   GPU Max Clock rate:                            1590 MHz (1.59 GHz)
17.   Memory Clock rate:                             6001 Mhz
18.   Memory Bus Width:                              192-bit
19.   L2 Cache Size:                                 1572864 bytes
20.   Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
21.   Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
22.   Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
23.   Total amount of constant memory:               zu bytes
24.   Total amount of shared memory per block:       zu bytes
25.   Total number of registers available per block: 65536
26.   Warp size:                                     32
27.   Maximum number of threads per multiprocessor:  1024
28.   Maximum number of threads per block:           1024
29.   Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
30.   Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
31.   Maximum memory pitch:                          zu bytes
32.   Texture alignment:                             zu bytes
33.   Concurrent copy and kernel execution:          Yes with 2 copy engine(s)
34.   Run time limit on kernels:                     Yes
35.   Integrated GPU sharing Host Memory:            No
36.   Support host page-locked memory mapping:       Yes
37.   Alignment requirement for Surfaces:            Yes
38.   Device has ECC support:                        Disabled
39.   CUDA Device Driver Mode (TCC or WDDM):         WDDM (Windows Display Driver Model)
40.   Device supports Unified Addressing (UVA):      Yes
41.   Device supports Compute Preemption:            Yes
42.   Supports Cooperative Kernel Launch:            Yes
43.   Supports MultiDevice Co-op Kernel Launch:      No
44.   Device PCI Domain ID / Bus ID / location ID:   0 / 1 / 0
45.   Compute Mode:
46.      < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >
48. deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 12.0, CUDA Runtime Version = 11.2, NumDevs = 1, Device0 = NVIDIA GeForce GTX 1660 Ti
49. Result = PASS

复制代码

  NVIDIA的nvidia-smi（体系管理接口，监控GPU状态）提供GPU实时性能数据和管理功能
  NVIDIA的nvcc-V（CUDA编译器版本信息获取工具）重要用于查抄编译器兼容
  在CMD窗口使用指令nvidia-smi 查察

1. Microsoft Windows [版本 10.0.19045.5011]
2. (c) Microsoft Corporation。保留所有权利。
4. C:\Users\admin>nvidia-smi
5. Fri Oct 11 15:19:13 2024
6. +-----------------------------------------------------------------------------+
7. | NVIDIA-SMI 528.79       Driver Version: 528.79       CUDA Version: 12.0     |
8. |-------------------------------+----------------------+----------------------+
9. | GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |
10. | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
11. |                               |                      |               MIG M. |
12. |===============================+======================+======================|
13. |   0  NVIDIA GeForce ... WDDM  | 00000000:01:00.0 Off |                  N/A |
14. | N/A   59C    P0    24W /  80W |      0MiB /  6144MiB |      0%      Default |
15. |                               |                      |                  N/A |
16. +-------------------------------+----------------------+----------------------+
18. +-----------------------------------------------------------------------------+
19. | Processes:                                                                  |
20. |  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
21. |        ID   ID                                                   Usage      |
22. |=============================================================================|
23. |  No running processes found                                                 |
24. +-----------------------------------------------------------------------------+

复制代码

在CMD窗口使用指令nvcc -V 查察

1. Microsoft Windows [版本 10.0.19045.5011]
2. (c) Microsoft Corporation。保留所有权利。
4. C:\Users\admin>nvcc -V
5. nvcc: NVIDIA (R) Cuda compiler driver
6. Copyright (c) 2005-2020 NVIDIA Corporation
7. Built on Mon_Nov_30_19:15:10_Pacific_Standard_Time_2020
8. Cuda compilation tools, release 11.2, V11.2.67
9. Build cuda_11.2.r11.2/compiler.29373293_0

复制代码

  pip install -i https://pypi.tuna.tsinghua.edu.cn/simple tensorflow==2.10.0
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple tensorflow-gpu==2.10.1
  留意：本机 Windows 上的 GPU 支持仅实用于 2.10 或更早版本，从 TF 2.11 开始，Windows 不支持 CUDA 构建。要在 Windows 上使用 TensorFlow GPU，您必要在 WSL2 中构建/安装 TensorFlow 或将 tensorflow-cpu 与 TensorFlow-DirectML-Plugin 一起使用。
   CPU版本和GPU版本的区别重要在于运行速率，GPU版本运行速率更快，以是假如电脑显卡支持cuda，保举安装gpu版本的。CPU版本，无需额外准备，CPU版本一样平常电脑都可以安装，无需额外准备显卡的内容。GPU版本，必要提前下载 cuda 和 cuDNN。
  安装前 肯定 要查察本身电脑的环境设置，然后查询Tensorflow-gpu、Python、 cuda 、 cuDNN 版本关系，要 一 一对应。
  

tensorflow版本从2.x开始不再区分CPU版和GPU版，因此在软件设置正确的环境下，是可以找到GPU装备的。Tensorflow 2.10是末了一个在本地windows上支持GPU的版本。从2.11版本开始，必要在windows WLS2（实用于 Linux 的 Windows 子体系）上安装才气使用GPU。以是要在native-windows上使用GPU，就只能安装2.10.0版本及以下的版本，大概安装老版的tensorflow-gpu。
   tensorflow gpu cuda cudnn对应表格
https://tensorflow.google.cn/install/source_windows?hl=en#gpu
  
tensorflow：支持 CPU 和 GPU 的最新稳固版（实用于 Ubuntu 和 Windows）
tf-nightly：预览 build（不稳固）。Ubuntu 和 Windows 均包罗 GPU 支持。
旧版 TensorFlow
对于 TensorFlow 1.x，CPU 和 GPU 软件包是分开的：
  tensorflow==1.15：仅支持 CPU 的版本
tensorflow-gpu==1.15：支持 GPU 的版本（实用于 Ubuntu 和 Windows）
体系要求
Python 3.6–3.9
若要支持 Python 3.9，必要使用 TensorFlow 2.5 或更高版本。
若要支持 Python 3.8，必要使用 TensorFlow 2.2 或更高版本。
pip 19.0 或更高版本（必要 manylinux2010 支持）
Ubuntu 16.04 或更高版本（64 位）
macOS 10.12.6 (Sierra) 或更高版本（64 位）（不支持 GPU）
macOS 要求使用 pip 20.3 或更高版本
Windows 7 或更高版本（64 位）
实用于 Visual Studio 2015、2017 和 2019 的 Microsoft Visual C++ 可再发行软件包
GPU 支持必要使用支持 CUDA® 的卡（实用于 Ubuntu 和 Windows）
留意：必须使用最新版本的 pip，才气安装 TensorFlow 2。
硬件要求
从 TensorFlow 1.6 开始，二进制文件使用 AVX 指令，这些指令大概无法在旧版 CPU 上运行。
  安装numpy

1. pip install -i https://pypi.tuna.tsinghua.edu.cn/simple numpy==1.20.3

复制代码

安装pytorch

1. Commands for Versions >= 1.0.0
2. v2.4.0
3. Conda
4. OSX
5. # conda
6. conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 -c pytorch
7. Linux and Windows
8. # CUDA 11.8
9. conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0  pytorch-cuda=11.8 -c pytorch -c nvidia
10. # CUDA 12.1
11. conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 pytorch-cuda=12.1 -c pytorch -c nvidia
12. # CUDA 12.4
13. conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 pytorch-cuda=12.4 -c pytorch -c nvidia
14. # CPU Only
15. conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 cpuonly -c pytorch
17. (base) C:\Users\>conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 pytorch-cuda=12.4 -c pytorch -c nvidia
18. Collecting package metadata (current_repodata.json): done
19. Solving environment: failed with initial frozen solve. Retrying with flexible solve.
20. Collecting package metadata (repodata.json): done
21. Solving environment: -
22. The environment is inconsistent, please check the package plan carefully
23. The following packages are causing the inconsistency:
25.   - defaults/win-64::anaconda==2021.11=py39_0
26.   - defaults/win-64::astropy==4.3.1=py39hc7d831d_0
27.   - defaults/win-64::bkcharts==0.2=py39haa95532_0

复制代码

测试设置

1. import tensorflow as tf
2. from tensorflow.keras import layers, models
3. import torch
4. import os
6. #将TF_ENABLE_ONEDNN_OPTS设置成1或以上。0代表显示所有信息，1表示不显示info，2表示不显示warning，3表示不显示error。
7. os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
9. print('TensorFlow版本',tf.__version__)
10. # 查看torch当前版本号
11. print('torch当前版本号',torch.__version__)  
12. # 编译当前版本的torch使用的cuda版本号
13. print('torch使用的cuda版本号',torch.version.cuda)  
14. # 查看当前cuda是否有可用的Torch，如果输出True，则表示存在/成功安装
15. print('当前cuda是否有可用的Torch',torch.cuda.is_available())  
17. # 获取TensorFlow的构建信息
18. build = tf.sysconfig.get_build_info()
20. # 打印CUDA的版本号（如果已安装）
21. print(build['cuda_version'])
23. # 打印cuDNN的版本号（如果已安装）
24. print(build['cudnn_version'])
26. print('GPU:是否已经编译了CUDA支持', tf.test.is_built_with_cuda())
27. print('GPU:当前GPU设备名称', tf.test.gpu_device_name())
29. # 输出可用的GPU数量
30. print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
32. print("Num CPUs Available: ", len(tf.config.list_physical_devices('CPU')))
34. #默认情况下，TensorFlow 会映射进程可见的所有 GPU（取决于 CUDA_VISIBLE_DEVICES）的几乎全部内存。
35. #这是为了减少内存碎片，更有效地利用设备上相对宝贵的 GPU 内存资源
36. gpus = tf.config.list_physical_devices('GPU')
38. if gpus:
39.   # Restrict TensorFlow to only allocate 1GB of memory on the first GPU
40.   try:
41.     tf.config.set_logical_device_configuration(
42.         gpus[0],
43.         [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=1024*6)])
44.     logical_gpus = tf.config.list_logical_devices('GPU')
45.     print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
46.   except RuntimeError as e:
47.     # Virtual devices must be set before GPUs have been initialized
48.     print(e)
50. import timeit
52. #指定在cpu上运行
53. def cpu_run():
54.     with tf.device('/cpu:0'):
55.         cpu_a = tf.random.normal([10000, 1000])
56.         cpu_b = tf.random.normal([1000, 2000])
57.         c = tf.matmul(cpu_a, cpu_b)
58.     return c
60. #指定在gpu上运行
61. def gpu_run():
62.     with tf.device('/gpu:0'):
63.         gpu_a = tf.random.normal([10000, 1000])
64.         gpu_b = tf.random.normal([1000, 2000])
65.         c = tf.matmul(gpu_a, gpu_b)
66.     return c
68. cpu_time = timeit.timeit(cpu_run, number=10)
69. gpu_time = timeit.timeit(gpu_run, number=10)
70. print("cpu:", cpu_time, "  gpu:", gpu_time)

复制代码

主步伐

输出概率
Softmax
线性层
加法和归一化
前馈网络
残差毗连与层归一化
加权和归一化
多头留意力
编码器自留意力：标志相互看
查询、键、值由编码器的状态盘算得出
位置编码
输入嵌入
输入
前馈网络：在获取其他标志的信息后，花点时间思考和加工这些信息
编码器自留意力：目标标志查察源查询——来自解码器的状态；键和值来自编码器的状态
解码器自留意力（遮蔽）：标志查察前面的标志
查询、键、值由解码器的状态盘算得出
位置编码
输出嵌入
输出(右移)

    Torch和TensorFlow是两个盛行的深度学习框架，都可以用于构建和训练神经网络模子。它们都提供了强大的盘算图和自动求导功能，以及一系列工具和库来简化深度学习模子的开发和训练过程。Torch的盘算图是动态的，这意味着可以在运行时举行修改和调解。而TensorFlow的盘算图是静态的，必要在构建之后才气实行。这使得Torch更得当于动态的盘算流程和实行性的研究，而TensorFlow更得当于大规模的生产环境和优化盘算性能。Torch在早期得到了广泛的应用和支持，而TensorFlow则在谷歌的鼎力大举推动下徐徐成为了业界的主流深度学习框架之一。这也导致了它们在生态体系和社区支持方面的差异。

1. # -*- coding: utf-8 -*-
2. """
3. Spyder Editor
5. This is a temporary script file.
7. y=sin(x) 神经网络的设计与训练
8. """
10. import torch
11. from torch import nn
12. from matplotlib import pyplot as plt
13. import numpy as np
15. #神经网络类 network，继承nn.Module类
16. class Network(nn.Module):
17.     #类的初始化函数
18.     #init函数传入1个参数m,m代表了隐藏层神经元的数量
19.     def __init__(self,m):
20.         super().__init__()
21.         #layer1 是输入层与隐藏层之间的线性层，大小是1*m
22.         self.layer1 = nn.Linear(1,m)
23.         #layer2 是隐藏层与输出层之间的线性层，大小是m*1
24.         self.layer2 = nn.Linear(m,1)
25.         
26.     #前向传播计算函数，函数传入输入数据x
27.     def forward(self,x):
28.         x = self.layer1(x) #先进入layer1层，计算结果
29.         x = torch.sigmoid(x) #使用sigmoid激活函数
30.         return self.layer2(x) #返回layer2层的计算结果
31.         
32.    
33. # 在main函数中实现模型的测试代码
34. if __name__ == '__main__':
35.     '''
36.     model = Network(6) #创建模型，隐藏层个数传入6
37.     print(model) #打印model，可以看到模型的结果
38.     #接着使用循环，遍历模型中的参数
39.     for name,param in model.named_parameters():
40.         #打印参数名name和参数的尺寸param.data.shape
41.         print(f"{name}:{param.data.shape}")
42.     #定义一个100*1大小的张量
43.     #代表了100个输入数据，每个数据包括1个特征值，也就是sin(x)中的x
44.     x = torch.zeros([100,1])
45.     h = model(x) #将x输入至模型model,得到预测结果h,h即为sin(x)
46.     print(f"x:{x.shape}")
47.     print(f"h:{h.shape}")
48.     '''
49.    
50.     #神经网络模拟正弦函数，是一个回归任务
51.     #训练使用的数据，可以直接使用正弦函数进行构造
53.     #数据的生成代码
54.     #使用np.arrange 生成一个从0到1，步长为0.01
55.     # 含有100个数据点的数组，作为正弦函数的输入数据
56.     x = np.arange(0.0, 1.0, 0.01)
57.     # 将0到1的x，乘以2倍PI,从单位间隔转换为弧度值
58.     # 将x映射到正弦函数的一个完整周期上，并计算正弦值
59.     y = np.sin(2*np.pi*x)
60.     # 将x和y通过reshape函数转为100乘以1的数组
61.     # 也就是100个(x,y)坐标，代表100个训练数据
62.     x = x.reshape(100,1)
63.     y = y.reshape(100,1)
64.     #将(x,y)组成的数据点，画在画板上
65.     plt.scatter(x,y)
66.    
67.     x = torch.Tensor(x) # 训练前将数据x和y转化为tensor张量
68.     y = torch.Tensor(y)
69.    
70.     model = Network(3) # 定义神经网络
71.     # 隐藏层的神经元数量，可以尝试6 、 10 、 32 等数据，观察实验结果
72.    
73.     criterion = nn.MSELoss() # 创建均方误差损失函数
74.     # Adam优化器optimizer
75.     optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
76.     # 完成这些必要的变量声明后，就可以进入神经网络的循环迭代
77.    
78.     #神经网络训练代码
79.     # 使用批量梯度下降算法
80.     # 每次迭代，都会基于全部样本计算损失值，执行梯度下降
81.     # 循环的轮数定为1万，就可以使模型达到收敛
82.     for epoch in range(1000):
83.         # 在循环中，包括了5个步骤：
84.         h = model(x) #1.计算模型的预测值h
85.         loss=criterion(h,y) #2.计算预测h和标签y之间的损失loss
86.         loss.backward() #3.使用backward计算梯度
87.         optimizer.step() #4.使用optimizer.step更新参数
88.         optimizer.zero_grad() #5.将梯度清零
89.         
90.         #这5个步骤，是使用pytorch框架训练模型的定式
91.         
92.         #每迭代1000次，就打印一次模型的损失，用于观察训练的过程
93.         if epoch % 1000 == 0:
94.             #其中loss.item是损失的标量值
95.             print(f"After { epoch } iterations, the loss is {loss.item()}")
96.    
97.     h = model(x) # 完成训练后，使用模型预测输入x，得到预测结果h
98.     x = x.data.numpy()
99.     h = h.data.numpy()
100.     plt.scatter(x,h) # 将预测点(x,h)打印在屏幕
101.     plt.show()
102.    

复制代码

1. # -*- coding: utf-8 -*-
2. """
3. Created on Tue Oct 15 17:57:10 2024
5. """
7. import tensorflow as tf
8. print(tf.__file__)
9. #https://github.com/tensorflow/tensorflow
11. from tensorflow.examples.tutorials.mnist import input_data
12. mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
13. print ( ' 输入数据：', mnist.train.images)
14. print ( ' 输入数据打shape :', mnist.train.images.shape)
15. import pylab
16. im = mnist.train.images[1]
17. im = im.reshape(-1 ,28)
18. pylab.imshow(im)
19. pylab.show()

复制代码

1. # -*- coding: utf-8 -*-
2. """
3. Created on Tue Oct 15 17:51:23 2024
5. """
7. #coding: utf-8
8. import os
9. import tensorflow as tf
10. from tensorflow.examples.tutorials.mnist import input_data
11. from PIL import Image
13. '''
14. 函数功能：按照bmp格式提取mnist数据集中的图片
15. 参数介绍:
16.     mnist_dir   mnist数据集存储的路径
17.     save_dir    提取结果存储的目录
18. '''
19. def extract_mnist(mnist_dir, save_dir):
20.     rows = 28
21.     cols = 28
23.     # 加载mnist数据集
24.     # one_hot = True为默认打开"独热编码"
25.     mnist = input_data.read_data_sets(mnist_dir, one_hot=False)
26.     # 获取训练图片数量
27.     shape = mnist.train.images.shape
28.     images_train_count = shape[0]
29.     pixels_count_per_image = shape[1]
30.     # 获取训练标签数量=训练图片数量
31.     # 关闭"独热编码"后，labels的类型为[7 3 4 ... 5 6 8]
32.     labels = mnist.train.labels
33.     labels_train_count = labels.shape[0]
35.     if (images_train_count == labels_train_count):
36.         print("训练集共包含%d张图片，%d个标签" % (images_train_count, labels_train_count))
37.         print("每张图片包含%d个像素" % (pixels_count_per_image))
38.         print("数据类型为", mnist.train.images.dtype)
40.         # mnist图像数值的范围为[0,1], 需将其转换为[0,255]
41.         for current_image_id in range(images_train_count):
42.             for i in range(pixels_count_per_image):
43.                 if mnist.train.images[current_image_id][i] != 0:
44.                     mnist.train.images[current_image_id][i] = 255
46.             if ((current_image_id + 1) % 50) == 0:
47.                 print("已转换%d张，共需转换%d张" %
48.                       (current_image_id + 1, images_train_count))
50.         # 创建train images的保存目录, 按标签保存
51.         for i in range(10):
52.             dir = "%s/%s" % (save_dir, i)
53.             print(dir)
54.             if not os.path.exists(dir):
55.                 os.mkdir(dir)
57.         # indices = [0, 0, 0, ..., 0]用来记录每个标签对应的图片数量
58.         indices = [0 for x in range(0, 10)]
59.         for i in range(images_train_count):
60.             new_image = Image.new("L", (cols, rows))
61.             # 遍历new_image 进行赋值
62.             for r in range(rows):
63.                 for c in range(cols):
64.                     new_image.putpixel(
65.                         (r, c), int(mnist.train.images[i][c + r * cols]))
67.             # 获取第i张训练图片对应的标签
68.             label = labels[i]
69.             image_save_path = "%s/%s/%s.bmp" % (save_dir, label,
70.                                                 indices[label])
71.             indices[label] += 1
72.             new_image.save(image_save_path)
74.             # 打印保存进度
75.             if ((i + 1) % 50) == 0:
76.                 print("图片保存进度: 已保存%d张，共需保存%d张" % (i + 1, images_train_count))
77.     else:
78.         print("图片数量与标签数量不一致!")
80. if __name__ == '__main__':
81.     mnist_dir = "./mnist_Data"
82.     save_dir = "./mnist_Data_TrainImages"
83.     extract_mnist(mnist_dir, save_dir)
84.    
85.    

复制代码

1. # -*- coding: utf-8 -*-
2. """
3. Created on Tue Oct 15 15:30:10 2024
4. 设计、实现标准前馈神经网络
5. 输入层 隐藏层 输出层 sofrmax p0+p1+...+pn=1
6. 神经网络的设计和实现
7. 训练数据的准备和处理
8. 模型的训练和测试流程
10. MNIST是一个手写体数字的图片数据集，该数据集来由美国国家标准与技术研究所（National Institute of Standards and Technology (NIST)）发起整理，一共统计了来自250个不同的人手写数字图片，其中50%是高中生，50%来自人口普查局的工作人员。
11. 该数据集的收集目的是希望通过算法，实现对手写数字的识别。
12. 1998年，Yan LeCun 等人发表了论文《Gradient-Based Learning Applied to Document Recognition》，
13. 首次提出了LeNet-5 网络，利用上述数据集实现了手写字体的识别。
14. https://yann.lecun.com/exdb/mnist/
16. 在PyTorch中构建一个简单的卷积神经网络，并使用MNIST数据集训练它识别手写数字。 MNIST包含70,000张手写数字图像: 60,000张用于培训，10,000张用于测试。
17. 图像是灰度（即通道数为1），28x28像素，并且居中的，以减少预处理和加快运行。
18. PyTorch是一个非常流行的深度学习框架。但是与其他框架不同的是，PyTorch具有动态执行图，意味着计算图是动态创建的。
20. """
21. import torch
22. from torch import nn
23. from torchvision import transforms
24. from torchvision import datasets
25. from torch.utils.data import DataLoader
26. import torch.optim as optim
28. # 定义神经网络Network
29. class Network(nn.Module):
30.     def __init__(self):
31.         super().__init__()
32.         # 线性层1，输入层和隐藏层之间的线性层
33.         self.layer1 = nn.Linear(784,256)
34.         # 线性层2，隐藏层和输出层之间的线性层
35.         self.layer2 = nn.Linear(256,10)
36.         
37.     # 在前向传播，forward函数中，输入为图像x
38.     def forward(self,x):
39.         x = x.view(-1, 28*28) #使用 view函数，将x展平
40.         x = self.layer1(x) # 将x输入至layer1
41.         x = torch.relu(x) # 使用relu激活
42.         return self.layer2(x) # 输入至layer2计算结果
43.         # 这里我们没有直接定义softmax层
44.         # 这是因为后面会使用CrossRntropyLoss损失函数
45.         # 在这个损失函数中，会实现softmax的计算
47. #训练数据的准备和处理
48. #MNIST数据集，可以从torchvision.datasets中获取
49. #TFDS 存在于两个软件包中：
50. #pip install tensorflow-datasets：稳定版，数月发行一次。
51. #pip install tfds-nightly：每天发行，包含最近版本的数据集。
52. #https://tensorflow.google.cn/datasets/overview?hl=zh-cn
53. #https://tensorflow.google.cn/datasets/catalog/overview
54. #train_dataset = datasets.MNIST(root='./MNIST',train=True,transform=data_tf,download=True)
55. #train 60000个数据，用作训练
56. #tesst 10000个数据，用作测试
58. #一共4个文件，训练集、训练集标签、测试集、测试集标签
60. #文件名称        大小        内容
61. #train-labels-idx1-ubyte.gz        9,681 kb        55000张训练集，5000张验证集
62. #train-labels-idx1-ubyte.gz        29 kb        训练集图片对应的标签
63. #t10k-images-idx3-ubyte.gz        1,611 kb        10000张测试集
64. #t10k-labels-idx1-ubyte.gz        5 kb        测试集图片对应的标签
66. #如果直接下载该数据集的话，下载下来的是.gz格式的数据
67. #手动提取Mnist数据集中的图片，并把它按照常用的格式存储 在代码中用到了两个第三方的包，分别为tensorflow、PIL
68. #conda install tensorflow-gpu
69. #conda install Pillow
70. #https://github.com/tensorflow/tensorflow 压缩包解压,把里面的tensorflow下的examples文件夹直接复制过来
72. # 数据处理流程
73. if __name__ == '__main__':
74.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
75.     print(torch.cuda.device_count(),torch.cuda.get_device_name(0),torch.cuda.current_device())
76.     #optimizer加载参数时，tensor默认在CPU上，当你使用GPU训练时就会报以上错误。
77.     # 实现图像的预处理pipeline
78.     transform = transforms.Compose([
79.         transforms.Grayscale(num_output_channels=1), #转换为单通道灰度图
80.         transforms.ToTensor() # 转换为张量
81.     ])
82.     # 使用ImageFolder函数，读取数据文件夹，构建数据集dataset
83.     # 这个函数会将保存数据的文件夹的名字，作为数据的标签，组织数据
84.     # 例如：对于名字为“3”的文件夹
85.     # 会将“3”作为文件夹中图像数据的标签，和图像匹配，用于后续的训练，使用起来非常的方便
86.     train_dataset =  datasets.ImageFolder(root="./mint_image/train", transform=transform)
87.     #读取测试数据集
88.     test_dataset =  datasets.ImageFolder(root="./mint_image/test", transform=transform)
89.     # 打印他们的长度
90.     print("train_dataset length:", len(train_dataset))
91.     print("test_dataset length:", len(test_dataset))
92.    
93.     #使用train_loader，实现小批量的数据读取
94.     #这里设置小批量的大小，batch_size=64,也就是每个批次，包括64个数据
95.     train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
96.     #打印train_loader的长度
97.     print("train_loader length:", len(train_loader))
98.     #60000个训练数据，如果每个小批量，读入64个样本，那么60000个数据会被分割成938组数据
99.     #计算938*64=60032，这说明最后一个组，会不够64个数据
100.    
101.     # 循环遍历train_loader
102.     # 每一次循环，都会取出64个图像数据，作为一个小批量batch
103.     for batch_idx, (data, label) in enumerate(train_loader):
104.         if batch_idx == 2: #打印前2个batch观察
105.            break
106.         print("batch_idx:",batch_idx)
107.         print("data.shape:", data.shape) # 数据尺寸 torch.Size([64, 1, 28, 28]) 每组数据包括64个图像，每个图像有1个灰色通道，图像的尺寸是28*28
108.         print("label:", label.shape) #图像中的数字
109.         print(label)
110.    
111.     #模型的训练和测试
112.     #在使用pytorch训练模型时，需要创建三个对象
113.     model = Network() #1. 模型本身，它就是我们设计的神经网络
114.     #整个模型的参数、缓存、依赖的模块 放入device
115.     model.to(device)
116.     optimizer = optim.Adam(model.parameters()) #2. 优化器，优化模型中的参数
117.     criterion = nn.CrossEntropyLoss() #3. 损失函数，分类问题，使用交叉熵损失误差
118.    
119.     #进入模型的循环迭代
120.     for epoch in range(10): #外层循环，代表整个训练数据集的遍历次数
121.         #整个训练集要循环多少轮，是10次、20次或者100次都是可能的
122.         
123.         #内循环使用train_loader,进行小批量的数据读取
124.         for batch_idx, (inputs, target) in enumerate(train_loader):
125.             #内层每循环一次，就会进行一次梯度下降算法
126.             #包括5个步骤：
127.             #inputs, target = data
128.             inputs, target = inputs.to(device), target.to(device)
129.             # forward + backward + update
130.             outputs = model(inputs) #1.计算神经网络的前向传播结果
131.             loss = criterion(outputs, target) #2. 计算output和标签label之间的损失loss
132.             loss.backward() #3. 使用backward计算梯度
133.             optimizer.step() #4. 使用optimizer.step更新参数
134.             optimizer.zero_grad() #5.将梯度清零
135.             #这5个步骤，是使用pytorch框架训练模型的定式
136.             
137.             #每迭代100个小批量，就打印一次模型的损失，观察训练的过程
138.             if batch_idx % 100 == 0:
139.                 print(f"Epoch {epoch + 1}/10" f"|Batch {batch_idx}/{len(train_loader)}" f"|Loss: {loss.item():.4f}")
140.                
141.     torch.save(model.state_dict(), './mnist.pth') # 保存模型
142.    
143.     #对象模型进行测试  map_location=lambda storage, loc: storage.cuda(0) map_location=torch.device('cuda:0') , map_location=device
144.     #model.load_state_dict(torch.load('./mnist.pth', map_location=device )) #加载刚刚训练好的模型文件
145.    
146.     checkpoint = torch.load("./mnist.pth", map_location=device)  # Load all tensors onto the CPU
147.     model.load_state_dict(checkpoint)
148.     #optimizer.load_state_dict(checkpoint)
149.    
150.     #for k, v in optimizer.state.items():    # key is Parameter, val is a dict {key='momentum_buffer':tensor(...)}
151.     #    if 'momentum_buffer' not in v:
152.     #        continue
153.     #    optimizer.state[k]['momentum_buffer'] = optimizer.state[k]['momentum_buffer'].cuda()
155.     # 增加以下几行代码，将optimizer里的tensor数据全部转到GPU上
156.     #for state in optimizer.state.values():
157.     #    for k, v in state.items():
158.     #        if torch.is_tensor(v):
159.     #            state[k] = v.cuda()
161.     right = 0 # 保存正确识别的数量
162.     for i,(x,y) in enumerate(test_dataset):
163.         output = model(x) #将其中的数据x输入到模型
164.         predict = output.argmax(1).item() #选择概率最大的作为预测结果
165.         #对比预测值predict和真实标签y
166.         if predict == y:
167.             right += 1
168.         else:
169.             #将识别错误的样例打印出来
170.             img_path = test_dataset.samples[i][0]
171.             print(f"wrong case: predict = {predict} y= {y} img_path = {img_path}")
172.             
173.     #计算测试效果
174.     sample_num = len(test_dataset)
175.     acc = right*1.0/sample_num
176.     print("test accuracy = %d/%d = %.31f" % (right, sample_num, acc))
177.    
178.    

复制代码

1. train_dataset length: 55000
2. test_dataset length: 63
3. train_loader length: 860
4. batch_idx: 0
5. data.shape: torch.Size([64, 1, 28, 28])
6. label: torch.Size([64])
7. tensor([5, 7, 5, 5, 1, 3, 0, 3, 6, 6, 2, 5, 5, 2, 7, 0, 1, 3, 4, 4, 7, 9, 0, 6,
8.         6, 8, 3, 1, 6, 7, 7, 6, 6, 2, 0, 3, 0, 4, 7, 5, 1, 9, 1, 3, 2, 0, 1, 7,
9.         6, 5, 4, 6, 7, 4, 7, 6, 3, 2, 6, 2, 0, 0, 2, 4])
10. batch_idx: 1
11. data.shape: torch.Size([64, 1, 28, 28])
12. label: torch.Size([64])
13. tensor([3, 1, 5, 1, 1, 9, 3, 4, 2, 7, 5, 6, 6, 5, 1, 9, 5, 2, 8, 8, 7, 9, 4, 8,
14.         4, 1, 0, 7, 3, 9, 0, 2, 8, 4, 0, 7, 1, 9, 8, 7, 9, 3, 5, 1, 3, 9, 9, 4,
15.         7, 8, 4, 4, 5, 4, 0, 0, 5, 1, 4, 7, 1, 0, 4, 8])
16. batch_idx: 2
17. data.shape: torch.Size([64, 1,

复制代码