深度学习入门:自制框架
斋藤康毅
郑明智 译
出版时间:2023年03月
页数:480
“鱼书”《深度学习入门:基于Python的理论与实现》作者又一力作。
带你创建深度学习框架,直击现代深度学习框架本质!

本书有什么特点?
● 简明易懂,讲解详细
本书延续前作的行文风格,采用通俗的语言和大量直观的示意图详细讲解,帮助读者加深对PyTorch、TensorFlow和Chainer等现代深度学习框架的理解,进一步巩固Python编程和软件开发的相关知识。
● 通过“从零创建”,剖析深度学习框架机制
本书会从零创建一个深度学习框架,让读者在运行程序的过程中了解深度学习框架中蕴藏的技术与机制。通过这样的体验,读者可看清深度学习框架的本质。
● 增量开发
本书将繁杂的深度学习框架的创建工作分为60个步骤完成,内容循序渐进,读者可在一步步的实践过程中获得正向的反馈结果,激发学习动力。
  1. 前言
  2. 第1阶段 自动微分
  3. 步骤1 作为“箱子”的变量
  4. 1.1 什么是变量
  5. 1.2 实现Variable类
  6. 1.3 (补充)NumPy的多维数组
  7. 步骤2 创建变量的函数
  8. 2.1 什么是函数
  9. 2.2 Function类的实现
  10. 2.3 使用Function类
  11. 步骤3 函数的连续调用
  12. 3.1 Exp函数的实现
  13. 3.2 函数的连续调用
  14. 步骤4 数值微分
  15. 4.1 什么是导数
  16. 4.2 数值微分的实现
  17. 4.3 复合函数的导数
  18. 4.4 数值微分存在的问题
  19. 步骤5 反向传播的理论知识
  20. 5.1 链式法则
  21. 5.2 反向传播的推导
  22. 5.3 用计算图表示
  23. 步骤6 手动进行反向传播
  24. 6.1 Variable类的功能扩展
  25. 6.2 Function类的功能扩展
  26. 6.3 Square类和Exp类的功能扩展
  27. 6.4 反向传播的实现
  28. 步骤7 反向传播的自动化
  29. 7.1 为反向传播的自动化创造条件
  30. 7.2 尝试反向传播
  31. 7.3 增加backward方法
  32. 步骤8 从递归到循环
  33. 8.1 现在的Variable类
  34. 8.2 使用循环实现
  35. 8.3 代码验证
  36. 步骤9 让函数更易用
  37. 9.1 作为Python函数使用
  38. 9.2 简化backward方法
  39. 9.3 只支持ndarray
  40. 步骤10 测试
  41. 10.1 Python的单元测试
  42. 10.2 square函数反向传播的测试
  43. 10.3 通过梯度检验来自动测试
  44. 10.4 测试小结
  45. 第 2阶段 用自然的代码表达
  46. 步骤11 可变长参数(正向传播篇)
  47. 11.1 修改Function类
  48. 11.2 Add类的实现
  49. 步骤12 可变长参数(改进篇)
  50. 12.1 第 1 项改进:使函数更容易使用
  51. 12.2 第 2 项改进:使函数更容易实现
  52. 12.3 add函数的实现
  53. 步骤13 可变长参数(反向传播篇)
  54. 13.1 支持可变长参数的Add类的反向传播
  55. 13.2 修改Variable类
  56. 13.3 Square类的实现
  57. 步骤14 重复使用同一个变量
  58. 14.1 问题的原因
  59. 14.2 解决方案
  60. 14.3 重置导数
  61. 步骤15 复杂的计算图(理论篇)
  62. 15.1 反向传播的正确顺序
  63. 15.2 当前的DeZero
  64. 15.3 函数的优先级
  65. 步骤16 复杂的计算图(实现篇)
  66. 16.1 增加“辈分”变量
  67. 16.2 按照“辈分”顺序取出元素
  68. 16.3 Variable类的backward
  69. 16.4 代码验证
  70. 步骤17 内存管理和循环引用
  71. 17.1 内存管理
  72. 17.2 引用计数方式的内存管理
  73. 17.3 循环引用
  74. 17.4 weakref模块
  75. 17.5 代码验证
  76. 步骤18 减少内存使用量的模式
  77. 18.1 不保留不必要的导数
  78. 18.2 回顾Function类
  79. 18.3 使用Config类进行切换
  80. 18.4 模式的切换
  81. 18.5 使用with语句切换
  82. 步骤19 让变量更易用
  83. 19.1 命名变量
  84. 19.2 实例变量ndarray
  85. 19.3 len函数和print函数
  86. 步骤20 运算符重载(1)
  87. 20.1 Mul类的实现
  88. 20.2 运算符重载
  89. 步骤21 运算符重载(2)
  90. 21.1 与ndarray一起使用
  91. 21.2 与float和int一起使用
  92. 21.3 问题1:左项为float或int的情况
  93. 21.4 问题2:左项为ndarray实例的情况
  94. 步骤22 运算符重载(3)
  95. 22.1 负数
  96. 22.2 减法
  97. 22.3 除法
  98. 22.4 幂运算
  99. 步骤23 打包
  100. 23.1 文件结构
  101. 23.2 将代码移到核心类
  102. 23.3 运算符重载
  103. 23.4 实际的_ _init_ _.py 文件
  104. 23.5 导入dezero
  105. 步骤24 复杂函数的求导
  106. 24.1 Sphere函数
  107. 24.2 matyas函数
  108. 24.3 Goldstein Price函数
  109. 第3阶段 实现高阶导数
  110. 步骤25 计算图的可视化(1)
  111. 25.1 安装Graphviz
  112. 25.2 使用DOT语言描述图形
  113. 25.3 指定节点属性
  114. 25.4 连接节点
  115. 步骤26 计算图的可视化(2)
  116. 26.1 可视化代码的使用示例
  117. 26.2 从计算图转换为DOT语言
  118. 26.3 从DOT语言转换为图像
  119. 26.4 代码验证
  120. 步骤27 泰勒展开的导数
  121. 27.1 sin函数的实现
  122. 27.2 泰勒展开的理论知识
  123. 27.3 泰勒展开的实现
  124. 27.4 计算图的可视化
  125. 步骤28 函数优化
  126. 28.1 Rosenbrock函数
  127. 28.2 求导
  128. 28.3 梯度下降法的实现
  129. 步骤29 使用牛顿法进行优化(手动计算)
  130. 29.1 使用牛顿法进行优化的理论知识
  131. 29.2 使用牛顿法实现优化
  132. 步骤30 高阶导数(准备篇)
  133. 30.1 确认工作①:Variable实例变量
  134. 30.2 确认工作②:Function类
  135. 30.3 确认工作③:Variable类的反向传播
  136. 步骤31 高阶导数(理论篇)
  137. 31.1 在反向传播时进行的计算
  138. 31.2 创建反向传播的计算图的方法
  139. 步骤32 高阶导数(实现篇)
  140. 32.1 新的DeZero
  141. 32.2 函数类的反向传播
  142. 32.3 实现更有效的反向传播(增加模式控制代码)
  143. 32.4 修改_ _init_ _.py
  144. 步骤33 使用牛顿法进行优化(自动计算)
  145. 33.1 求二阶导数
  146. 33.2 使用牛顿法进行优化
  147. 步骤34 sin函数的高阶导数
  148. 34.1 sin函数的实现
  149. 34.2 cos函数的实现
  150. 34.3 sin函数的高阶导数
  151. 步骤35 高阶导数的计算图
  152. 35.1 tanh函数的导数
  153. 35.2 tanh函数的实现
  154. 35.3 高阶导数的计算图可视化
  155. 步骤36 DeZero的其他用途
  156. 36.1 double backprop的用途
  157. 36.2 深度学习研究中的应用示例
  158. 第4阶段 创建神经网络
  159. 步骤37 处理张量
  160. 37.1 对各元素进行计算
  161. 37.2 使用张量时的反向传播
  162. 37.3 使用张量时的反向传播(补充内容)
  163. 步骤38 改变形状的函数
  164. 38.1 reshape函数的实现
  165. 38.2 从Variable对象调用reshape
  166. 38.3 矩阵的转置
  167. 38.4 实际的transpose函数(补充内容)
  168. 步骤39 求和的函数
  169. 39.1 sum函数的反向传播
  170. 39.2 sum函数的实现
  171. 39.3 axis和keepdims
  172. 步骤40 进行广播的函数 272
  173. 40.1 broadcast_to函数和sum_to函数
  174. 40.2 DeZero的broadcast_to函数和sum_to函数
  175. 40.3 支持广播
  176. 步骤41 矩阵的乘积
  177. 41.1 向量的内积和矩阵的乘积
  178. 41.2 检查矩阵的形状
  179. 41.3 矩阵乘积的反向传播
  180. 步骤42 线性回归
  181. 42.1 玩具数据集
  182. 42.2 线性回归的理论知识
  183. 42.3 线性回归的实现
  184. 42.4 DeZero的mean_squared_error函数(补充内容)
  185. 步骤43 神经网络
  186. 43.1 DeZero中的linear函数
  187. 43.2 非线性数据集
  188. 43.3 激活函数和神经网络
  189. 43.4 神经网络的实现
  190. 步骤44 汇总参数的层
  191. 44.1 Parameter类的实现
  192. 44.2 Layer类的实现
  193. 44.3 Linear类的实现
  194. 44.4 使用Layer实现神经网络
  195. 步骤45 汇总层的层
  196. 45.1 扩展Layer类
  197. 45.2 Model类
  198. 45.3 使用Model来解决问题
  199. 45.4 MLP类
  200. 步骤46 通过Optimizer更新参数
  201. 46.1 Optimizer类
  202. 46.2 SGD类的实现
  203. 46.3 使用SGD类来解决问题
  204. 46.4 SGD以外的优化方法
  205. 步骤47 softmax函数和交叉熵误差
  206. 47.1 用于切片操作的函数
  207. 47.2 softmax函数
  208. 47.3 交叉熵误差
  209. 步骤48 多分类
  210. 48.1 螺旋数据集
  211. 48.2 用于训练的代码
  212. 步骤49 Dataset类和预处理
  213. 49.1 Dataset类的实现
  214. 49.2 大型数据集的情况
  215. 49.3 数据的连接
  216. 49.4 用于训练的代码
  217. 49.5 数据集的预处理
  218. 步骤50 用于取出小批量数据的DataLoader
  219. 50.1 什么是迭代器
  220. 50.2 使用DataLoader
  221. 50.3 accuracy函数的实现
  222. 50.4 螺旋数据集的训练代码
  223. 步骤51 MINST的训练
  224. 51.1 MNIST数据集
  225. 51.2 训练MNIST
  226. 51.3 改进模型
  227. 第5阶段 DeZero高级挑战
  228. 步骤52 支持GPU
  229. 52.1 CuPy的安装和使用方法
  230. 52.2 cuda模块
  231. 52.3 向Variable/Layer/DataLoader类添加代码
  232. 52.4 函数的相应修改
  233. 52.5 在GPU上训练MNIST
  234. 步骤53 模型的保存和加载
  235. 53.1 NumPy的save函数和load函数
  236. 53.2 Layer类参数的扁平化
  237. 53.3 Layer类的save函数和load函数
  238. 步骤54 Dropout和测试模式
  239. 54.1 什么是Dropout
  240. 54.2 Inverted Dropout
  241. 54.3 增加测试模式
  242. 54.4 Dropout的实现
  243. 步骤55 CNN的机制(1)
  244. 55.1 CNN的网络结构
  245. 55.2 卷积运算
  246. 55.3 填充
  247. 55.4 步幅
  248. 55.5 输出大小的计算方法
  249. 步骤56 CNN的机制(2)
  250. 56.1 三阶张量
  251. 56.2 结合方块进行思考
  252. 56.3 小批量处理
  253. 56.4 池化层
  254. 步骤57 conv2d函数和pooling函数
  255. 57.1 使用im2col展开
  256. 57.2 conv2d函数的实现
  257. 57.3 Conv2d层的实现
  258. 57.4 pooling 函数的实现
  259. 步骤58 具有代表性的CNN(VGG16)
  260. 58.1 VGG16的实现
  261. 58.2 已训练的权重数据
  262. 58.3 使用已训练的VGG16
  263. 步骤59 使用RNN处理时间序列数据
  264. 59.1 RNN层的实现
  265. 59.2 RNN模型的实现
  266. 59.3 切断连接的方法
  267. 59.4 正弦波的预测
  268. 步骤60 LSTM与数据加载器
  269. 60.1 用于时间序列数据的数据加载器
  270. 60.2 LSTM层的实现
  271. 附录A in place运算(步骤14的补充内容)
  272. A.1 问题确认
  273. A.2 关于复制和覆盖
  274. A.3 DeZero的反向传播
  275. 附录B 实现get_item函数(步骤47的补充内容)
  276. 附录C 在Google Colaboratory上运行
  277. 后记
  278. 参考文献
书名:深度学习入门:自制框架
作者:斋藤康毅
译者:郑明智 译
国内出版社:人民邮电出版社
出版时间:2023年03月
页数:480
书号:978-7-115-60751-5
原版书书名:Building Deep Learning Framework
原版书出版商:O'Reilly Media
斋藤康毅
 
1984年生于日本长崎县,东京工业大学毕业,并完成东京大学研究生院课程。目前在某企业从事人工智能相关的研究和开发工作。著有《深度学习入门:基于Python的理论与实现》,同时也是Introducing Python、Python in Practice、The Elements of Computing Systems、Building Machine Learning Systems with Python的日文版译者。
 
 
购买选项
定价:129.80元
书号:978-7-115-60751-5
出版社:人民邮电出版社