├── README.md ├── chapter ├── 1-1_intro.tex ├── 1-2_why_use_keras.tex ├── 10_callbacks.tex ├── 11_datasets.tex ├── 12_applications.tex ├── 13_backend.tex ├── 14_initializers.tex ├── 15_regularizers.tex ├── 16_constraints.tex ├── 17_visualization.tex ├── 18_scikit-learn-api.tex ├── 19_utils.tex ├── 2-1_sequential-model-guide.tex ├── 2-2_functional-api-guide.tex ├── 2-3_faq.tex ├── 20_contributing.tex ├── 3-1_about-keras-models.tex ├── 3-2_Sequential.tex ├── 3-3_model.tex ├── 4-10_normalization.tex ├── 4-11_noise.tex ├── 4-12_wrappers.tex ├── 4-13_writing-your-own-keras-layers.tex ├── 4-1_about-keras-layers.tex ├── 4-2_core.tex ├── 4-3_convolutional.tex ├── 4-4_pooling.tex ├── 4-5_locally-connected.tex ├── 4-6_recurrent.tex ├── 4-7_embedding.tex ├── 4-8_merge.tex ├── 4-9_advanced-activations.tex ├── 5-1_preprocessing-sequence.tex ├── 5-2_preprocessing-text.tex ├── 5-3_preprocessing-image.tex ├── 6_losses.tex ├── 7_metrics.tex ├── 8_optimizers.tex └── 9_activations.tex ├── figure ├── collect_qrcode.png ├── framework_rank.png └── qrcode_for_BreakIntoAI.jpg ├── keras-docs-zh.pdf ├── keras-docs-zh.sty ├── keras-docs-zh.tex ├── logo └── keras-logo.png └── preface ├── preface.tex └── support.tex /README.md: -------------------------------------------------------------------------------- 1 | # Keras 深度学习库 PDF 版 2 | Keras Deep Learning Library PDF version 3 | 4 | ## Keras: 基于 Python 的深度学习库 PDF版本 5 | 6 | - 网页版请访问 [Keras官方中文文档](https://keras.io/zh/) 7 | - Markdown版请访问 [keras-docs-zh](https://github.com/keras-team/keras-docs-zh) 8 | 9 | 整理 Keras: 基于 Python 的深度学习库（PDF 版） 的主要原因在于学习 Keras 深度学习库时方便本地查阅。 10 | 11 | 感谢 [keras-team](https://github.com/keras-team/keras-docs-zh) 所做的中文翻译工作，本文档制作基于此处。 12 | 13 | The main reason of organizing PDF version based the Chinese Keras Markdown is that it is easy to read locally when learning the Keras Deep Learning Library. 14 | 15 | Thanks for the Chinese translation work done by [keras-team](https://github.com/keras-team/keras-docs-zh), this document is produced based on it. 16 | 17 | 18 | ## 排版规范 Typesetting 19 | 20 | 此文档遵循 [中文排版指南](https://github.com/sparanoid/chinese-copywriting-guidelines) 规范，并在此之上遵守以下约定： 21 | 22 | * 英文的左右保持一个空白，避免中英文字黏在一起； 23 | * 使用全角标点符号； 24 | * 严格遵循 Markdown 语法； 25 | * 原文中的双引号（" "）请代换成中文的引号（「」符号怎么打出来见 [这里](http://zhihu.com/question/19755746/answer/27233392)）； 26 | * 「`加亮`」和「**加粗**」和「[链接]()」都需要在左右保持一个空格。 27 | 28 | ## 翻译对照列表 Conventions 29 | 30 | - 该翻译用于 `zh-cn` （简体中文，中国大陆地区）。 31 | - 当遇到以下 `专业术语` 的时候，请使用以下列表进行对照翻译。（未完待续） 32 | 33 | 34 | | English | 中文 | 35 | |:-------------------|:--------------------| 36 | | arguments         | 参数                | 37 | | boolean           | 布尔                | 38 | | data augumentation | 数据增强            | 39 | | deep learning     | 深度学习            | 40 | | float             | 浮点数               | 41 | | Functional API     | 函数式 API     | 42 | | Fuzz factor       | 模糊因子             | 43 | | input shape       | 输入尺寸             | 44 | | index             | 索引                 | 45 | | int               | 整数                 | 46 | | layer             | 层                  | 47 | | loss function     | 损失函数             | 48 | | metrics | 评估标准 | 49 | | nD tensor         | nD 张量             | 50 | | Numpy Array | Numpy 矩阵 | 51 | | objective | 目标 | 52 | | optimizer | 优化器 | 53 | | output shape | 输出尺寸 | 54 | | regularizer       | 正则化器             | 55 | | return | 返回 | 56 | | recurrent | 循环 | 57 | | Sequential Model | 顺序模型 | 58 | | shape | 尺寸 | 59 | | target | 目标 | 60 | | testing | 测试 | 61 | | training | 训练 | 62 | | wrapper           | 封装器               | 63 | 64 | 65 | 66 | ### 严正声明 67 | 68 | 本文档可免费用于学习和科学研究，可自由传播，但切勿擅自用于商业用途，由此引发一切后果贡献者概不负责。 69 | 70 | Statement: This document can be freely used for learning and scientific research and is freely disseminated, but it must not be used for commercial purposes. Otherwise, the the contributor is not responsible for the consequences. 71 | 72 | Welcome to contribute!!! 73 | -------------------------------------------------------------------------------- /chapter/1-1_intro.tex: -------------------------------------------------------------------------------- 1 | \section{Keras: 基于 Python的深度学习库}\label{keras-ux57faux4e8e-python-ux7684ux6df1ux5ea6ux5b66ux4e60ux5e93} 2 | 3 | \subsection{你恰好发现了Keras}\label{ux4f60ux6070ux597dux53d1ux73b0ux4e86-keras} 4 | 5 | Keras 是一个用 Python 编写的高级神经网络 API，它能够以 6 | \href{https://github.com/tensorflow/tensorflow}{TensorFlow}, 7 | \href{https://github.com/Microsoft/cntk}{CNTK}, 或者 8 | \href{https://github.com/Theano/Theano}{Theano} 作为后端运行。Keras 9 | 的开发重点是支持快速的实验。\emph{能够以最小的时延把你的想法转换为实验结果，是做好研究的关键。} 10 | 11 | 如果你在以下情况下需要深度学习库，请使用 Keras： 12 | 13 | \begin{itemize} 14 | \tightlist 15 | \item 16 | 允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。 17 | \item 18 | 同时支持卷积神经网络和循环神经网络，以及两者的组合。 19 | \item 20 | 在 CPU 和 GPU 上无缝运行。 21 | \end{itemize} 22 | 23 | 查看文档，请访问 \href{https://keras.io/zh/}{Keras.io}。 24 | 25 | Keras 兼容的 Python 版本: \textbf{Python 2.7-3.6}。 26 | 27 | 28 | \subsection{指导原则}\label{ux6307ux5bfcux539fux5219} 29 | 30 | \begin{itemize} 31 | \item 32 | \textbf{用户友好。} Keras 是为人类而不是为机器设计的 33 | API。它把用户体验放在首要和中心位置。Keras 34 | 遵循减少认知困难的最佳实践：它提供一致且简单的 35 | API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。 36 | \item 37 | \textbf{模块化。} 38 | 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。 39 | \item 40 | \textbf{易扩展性。} 41 | 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 42 | 更加适合高级研究。 43 | \item 44 | \textbf{基于 Python 实现。} Keras 45 | 没有特定格式的单独配置文件。模型定义在 Python 46 | 代码中，这些代码紧凑，易于调试，并且易于扩展。 47 | \end{itemize} 48 | 49 | 50 | 51 | \subsection{快速开始：30 秒上手 52 | Keras}\label{ux5febux901fux5f00ux59cb30-ux79d2ux4e0aux624b-keras} 53 | 54 | Keras 的核心数据结构是 55 | \textbf{model}，一种组织网络层的方式。最简单的模型是 56 | \hyperref[sequential-model-guide]{\texttt{Sequential}} 57 | 顺序模型，它是由多个网络层线性堆叠的栈。对于更复杂的结构，你应该使用 58 | \hyperref[functional-api-guide]{Keras函数式 API}，它允许构建任意的神经网络图。 59 | 60 | \texttt{Sequential} 顺序模型如下所示： 61 | 62 | \begin{Shaded} 63 | \begin{Highlighting}[] 64 | \ImportTok{from} \NormalTok{keras.models }\ImportTok{import} \NormalTok{Sequential} 65 | 66 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 67 | \end{Highlighting} 68 | \end{Shaded} 69 | 70 | 可以简单地使用 \texttt{.add()} 来堆叠模型： 71 | 72 | \begin{Shaded} 73 | \begin{Highlighting}[] 74 | \ImportTok{from} \NormalTok{keras.layers }\ImportTok{import} \NormalTok{Dense} 75 | 76 | \NormalTok{model.add(Dense(units}\OperatorTok{=}\DecValTok{64}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{, input_dim}\OperatorTok{=}\DecValTok{100}\NormalTok{))} 77 | \NormalTok{model.add(Dense(units}\OperatorTok{=}\DecValTok{10}\NormalTok{, activation}\OperatorTok{=}\StringTok{'softmax'}\NormalTok{))} 78 | \end{Highlighting} 79 | \end{Shaded} 80 | 81 | 在完成了模型的构建后, 可以使用 \texttt{.compile()} 来配置学习过程： 82 | 83 | \begin{Shaded} 84 | \begin{Highlighting}[] 85 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'categorical_crossentropy'}\NormalTok{,} 86 | \NormalTok{optimizer}\OperatorTok{=}\StringTok{'sgd'}\NormalTok{,} 87 | \NormalTok{metrics}\OperatorTok{=}\NormalTok{[}\StringTok{'accuracy'}\NormalTok{])} 88 | \end{Highlighting} 89 | \end{Shaded} 90 | 91 | 如果需要，你还可以进一步地配置你的优化器。Keras 92 | 的核心原则是使事情变得相当简单，同时又允许用户在需要的时候能够进行完全的控制（终极的控制是源代码的易扩展性）。 93 | 94 | \begin{Shaded} 95 | \begin{Highlighting}[] 96 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\NormalTok{keras.losses.categorical_crossentropy,} 97 | \NormalTok{optimizer}\OperatorTok{=}\NormalTok{keras.optimizers.SGD(lr}\OperatorTok{=}\FloatTok{0.01}\NormalTok{, momentum}\OperatorTok{=}\FloatTok{0.9}\NormalTok{, nesterov}\OperatorTok{=}\VariableTok{True}\NormalTok{))} 98 | \end{Highlighting} 99 | \end{Shaded} 100 | 101 | 现在，你可以批量地在训练数据上进行迭代了： 102 | 103 | \begin{Shaded} 104 | \begin{Highlighting}[] 105 | \CommentTok{# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。} 106 | \NormalTok{model.fit(x_train, y_train, epochs}\OperatorTok{=}\DecValTok{5}\NormalTok{, batch_size}\OperatorTok{=}\DecValTok{32}\NormalTok{)} 107 | \end{Highlighting} 108 | \end{Shaded} 109 | 110 | 或者，你可以手动地将批次的数据提供给模型： 111 | 112 | \begin{Shaded} 113 | \begin{Highlighting}[] 114 | \NormalTok{model.train_on_batch(x_batch, y_batch)} 115 | \end{Highlighting} 116 | \end{Shaded} 117 | 118 | 只需一行代码就能评估模型性能： 119 | 120 | \begin{Shaded} 121 | \begin{Highlighting}[] 122 | \NormalTok{loss_and_metrics }\OperatorTok{=} \NormalTok{model.evaluate(x_test, y_test, batch_size}\OperatorTok{=}\DecValTok{128}\NormalTok{)} 123 | \end{Highlighting} 124 | \end{Shaded} 125 | 126 | 或者对新的数据生成预测： 127 | 128 | \begin{Shaded} 129 | \begin{Highlighting}[] 130 | \NormalTok{classes }\OperatorTok{=} \NormalTok{model.predict(x_test, batch_size}\OperatorTok{=}\DecValTok{128}\NormalTok{)} 131 | \end{Highlighting} 132 | \end{Shaded} 133 | 134 | 构建一个问答系统，一个图像分类模型，一个神经图灵机，或者其他的任何模型，就是这么的快。深度学习背后的思想很简单，那么它们的实现又何必要那么痛苦呢？ 135 | 136 | 有关 Keras 更深入的教程，请查看： 137 | 138 | 139 | 140 | \begin{itemize} 141 | \tightlist 142 | \item 143 | \hyperref[sequential-model-guide]{\texttt{开始使用 Sequential 顺序模型}} 144 | \item 145 | \hyperref[functional-api-guide]{开始使用函数式 API} 146 | \end{itemize} 147 | 148 | 在代码仓库的 149 | \href{https://github.com/keras-team/keras/tree/master/examples}{examples 150 | 目录}中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 151 | 的文本生成等等。 152 | 153 | 154 | 155 | \subsection{安装指引}\label{ux5b89ux88c5ux6307ux5f15} 156 | 157 | 在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 158 | CNTK。我们推荐 TensorFlow 后端。 159 | 160 | \begin{itemize} 161 | \tightlist 162 | \item 163 | \href{https://www.tensorflow.org/install/}{TensorFlow 安装指引}。 164 | \item 165 | \href{http://deeplearning.net/software/theano/install.html\#install}{Theano 166 | 安装指引}。 167 | \item 168 | \href{https://docs.microsoft.com/en-us/cognitive-toolkit/setup-cntk-on-your-machine}{CNTK 169 | 安装指引}。 170 | \end{itemize} 171 | 172 | 你也可以考虑安装以下\textbf{可选依赖}： 173 | 174 | \begin{itemize} 175 | \tightlist 176 | \item 177 | cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。 178 | \item 179 | HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。 180 | \item 181 | graphviz 和 pydot 182 | (用于\hyperref[visualization]{可视化工具}绘制模型图)。 183 | \end{itemize} 184 | 185 | 然后你就可以安装 Keras 本身了。有两种方法安装 Keras： 186 | 187 | \begin{itemize} 188 | \tightlist 189 | \item 190 | \textbf{使用 PyPI 安装 Keras (推荐)：} 191 | \end{itemize} 192 | 193 | \begin{verbatim} 194 | sudo pip install keras 195 | \end{verbatim} 196 | 197 | 如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo： 198 | 199 | \begin{verbatim} 200 | pip install keras 201 | \end{verbatim} 202 | 203 | \begin{itemize} 204 | \tightlist 205 | \item 206 | \textbf{或者：使用 Github 源码安装 Keras：} 207 | \end{itemize} 208 | 209 | 首先，使用 \texttt{git} 来克隆 Keras： 210 | 211 | \begin{verbatim} 212 | git clone https://github.com/keras-team/keras.git 213 | \end{verbatim} 214 | 215 | 然后，\texttt{cd} 到 Keras 目录并且运行安装命令： 216 | 217 | \begin{verbatim} 218 | cd keras 219 | sudo python setup.py install 220 | \end{verbatim} 221 | 222 | 223 | 224 | \subsection{使用 TensorFlow 225 | 以外的后端} 226 | 227 | 默认情况下，Keras 将使用 TensorFlow 228 | 作为其张量操作库。请\hyperref[keras-backend]{跟随这些指引}来配置其他 229 | Keras 后端。 230 | 231 | 232 | 233 | \subsection{技术支持} 234 | 235 | 你可以提出问题并参与开发讨论： 236 | 237 | \begin{itemize} 238 | \tightlist 239 | \item 240 | \href{https://groups.google.com/forum/\#!forum/keras-users}{Keras 241 | Google group}。 242 | \item 243 | \href{https://kerasteam.slack.com}{Keras Slack channel}。 使用 244 | \href{https://keras-slack-autojoin.herokuapp.com/}{这个链接} 245 | 向该频道请求邀请函。 246 | \end{itemize} 247 | 248 | 你也可以在 \href{https://github.com/keras-team/keras/issues}{Github 249 | issues} 中张贴\textbf{漏洞报告和新功能请求}（仅限于此）。注意请先阅读\hyperref[contributing]{规范文档}。 250 | 251 | 252 | 253 | \subsection{为什么取名为 254 | Keras?}\label{ux4e3aux4ec0ux4e48ux53d6ux540dux4e3a-keras} 255 | 256 | Keras (\setmainfont{Linux Libertine O} κέρας) 在希腊语中意为 \emph{号角} 257 | 。它来自古希腊和拉丁文学中的一个文学形象，首先出现于 \emph{《奥德赛》} 258 | 中， 梦神 (\emph{Oneiroi}, singular \emph{Oneiros}) 259 | 从这两类人中分离出来：那些用虚幻的景象欺骗人类，通过象牙之门抵达地球之人，以及那些宣告未来即将到来，通过号角之门抵达之人。 260 | 它类似于文字寓意，{\setmainfont{Linux Libertine O}κέρας }(号角) / \setmainfont{Linux Libertine O}κραίνω (履行)，以及 \setmainfont{Linux Libertine O}ἐλέφας (象牙) / 261 | \setmainfont{Linux Libertine O}ἐλεφαίρομαι (欺骗)。 262 | 263 | Keras 最初是作为 ONEIROS 264 | 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。 265 | 266 | \begin{quote} 267 | \emph{``Oneiroi 超出了我们的理解 - 268 | 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 269 | Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 270 | Oneiroi 是诡计多端的，他们带有一些不会实现的信息； 271 | 那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。"} 272 | Homer, Odyssey 19. 562 ff (Shewring translation). 273 | \end{quote} 274 | 275 | \newpage -------------------------------------------------------------------------------- /chapter/1-2_why_use_keras.tex: -------------------------------------------------------------------------------- 1 | \section{为什么选择 Keras？} 2 | 在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras与现有替代品的一些比较。 3 | 4 | 5 | \subsection{Keras优先考虑开发人员的经验} 6 | 7 | \begin{itemize} 8 | \item 9 | Keras 是为人类而非机器设计的 10 | API。\href{https://blog.keras.io/user-experience-design-for-apis.html}{Keras 11 | 遵循减少认知困难的最佳实践}: 它提供一致且简单的 12 | API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。 13 | \item 14 | 这使 Keras 易于学习和使用。作为 Keras 15 | 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而\href{https://www.quora.com/Why-has-Keras-been-so-successful-lately-at-Kaggle-competitions}{帮助你赢得机器学习竞赛}。 16 | \item 17 | 这种易用性并不以降低灵活性为代价：因为 Keras 18 | 与底层深度学习语言（特别是 19 | TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，\texttt{tf.keras} 20 | 作为 Keras API 可以与 TensorFlow 工作流无缝集成。 21 | \end{itemize} 22 | 23 | 24 | \subsection{Keras被工业界和学术界广泛采用} 25 | 26 | \begin{figure}[h] 27 | \begin{center} 28 | \includegraphics[width=\textwidth]{figure/framework_rank.png} 29 | \end{center} 30 | \caption{Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出} 31 | \end{figure} 32 | 33 | 截至 2018 年中期，Keras 拥有超过 250,000 名个人用户。与其他任何深度学习框架相比，Keras 在行业和研究领域的应用率更高（除 TensorFlow 之外，且 Keras API 是 TensorFlow 的官方前端，通过 \texttt{tf.keras} 模块使用）。 34 | 35 | 您已经不断与使用 Keras 构建的功能进行交互 - 它在 Netflix, Uber, Yelp, 36 | Instacart, Zocdoc, Square 37 | 等众多网站上使用。它尤其受以深度学习作为产品核心的创业公司的欢迎。 38 | 39 | Keras也是深度学习研究人员的最爱，在上载到预印本服务器 40 | \href{https://arxiv.org/archive/cs}{arXiv.org} 41 | 的科学论文中被提及的次数位居第二。Keras 42 | 还被大型科学组织的研究人员采用，特别是 CERN 和 NASA。 43 | 44 | 45 | 46 | 47 | \subsection{Keras 可以轻松将模型转化为产品} 48 | 49 | 与任何其他深度学习框架相比，你的 Keras 模型可以轻松部署在更广泛的平台上： 50 | 51 | \begin{itemize} 52 | \tightlist 53 | \item 54 | 在 iOS 上，通过 55 | \href{https://developer.apple.com/documentation/coreml}{Apple's 56 | CoreML}（苹果为 Keras 提供官方支持）。这里有一个\href{https://www.pyimagesearch.com/2018/04/23/running-keras-models-on-ios-with-coreml/}{教程}。 57 | \item 58 | 在安卓 上，通过 TensorFlow Android 59 | runtime，例如：\href{https://medium.com/@timanglade/how-hbos-silicon-valley-built-not-hotdog-with-mobile-tensorflow-keras-react-native-ef03260747f3}{Not 60 | Hotdog app}。 61 | \item 62 | 在浏览器上，通过 GPU 加速的 JavaScript 63 | 运行时，例如：\href{https://transcranial.github.io/keras-js/\#/}{Keras.js} 64 | 和 \href{https://mil-tokyo.github.io/webdnn/}{WebDNN}。 65 | \item 66 | 在 Google Cloud 上，通过 67 | \href{https://www.tensorflow.org/serving/}{TensorFlow-Serving}。 68 | \item 69 | \href{https://blog.keras.io/building-a-simple-keras-deep-learning-rest-api.html}{在 Python 网页应用后端（比如 Flask app）中}。 70 | \item 71 | 在 JVM，通过 72 | \href{https://deeplearning4j.org/model-import-keras}{SkyMind 提供的 73 | DL4J 模型导入}。 74 | \item 75 | 在 Raspberry Pi 树莓派上。 76 | \end{itemize} 77 | 78 | 79 | \subsection{Keras 80 | 支持多个后端引擎，并且不会将你锁定到一个生态系统中}\label{keras-ux652fux6301ux591aux4e2aux540eux7aefux5f15ux64ceux5e76ux4e14ux4e0dux4f1aux5c06ux4f60ux9501ux5b9aux5230ux4e00ux4e2aux751fux6001ux7cfbux7edfux4e2d} 81 | 82 | 你的 Keras 83 | 模型可以基于不同的\hyperref[keras-backend]{深度学习后端}开发。重要的是，任何仅利用内置层构建的 84 | Keras 85 | 模型，都可以在所有这些后端中移植：用一种后端训练模型，再将它载入另一种后端中（比如为了发布）。支持的后端有： 86 | 87 | \begin{itemize} 88 | \tightlist 89 | \item 90 | 谷歌的 TensorFlow 后端 91 | \item 92 | 微软的 CNTK 后端 93 | \item 94 | Theano 后端 95 | \end{itemize} 96 | 97 | 亚马逊也正在为 Keras 开发 MXNet 后端。 98 | 99 | 如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练： 100 | 101 | \begin{itemize} 102 | \tightlist 103 | \item 104 | \href{https://developer.nvidia.com/deep-learning}{NVIDIA GPU}。 105 | \item 106 | \href{https://cloud.google.com/tpu/}{Google TPU}，通过 TensorFlow 107 | 后端和 Google Cloud。 108 | \item 109 | OpenGL 支持的 GPU, 比如 AMD, 通过 110 | \href{https://github.com/plaidml/plaidml}{PlaidML Keras 后端}。 111 | \end{itemize} 112 | 113 | 114 | \subsection{Keras 拥有强大的多 GPU 115 | 和分布式训练支持} 116 | 117 | \begin{itemize} 118 | \tightlist 119 | \item 120 | Keras \hyperref[multi-gpu-model]{内置对多 GPU 121 | 数据并行的支持}。 122 | \item 123 | 优步的 \href{https://github.com/uber/horovod}{Horovod} 对 Keras 124 | 模型有第一流的支持。 125 | \item 126 | Keras 127 | 模型\href{https://www.tensorflow.org/versions/master/api_docs/python/tf/keras/estimator/model_to_estimator}{可以被转换为 128 | TensorFlow 估计器}并在 129 | \href{https://cloud.google.com/solutions/running-distributed-tensorflow-on-compute-engine}{Google 130 | Cloud 的 GPU 集群}上训练。 131 | \item 132 | Keras 可以在 Spark（通过 CERN 的 133 | \href{https://github.com/cerndb/dist-keras}{Dist-Keras}）和~\href{https://github.com/maxpumperla/elephas}{Elephas} 134 | 上运行。 135 | \end{itemize} 136 | 137 | 138 | \subsection{Keras 139 | 的发展得到深度学习生态系统中的关键公司的支持}\label{keras-ux7684ux53d1ux5c55ux5f97ux5230ux6df1ux5ea6ux5b66ux4e60ux751fux6001ux7cfbux7edfux4e2dux7684ux5173ux952eux516cux53f8ux7684ux652fux6301} 140 | 141 | Keras 的开发主要由谷歌支持，Keras API 以 \texttt{tf.keras} 的形式包装在 142 | TensorFlow 中。此外，微软维护着 Keras 的 CNTK 后端。亚马逊 AWS 正在开发 143 | MXNet 支持。其他提供支持的公司包括 NVIDIA、优步、苹果（通过 CoreML）等。 144 | 145 | \newpage 146 | -------------------------------------------------------------------------------- /chapter/11_datasets.tex: -------------------------------------------------------------------------------- 1 | 2 | \section{常用数据集 Datasets}\label{datasets} 3 | 4 | \subsection{CIFAR10 5 | 小图像分类数据集}\label{cifar10-ux5c0fux56feux50cfux5206ux7c7bux6570ux636eux96c6} 6 | 7 | 50,000 张 32x32 彩色训练图像数据，以及 10,000 张测试图像数据，总共分为 8 | 10 个类别。 9 | 10 | \textbf{用法：}\label{ux7528ux6cd5} 11 | 12 | \begin{Shaded} 13 | \begin{Highlighting}[] 14 | \ImportTok{from} \NormalTok{keras.datasets }\ImportTok{import} \NormalTok{cifar10} 15 | 16 | \NormalTok{(x_train, y_train), (x_test, y_test) }\OperatorTok{=} \NormalTok{cifar10.load_data()} 17 | \end{Highlighting} 18 | \end{Shaded} 19 | 20 | \begin{itemize} 21 | \tightlist 22 | \item 23 | \textbf{返回：} 24 | \item 25 | 2 个元组： 26 | 27 | \begin{itemize} 28 | \tightlist 29 | \item 30 | \textbf{x\_train, x\_test}: uint8 数组表示的 RGB 图像数据，尺寸为 31 | (num\_samples, 3, 32, 32)。 32 | \item 33 | \textbf{y\_train, y\_test}: uint8 数组表示的类别标签（范围在 0-9 34 | 之间的整数），尺寸为 (num\_samples,)。 35 | \end{itemize} 36 | \end{itemize} 37 | 38 | 39 | \subsection{CIFAR100 40 | 小图像分类数据集}\label{cifar100-ux5c0fux56feux50cfux5206ux7c7bux6570ux636eux96c6} 41 | 42 | 50,000 张 32x32 彩色训练图像数据，以及 10,000 张测试图像数据，总共分为 43 | 100 个类别。 44 | 45 | \textbf{用法：}\label{ux7528ux6cd5-1} 46 | 47 | \begin{Shaded} 48 | \begin{Highlighting}[] 49 | \ImportTok{from} \NormalTok{keras.datasets }\ImportTok{import} \NormalTok{cifar100} 50 | 51 | \NormalTok{(x_train, y_train), (x_test, y_test) }\OperatorTok{=} \NormalTok{cifar100.load_data(label_mode}\OperatorTok{=}\StringTok{'fine'}\NormalTok{)} 52 | \end{Highlighting} 53 | \end{Shaded} 54 | 55 | \begin{itemize} 56 | \tightlist 57 | \item 58 | \textbf{返回：} 59 | \item 60 | 2 个元组： 61 | 62 | \begin{itemize} 63 | \tightlist 64 | \item 65 | \textbf{x\_train, x\_test}: uint8 数组表示的 RGB 图像数据，尺寸为 66 | (num\_samples, 3, 32, 32)。 67 | \item 68 | \textbf{y\_train, y\_test}: uint8 数组表示的类别标签（范围在 0-9 69 | 之间的整数），尺寸为 (num\_samples,)。 70 | \end{itemize} 71 | \item 72 | \textbf{参数：} 73 | \item 74 | \textbf{label\_mode}: "fine" 或者 "coarse" 75 | \end{itemize} 76 | 77 | 78 | \subsection{IMDB 79 | 电影评论情感分类数据集}\label{imdb-ux7535ux5f71ux8bc4ux8bbaux60c5ux611fux5206ux7c7bux6570ux636eux96c6} 80 | 81 | 数据集来自 IMDB 的 25,000 82 | 条电影评论，以情绪（正面/负面）标记。每一条评论已经过预处理，并编码为词索引（整数）的\hyperref[preprocessing-sequence]{序列}表示。为了方便起见，将词按数据集中出现的频率进行索引，例如整数 83 | 3 编码数据中第三个最频繁的词。这允许快速筛选操作，例如：「只考虑前 84 | 10,000 个最常用的词，但排除前 20 个最常见的词」。 85 | 86 | 作为惯例，0 不代表特定的单词，而是被用于编码任何未知单词。 87 | 88 | \textbf{用法}\label{ux7528ux6cd5-2} 89 | 90 | \begin{Shaded} 91 | \begin{Highlighting}[] 92 | \ImportTok{from} \NormalTok{keras.datasets }\ImportTok{import} \NormalTok{imdb} 93 | 94 | \NormalTok{(x_train, y_train), (x_test, y_test) }\OperatorTok{=} \NormalTok{imdb.load_data(path}\OperatorTok{=}\StringTok{"imdb.npz"}\NormalTok{,} 95 | \NormalTok{num_words}\OperatorTok{=}\VariableTok{None}\NormalTok{,} 96 | \NormalTok{skip_top}\OperatorTok{=}\DecValTok{0}\NormalTok{,} 97 | \NormalTok{maxlen}\OperatorTok{=}\VariableTok{None}\NormalTok{,} 98 | \NormalTok{seed}\OperatorTok{=}\DecValTok{113}\NormalTok{,} 99 | \NormalTok{start_char}\OperatorTok{=}\DecValTok{1}\NormalTok{,} 100 | \NormalTok{oov_char}\OperatorTok{=}\DecValTok{2}\NormalTok{,} 101 | \NormalTok{index_from}\OperatorTok{=}\DecValTok{3}\NormalTok{)} 102 | \end{Highlighting} 103 | \end{Shaded} 104 | 105 | \begin{itemize} 106 | \tightlist 107 | \item 108 | \textbf{返回：} 109 | \item 110 | 2 个元组： 111 | 112 | \begin{itemize} 113 | \tightlist 114 | \item 115 | \textbf{x\_train, x\_test}: 序列的列表，即词索引的列表。如果指定了 116 | \texttt{num\_words} 参数，则可能的最大索引值是 117 | \texttt{num\_words-1}。如果指定了 \texttt{maxlen} 118 | 参数，则可能的最大序列长度为 \texttt{maxlen}。 119 | \item 120 | \textbf{y\_train, y\_test}: 整数标签列表 (1 或 0)。 121 | \end{itemize} 122 | \item 123 | \textbf{参数:} 124 | \item 125 | \textbf{path}: 如果你本地没有该数据集 (在 126 | \texttt{\textquotesingle{}\textasciitilde{}/.keras/datasets/\textquotesingle{}\ +\ path})，它将被下载到此目录。 127 | \item 128 | \textbf{num\_words}: 整数或 129 | None。要考虑的最常用的词语。任何不太频繁的词将在序列数据中显示为 130 | \texttt{oov\_char} 值。 131 | \item 132 | \textbf{skip\_top}: 133 | 整数。要忽略的最常见的单词（它们将在序列数据中显示为 134 | \texttt{oov\_char} 值）。 135 | \item 136 | \textbf{maxlen}: 整数。最大序列长度。 任何更长的序列都将被截断。 137 | \item 138 | \textbf{seed}: 整数。用于可重现数据混洗的种子。 139 | \item 140 | \textbf{start\_char}: 整数。序列的开始将用这个字符标记。设置为 1，因为 141 | 0 通常作为填充字符。 142 | \item 143 | \textbf{oov\_char}: 整数。由于 \texttt{num\_words} 或 144 | \texttt{skip\_top} 限制而被删除的单词将被替换为此字符。 145 | \item 146 | \textbf{index\_from}: 147 | 整数。使用此数以上更高的索引值实际词汇索引的开始。 148 | \end{itemize} 149 | 150 | 151 | \subsection{路透社新闻主题分类}\label{ux8defux900fux793eux65b0ux95fbux4e3bux9898ux5206ux7c7b} 152 | 153 | 数据集来源于路透社的 11,228 条新闻文本，总共分为 46 个主题。与 IMDB 154 | 数据集一样，每条新闻都被编码为一个词索引的序列（相同的约定）。 155 | 156 | \textbf{用法：}\label{ux7528ux6cd5-3} 157 | 158 | \begin{Shaded} 159 | \begin{Highlighting}[] 160 | \ImportTok{from} \NormalTok{keras.datasets }\ImportTok{import} \NormalTok{reuters} 161 | 162 | \NormalTok{(x_train, y_train), (x_test, y_test) }\OperatorTok{=} \NormalTok{reuters.load_data(path}\OperatorTok{=}\StringTok{"reuters.npz"}\NormalTok{,} 163 | \NormalTok{num_words}\OperatorTok{=}\VariableTok{None}\NormalTok{,} 164 | \NormalTok{skip_top}\OperatorTok{=}\DecValTok{0}\NormalTok{,} 165 | \NormalTok{maxlen}\OperatorTok{=}\VariableTok{None}\NormalTok{,} 166 | \NormalTok{test_split}\OperatorTok{=}\FloatTok{0.2}\NormalTok{,} 167 | \NormalTok{seed}\OperatorTok{=}\DecValTok{113}\NormalTok{,} 168 | \NormalTok{start_char}\OperatorTok{=}\DecValTok{1}\NormalTok{,} 169 | \NormalTok{oov_char}\OperatorTok{=}\DecValTok{2}\NormalTok{,} 170 | \NormalTok{index_from}\OperatorTok{=}\DecValTok{3}\NormalTok{)} 171 | \end{Highlighting} 172 | \end{Shaded} 173 | 174 | 规格与 IMDB 数据集的规格相同，但增加了： 175 | 176 | \begin{itemize} 177 | \tightlist 178 | \item 179 | \textbf{test\_split}: 浮点型。用作测试集的数据比例。 180 | \end{itemize} 181 | 182 | 该数据集还提供了用于编码序列的词索引： 183 | 184 | \begin{Shaded} 185 | \begin{Highlighting}[] 186 | \NormalTok{word_index }\OperatorTok{=} \NormalTok{reuters.get_word_index(path}\OperatorTok{=}\StringTok{"reuters_word_index.json"}\NormalTok{)} 187 | \end{Highlighting} 188 | \end{Shaded} 189 | 190 | \begin{itemize} 191 | \item 192 | \textbf{返回：} 一个字典，其中键是单词（字符串），值是索引（整数）。 193 | 例如，\texttt{word\_index{[}"giraffe"{]}} 可能会返回 \texttt{1234}。 194 | \item 195 | \textbf{参数：} 196 | \item 197 | \textbf{path}: 如果在本地没有索引文件 (at 198 | \texttt{\textquotesingle{}\textasciitilde{}/.keras/datasets/\textquotesingle{}\ +\ path}), 199 | 它将被下载到该目录。 200 | \end{itemize} 201 | 202 | 203 | \subsection{MNIST 204 | 手写字符数据集}\label{mnist-ux624bux5199ux5b57ux7b26ux6570ux636eux96c6} 205 | 206 | 训练集为 60,000 张 28x28 像素灰度图像，测试集为 10,000 同规格图像，总共 207 | 10 类数字标签。 208 | 209 | \textbf{用法：}\label{ux7528ux6cd5-4} 210 | 211 | \begin{Shaded} 212 | \begin{Highlighting}[] 213 | \ImportTok{from} \NormalTok{keras.datasets }\ImportTok{import} \NormalTok{mnist} 214 | 215 | \NormalTok{(x_train, y_train), (x_test, y_test) }\OperatorTok{=} \NormalTok{mnist.load_data()} 216 | \end{Highlighting} 217 | \end{Shaded} 218 | 219 | \begin{itemize} 220 | \tightlist 221 | \item 222 | \textbf{返回：} 223 | \item 224 | 2 个元组： 225 | 226 | \begin{itemize} 227 | \tightlist 228 | \item 229 | \textbf{x\_train, x\_test}: uint8 数组表示的灰度图像，尺寸为 230 | (num\_samples, 28, 28)。 231 | \item 232 | \textbf{y\_train, y\_test}: uint8 数组表示的数字标签（范围在 0-9 233 | 之间的整数），尺寸为 (num\_samples,)。 234 | \end{itemize} 235 | \item 236 | \textbf{参数：} 237 | \item 238 | \textbf{path}: 如果在本地没有索引文件 (at 239 | \texttt{\textquotesingle{}\textasciitilde{}/.keras/datasets/\textquotesingle{}\ +\ path}), 240 | 它将被下载到该目录。 241 | \end{itemize} 242 | 243 | 244 | \subsection{Fashion-MNIST 245 | 时尚物品数据集}\label{fashion-mnist-ux65f6ux5c1aux7269ux54c1ux6570ux636eux96c6} 246 | 247 | 训练集为 60,000 张 28x28 像素灰度图像，测试集为 10,000 同规格图像，总共 248 | 10 类时尚物品标签。该数据集可以用作 MNIST 的直接替代品。类别标签是： 249 | 250 | \begin{longtable}[c]{@{}lll@{}} 251 | \toprule 252 | 类别 & 描述 & 中文\tabularnewline 253 | \midrule 254 | \endhead 255 | 0 & T-shirt/top & T恤/上衣\tabularnewline 256 | 1 & Trouser & 裤子\tabularnewline 257 | 2 & Pullover & 套头衫\tabularnewline 258 | 3 & Dress & 连衣裙\tabularnewline 259 | 4 & Coat & 外套\tabularnewline 260 | 5 & Sandal & 凉鞋\tabularnewline 261 | 6 & Shirt & 衬衫\tabularnewline 262 | 7 & Sneaker & 运动鞋\tabularnewline 263 | 8 & Bag & 背包\tabularnewline 264 | 9 & Ankle boot & 短靴\tabularnewline 265 | \bottomrule 266 | \end{longtable} 267 | 268 | \textbf{用法：}\label{ux7528ux6cd5-5} 269 | 270 | \begin{Shaded} 271 | \begin{Highlighting}[] 272 | \ImportTok{from} \NormalTok{keras.datasets }\ImportTok{import} \NormalTok{fashion_mnist} 273 | 274 | \NormalTok{(x_train, y_train), (x_test, y_test) }\OperatorTok{=} \NormalTok{fashion_mnist.load_data()} 275 | \end{Highlighting} 276 | \end{Shaded} 277 | 278 | \begin{itemize} 279 | \tightlist 280 | \item 281 | \textbf{返回：} 282 | \item 283 | 2 个元组： 284 | 285 | \begin{itemize} 286 | \tightlist 287 | \item 288 | \textbf{x\_train, x\_test}: uint8 数组表示的灰度图像，尺寸为 289 | (num\_samples, 28, 28)。 290 | \item 291 | \textbf{y\_train, y\_test}: uint8 数组表示的数字标签（范围在 0-9 292 | 之间的整数），尺寸为 (num\_samples,)。 293 | \end{itemize} 294 | \end{itemize} 295 | 296 | 297 | \subsection{Boston 298 | 房价回归数据集}\label{boston-ux623fux4ef7ux56deux5f52ux6570ux636eux96c6} 299 | 300 | 数据集来自卡内基梅隆大学维护的 StatLib 库。 301 | 302 | 样本包含 1970 年代的在波士顿郊区不同位置的房屋信息，总共有 13 303 | 种房屋属性。 目标值是一个位置的房屋的中值（单位：k\$）。 304 | 305 | \textbf{用法：}\label{ux7528ux6cd5-6} 306 | 307 | \begin{Shaded} 308 | \begin{Highlighting}[] 309 | \ImportTok{from} \NormalTok{keras.datasets }\ImportTok{import} \NormalTok{boston_housing} 310 | 311 | \NormalTok{(x_train, y_train), (x_test, y_test) }\OperatorTok{=} \NormalTok{boston_housing.load_data()} 312 | \end{Highlighting} 313 | \end{Shaded} 314 | 315 | \begin{itemize} 316 | \item 317 | \textbf{参数：} 318 | \item 319 | \textbf{path}: 缓存本地数据集的位置 (相对路径 320 | \textasciitilde{}/.keras/datasets)。 321 | \item 322 | \textbf{seed}: 在计算测试分割之前对数据进行混洗的随机种子。 323 | \item 324 | \textbf{test\_split}: 需要保留作为测试数据的比例。 325 | \item 326 | \textbf{返回：} Numpy 数组的元组: 327 | \texttt{(x\_train,\ y\_train),\ (x\_test,\ y\_test)}。 328 | \end{itemize} 329 | 330 | \newpage 331 | -------------------------------------------------------------------------------- /chapter/14_initializers.tex: -------------------------------------------------------------------------------- 1 | \section{初始化 Initializers} 2 | \subsection{初始化器的用法}\label{initializers} 3 | 4 | 初始化定义了设置 Keras 各层权重随机初始值的方法。 5 | 6 | 用来将初始化器传入 Keras 层的参数名取决于具体的层。通常关键字为 7 | \texttt{kernel\_initializer} 和 \texttt{bias\_initializer}: 8 | 9 | \begin{Shaded} 10 | \begin{Highlighting}[] 11 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{,} 12 | \NormalTok{kernel_initializer}\OperatorTok{=}\StringTok{'random_uniform'}\NormalTok{,} 13 | \NormalTok{bias_initializer}\OperatorTok{=}\StringTok{'zeros'}\NormalTok{))} 14 | \end{Highlighting} 15 | \end{Shaded} 16 | 17 | \subsection{可用的初始化器}\label{ux53efux7528ux7684ux521dux59cbux5316ux5668} 18 | 19 | 下面这些是可用的内置初始化器，是 \texttt{keras.initializers} 20 | 模块的一部分: 21 | 22 | 23 | \subsubsection{Initializer {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L14}{{[}source{]}}}} 24 | 25 | \begin{Shaded} 26 | \begin{Highlighting}[] 27 | \NormalTok{keras.initializers.Initializer()} 28 | \end{Highlighting} 29 | \end{Shaded} 30 | 31 | 初始化器基类：所有初始化器继承这个类。 32 | 33 | 34 | 35 | 36 | \subsubsection{Zeros {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L33}{{[}source{]}}}} 37 | 38 | \begin{Shaded} 39 | \begin{Highlighting}[] 40 | \NormalTok{keras.initializers.Zeros()} 41 | \end{Highlighting} 42 | \end{Shaded} 43 | 44 | 将张量初始值设为 0 的初始化器。 45 | 46 | 47 | 48 | 49 | \subsubsection{Ones {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L41}{{[}source{]}}}} 50 | 51 | \begin{Shaded} 52 | \begin{Highlighting}[] 53 | \NormalTok{keras.initializers.Ones()} 54 | \end{Highlighting} 55 | \end{Shaded} 56 | 57 | 将张量初始值设为1的初始化器。 58 | 59 | 60 | 61 | 62 | \subsubsection{Constant {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L49}{{[}source{]}}}} 63 | 64 | \begin{Shaded} 65 | \begin{Highlighting}[] 66 | \NormalTok{keras.initializers.Constant(value}\OperatorTok{=}\DecValTok{0}\NormalTok{)} 67 | \end{Highlighting} 68 | \end{Shaded} 69 | 70 | 将张量初始值设为一个常数的初始化器。 71 | 72 | \textbf{参数} 73 | 74 | \begin{itemize} 75 | \tightlist 76 | \item 77 | \textbf{value}: 浮点数，生成的张量的值。 78 | \end{itemize} 79 | 80 | 81 | 82 | 83 | \subsubsection{RandomNormal {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L66}{{[}source{]}}}} 84 | 85 | \begin{Shaded} 86 | \begin{Highlighting}[] 87 | \NormalTok{keras.initializers.RandomNormal(mean}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, stddev}\OperatorTok{=}\FloatTok{0.05}\NormalTok{, seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 88 | \end{Highlighting} 89 | \end{Shaded} 90 | 91 | 按照正态分布生成随机张量的初始化器。 92 | 93 | \textbf{参数} 94 | 95 | \begin{itemize} 96 | \tightlist 97 | \item 98 | \textbf{mean}: 一个 Python 99 | 标量或者一个标量张量。要生成的随机值的平均数。 100 | \item 101 | \textbf{stddev}: 一个 Python 102 | 标量或者一个标量张量。要生成的随机值的标准差。 103 | \item 104 | \textbf{seed}: 一个 Python 整数。用于设置随机数种子。 105 | \end{itemize} 106 | 107 | 108 | 109 | 110 | \subsubsection{RandomUniform {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L94}{{[}source{]}}}} 111 | 112 | \begin{Shaded} 113 | \begin{Highlighting}[] 114 | \NormalTok{keras.initializers.RandomUniform(minval}\OperatorTok{=-}\FloatTok{0.05}\NormalTok{, maxval}\OperatorTok{=}\FloatTok{0.05}\NormalTok{, seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 115 | \end{Highlighting} 116 | \end{Shaded} 117 | 118 | 按照均匀分布生成随机张量的初始化器。 119 | 120 | \textbf{参数} 121 | 122 | \begin{itemize} 123 | \tightlist 124 | \item 125 | \textbf{minval}: 一个 Python 126 | 标量或者一个标量张量。要生成的随机值的范围下限。 127 | \item 128 | \textbf{maxval}: 一个 Python 129 | 标量或者一个标量张量。要生成的随机值的范围下限。默认为浮点类型的 1。 130 | \item 131 | \textbf{seed}: 一个 Python 整数。用于设置随机数种子。 132 | \end{itemize} 133 | 134 | 135 | 136 | 137 | \subsubsection{TruncatedNormal {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L122}{{[}source{]}}}} 138 | 139 | \begin{Shaded} 140 | \begin{Highlighting}[] 141 | \NormalTok{keras.initializers.TruncatedNormal(mean}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, stddev}\OperatorTok{=}\FloatTok{0.05}\NormalTok{, seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 142 | \end{Highlighting} 143 | \end{Shaded} 144 | 145 | 按照截尾正态分布生成随机张量的初始化器。 146 | 147 | 生成的随机值与 \texttt{RandomNormal} 148 | 生成的类似，但是在距离平均值两个标准差之外的随机值将被丢弃并重新生成。这是用来生成神经网络权重和滤波器的推荐初始化器。 149 | 150 | \textbf{Arguments} 151 | 152 | \begin{itemize} 153 | \tightlist 154 | \item 155 | \textbf{mean}: 一个 Python 156 | 标量或者一个标量张量。要生成的随机值的平均数。 157 | \item 158 | \textbf{stddev}: 一个 Python 159 | 标量或者一个标量张量。要生成的随机值的标准差。 160 | \item 161 | \textbf{seed}: 一个 Python 整数。用于设置随机数种子。 162 | \end{itemize} 163 | 164 | 165 | 166 | 167 | \subsubsection{VarianceScaling {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L155}{{[}source{]}}}} 168 | 169 | \begin{Shaded} 170 | \begin{Highlighting}[] 171 | \NormalTok{keras.initializers.VarianceScaling(scale}\OperatorTok{=}\FloatTok{1.0}\NormalTok{, mode}\OperatorTok{=}\StringTok{'fan_in'}\NormalTok{, distribution}\OperatorTok{=}\StringTok{'normal'},\\ 172 | \hspace{3cm}\NormalTok{seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 173 | \end{Highlighting} 174 | \end{Shaded} 175 | 176 | 初始化器能够根据权值的尺寸调整其规模。 177 | 178 | 使用 \texttt{distribution="normal"} 时，样本是从一个以 0 179 | 为中心的截断正态分布中抽取的，\texttt{stddev\ =\ sqrt(scale\ /\ n)}，其中 180 | n 是： 181 | 182 | \begin{itemize} 183 | \tightlist 184 | \item 185 | 权值张量中输入单元的数量，如果 mode = "fan\_in"。 186 | \item 187 | 输出单元的数量，如果 mode = "fan\_out"。 188 | \item 189 | 输入和输出单位数量的平均数，如果 mode = "fan\_avg"。 190 | \end{itemize} 191 | 192 | 使用 \texttt{distribution="uniform"} 时，样本是从 {[}-limit，limit{]} 193 | 内的均匀分布中抽取的，其中 \texttt{limit\ =\ sqrt(3\ *\ scale\ /\ n)}。 194 | 195 | \textbf{参数} 196 | 197 | \begin{itemize} 198 | \tightlist 199 | \item 200 | \textbf{scale}: 缩放因子（正浮点数）。 201 | \item 202 | \textbf{mode}: "fan\_in", "fan\_out", "fan\_avg" 之一。 203 | \item 204 | \textbf{distribution}: 使用的随机分布。"normal", "uniform" 之一。 205 | \item 206 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 207 | \end{itemize} 208 | 209 | \textbf{异常} 210 | 211 | \begin{itemize} 212 | \tightlist 213 | \item 214 | \textbf{ValueError}: 如果 "scale", mode" 或 "distribution" 参数无效。 215 | \end{itemize} 216 | 217 | 218 | 219 | 220 | \subsubsection{Orthogonal {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L228}{{[}source{]}}}} 221 | 222 | \begin{Shaded} 223 | \begin{Highlighting}[] 224 | \NormalTok{keras.initializers.Orthogonal(gain}\OperatorTok{=}\FloatTok{1.0}\NormalTok{, seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 225 | \end{Highlighting} 226 | \end{Shaded} 227 | 228 | 生成一个随机正交矩阵的初始化器。 229 | 230 | \textbf{参数} 231 | 232 | \begin{itemize} 233 | \tightlist 234 | \item 235 | \textbf{gain}: 适用于正交矩阵的乘法因子。 236 | \item 237 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 238 | \end{itemize} 239 | 240 | \textbf{参考文献} 241 | 242 | Saxe et al., http://arxiv.org/abs/1312.6120 243 | 244 | 245 | 246 | 247 | \subsubsection{Identity {\href{https://github.com/keras-team/keras/blob/master/keras/initializers.py\#L265}{{[}source{]}}}} 248 | 249 | \begin{Shaded} 250 | \begin{Highlighting}[] 251 | \NormalTok{keras.initializers.Identity(gain}\OperatorTok{=}\FloatTok{1.0}\NormalTok{)} 252 | \end{Highlighting} 253 | \end{Shaded} 254 | 255 | 生成单位矩阵的初始化器。 256 | 257 | 仅用于 2D 方阵。 258 | 259 | \textbf{参数} 260 | 261 | \begin{itemize} 262 | \tightlist 263 | \item 264 | \textbf{gain}: 适用于单位矩阵的乘法因子。 265 | \end{itemize} 266 | 267 | 268 | 269 | \subsubsection{lecun\_uniform}\label{lecunux5funiform} 270 | 271 | \begin{Shaded} 272 | \begin{Highlighting}[] 273 | \NormalTok{lecun_uniform(seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 274 | \end{Highlighting} 275 | \end{Shaded} 276 | 277 | LeCun 均匀初始化器。 278 | 279 | 它从 {[}-limit，limit{]} 中的均匀分布中抽取样本， 其中 \texttt{limit} 是 280 | \texttt{sqrt(3\ /\ fan\_in)}， \texttt{fan\_in} 281 | 是权值张量中的输入单位的数量。 282 | 283 | \textbf{Arguments} 284 | 285 | \begin{itemize} 286 | \tightlist 287 | \item 288 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 289 | \end{itemize} 290 | 291 | \textbf{Returns} 292 | 293 | 一个初始化器。 294 | 295 | \textbf{参考文献} 296 | 297 | LeCun 98, Efficient Backprop, - 298 | \textbf{http}://yann.lecun.com/exdb/publis/pdf/lecun-98b.pdf 299 | 300 | 301 | 302 | \subsubsection{glorot\_normal}\label{glorotux5fnormal} 303 | 304 | \begin{Shaded} 305 | \begin{Highlighting}[] 306 | \NormalTok{glorot_normal(seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 307 | \end{Highlighting} 308 | \end{Shaded} 309 | 310 | Glorot 正态分布初始化器，也称为 Xavier 正态分布初始化器。 311 | 312 | 它从以 0 为中心，标准差为 313 | \texttt{stddev\ =\ sqrt(2\ /\ (fan\_in\ +\ fan\_out))} 314 | 的截断正态分布中抽取样本， 其中 \texttt{fan\_in} 315 | 是权值张量中的输入单位的数量， \texttt{fan\_out} 316 | 是权值张量中的输出单位的数量。 317 | 318 | \textbf{Arguments} 319 | 320 | \begin{itemize} 321 | \tightlist 322 | \item 323 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 324 | \end{itemize} 325 | 326 | \textbf{Returns} 327 | 328 | 一个初始化器。 329 | 330 | \textbf{参考文献} 331 | 332 | Glorot \& Bengio, AISTATS 2010 - 333 | \textbf{http}://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf 334 | 335 | 336 | 337 | \subsubsection{glorot\_uniform}\label{glorotux5funiform} 338 | 339 | \begin{Shaded} 340 | \begin{Highlighting}[] 341 | \NormalTok{glorot_uniform(seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 342 | \end{Highlighting} 343 | \end{Shaded} 344 | 345 | Glorot 均匀分布初始化器，也称为 Xavier 均匀分布初始化器。 346 | 347 | 它从 {[}-limit，limit{]} 中的均匀分布中抽取样本， 其中 \texttt{limit} 是 348 | \texttt{sqrt(6\ /\ (fan\_in\ +\ fan\_out))}， \texttt{fan\_in} 349 | 是权值张量中的输入单位的数量， \texttt{fan\_out} 350 | 是权值张量中的输出单位的数量。 351 | 352 | \textbf{参数} 353 | 354 | \begin{itemize} 355 | \tightlist 356 | \item 357 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 358 | \end{itemize} 359 | 360 | \textbf{返回} 361 | 362 | 一个初始化器。 363 | 364 | \textbf{参考文献} 365 | 366 | Glorot \& Bengio, AISTATS 2010 - 367 | \textbf{http}://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf 368 | 369 | 370 | 371 | \subsubsection{he\_normal}\label{heux5fnormal} 372 | 373 | \begin{Shaded} 374 | \begin{Highlighting}[] 375 | \NormalTok{he_normal(seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 376 | \end{Highlighting} 377 | \end{Shaded} 378 | 379 | He 正态分布初始化器。 380 | 381 | 它从以 0 为中心，标准差为 \texttt{stddev\ =\ sqrt(2\ /\ fan\_in)} 382 | 的截断正态分布中抽取样本， 其中 \texttt{fan\_in} 383 | 是权值张量中的输入单位的数量， 384 | 385 | \textbf{参数} 386 | 387 | \begin{itemize} 388 | \tightlist 389 | \item 390 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 391 | \end{itemize} 392 | 393 | \textbf{返回} 394 | 395 | 一个初始化器。 396 | 397 | \textbf{参考文献} 398 | 399 | He et al., http://arxiv.org/abs/1502.01852 400 | 401 | 402 | 403 | \subsubsection{lecun\_normal}\label{lecunux5fnormal} 404 | 405 | \begin{Shaded} 406 | \begin{Highlighting}[] 407 | \NormalTok{lecun_normal(seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 408 | \end{Highlighting} 409 | \end{Shaded} 410 | 411 | LeCun 正态分布初始化器。 412 | 413 | 它从以 0 为中心，标准差为 \texttt{stddev\ =\ sqrt(1\ /\ fan\_in)} 414 | 的截断正态分布中抽取样本， 其中 \texttt{fan\_in} 415 | 是权值张量中的输入单位的数量。 416 | 417 | \textbf{参数} 418 | 419 | \begin{itemize} 420 | \tightlist 421 | \item 422 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 423 | \end{itemize} 424 | 425 | \textbf{返回} 426 | 427 | 一个初始化器。 428 | 429 | \textbf{参考文献} 430 | 431 | \begin{itemize} 432 | \tightlist 433 | \item 434 | \href{https://arxiv.org/abs/1706.02515}{Self-Normalizing Neural 435 | Networks} 436 | \item 437 | \href{http://yann.lecun.com/exdb/publis/pdf/lecun-98b.pdf}{Efficient 438 | Backprop} 439 | \end{itemize} 440 | 441 | 442 | 443 | \subsubsection{he\_uniform}\label{heux5funiform} 444 | 445 | \begin{Shaded} 446 | \begin{Highlighting}[] 447 | \NormalTok{he_uniform(seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 448 | \end{Highlighting} 449 | \end{Shaded} 450 | 451 | He 均匀方差缩放初始化器。 452 | 453 | 它从 {[}-limit，limit{]} 中的均匀分布中抽取样本， 其中 \texttt{limit} 是 454 | \texttt{sqrt(6\ /\ fan\_in)}， 其中 \texttt{fan\_in} 455 | 是权值张量中的输入单位的数量。 456 | 457 | \textbf{参数} 458 | 459 | \begin{itemize} 460 | \tightlist 461 | \item 462 | \textbf{seed}: 一个 Python 整数。作为随机发生器的种子。 463 | \end{itemize} 464 | 465 | \textbf{返回} 466 | 467 | 一个初始化器。 468 | 469 | \textbf{参考文献} 470 | 471 | He et al., http://arxiv.org/abs/1502.01852 472 | 473 | 一个初始化器可以作为一个字符串传递（必须匹配上面的一个可用的初始化器），或者作为一个可调用函数传递： 474 | 475 | \begin{Shaded} 476 | \begin{Highlighting}[] 477 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{initializers} 478 | 479 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, kernel_initializer}\OperatorTok{=}\NormalTok{initializers.random_normal(stddev}\OperatorTok{=}\FloatTok{0.01}\NormalTok{)))} 480 | 481 | \CommentTok{# 同样有效;将使用默认参数。} 482 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, kernel_initializer}\OperatorTok{=}\StringTok{'random_normal'}\NormalTok{))} 483 | \end{Highlighting} 484 | \end{Shaded} 485 | 486 | \subsection{使用自定义初始化器}\label{ux4f7fux7528ux81eaux5b9aux4e49ux521dux59cbux5316ux5668} 487 | 488 | 如果传递一个自定义的可调用函数，那么它必须使用参数 489 | \texttt{shape}（需要初始化的变量的尺寸）和 \texttt{dtype}（数据类型）： 490 | 491 | \begin{Shaded} 492 | \begin{Highlighting}[] 493 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{backend }\ImportTok{as} \NormalTok{K} 494 | 495 | \KeywordTok{def} \NormalTok{my_init(shape, dtype}\OperatorTok{=}\VariableTok{None}\NormalTok{):} 496 | \ControlFlowTok{return} \NormalTok{K.random_normal(shape, dtype}\OperatorTok{=}\NormalTok{dtype)} 497 | 498 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, kernel_initializer}\OperatorTok{=}\NormalTok{my_init))} 499 | \end{Highlighting} 500 | \end{Shaded} 501 | 502 | \newpage -------------------------------------------------------------------------------- /chapter/15_regularizers.tex: -------------------------------------------------------------------------------- 1 | \section{正则化 Regularizers}\label{regularizers} 2 | \subsection{正规化的使用} 3 | 4 | 正则化器允许在优化过程中对层的参数或层的激活情况进行惩罚。 网络优化的损失函数也包括这些惩罚项。 5 | 6 | 惩罚是以层为对象进行的。具体的 API 因层而异，但\texttt{Dense}，\texttt{Conv1D}，\texttt{Conv2D}和\texttt{Conv3D}这些层具有统一的API。 7 | 8 | 正则化器开放 3 个关键字参数： 9 | 10 | \begin{itemize} 11 | \tightlist 12 | \item 13 | \texttt{kernel\_regularizer}: 14 | \texttt{keras.regularizers.Regularizer}的实例 15 | \item 16 | \texttt{bias\_regularizer}: 17 | \texttt{keras.regularizers.Regularizer}的实例 18 | \item 19 | \texttt{activity\_regularizer}: 20 | \texttt{keras.regularizers.Regularizer}的实例 21 | \end{itemize} 22 | 23 | \subsection{例子}\label{ux4f8bux5b50} 24 | 25 | \begin{Shaded} 26 | \begin{Highlighting}[] 27 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{regularizers} 28 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, input_dim}\OperatorTok{=}\DecValTok{64}\NormalTok{,} 29 | \NormalTok{kernel_regularizer}\OperatorTok{=}\NormalTok{regularizers.l2(}\FloatTok{0.01}\NormalTok{),} 30 | \NormalTok{activity_regularizer}\OperatorTok{=}\NormalTok{regularizers.l1(}\FloatTok{0.01}\NormalTok{)))} 31 | \end{Highlighting} 32 | \end{Shaded} 33 | 34 | \subsection{可用的惩罚}\label{ux53efux7528ux7684ux60e9ux7f5a} 35 | 36 | \begin{Shaded} 37 | \begin{Highlighting}[] 38 | \NormalTok{keras.regularizers.l1(}\DecValTok{0}\NormalTok{.)} 39 | \NormalTok{keras.regularizers.l2(}\DecValTok{0}\NormalTok{.)} 40 | \NormalTok{keras.regularizers.l1_l2(}\DecValTok{0}\NormalTok{.)} 41 | \end{Highlighting} 42 | \end{Shaded} 43 | 44 | \subsection{开发新的正则化器}\label{ux5f00ux53d1ux65b0ux7684ux6b63ux5219ux5316ux5668} 45 | 46 | 任何输入一个权重矩阵、返回一个损失贡献张量的函数，都可以用作正则化器，例如： 47 | 48 | \begin{Shaded} 49 | \begin{Highlighting}[] 50 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{backend }\ImportTok{as} \NormalTok{K} 51 | 52 | \KeywordTok{def} \NormalTok{l1_reg(weight_matrix):} 53 | \ControlFlowTok{return} \FloatTok{0.01} \OperatorTok{*} \NormalTok{K.}\BuiltInTok{sum}\NormalTok{(K.}\BuiltInTok{abs}\NormalTok{(weight_matrix))} 54 | 55 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, input_dim}\OperatorTok{=}\DecValTok{64}\NormalTok{,} 56 | \NormalTok{kernel_regularizer}\OperatorTok{=}\NormalTok{l1_reg))} 57 | \end{Highlighting} 58 | \end{Shaded} 59 | 60 | 另外，你也可以用面向对象的方式来写你的正则化器, 例子见 https://github.com/keras-team/keras/blob/master/keras/regularizers.py 模块。 61 | 62 | \newpage 63 | -------------------------------------------------------------------------------- /chapter/16_constraints.tex: -------------------------------------------------------------------------------- 1 | \section{约束 Constraints}\label{constraints} 2 | 3 | \subsection{约束项的使用} 4 | 5 | \texttt{constraints} 6 | 模块的函数允许在优化期间对网络参数设置约束（例如非负性）。 7 | 8 | 约束是以层为对象进行的。具体的 API 因层而异，但 9 | \texttt{Dense}，\texttt{Conv1D}，\texttt{Conv2D} 和 \texttt{Conv3D} 10 | 这些层具有统一的 API。 11 | 12 | 约束层开放 2 个关键字参数： 13 | 14 | \begin{itemize} 15 | \tightlist 16 | \item 17 | \texttt{kernel\_constraint} 用于主权重矩阵。 18 | \item 19 | \texttt{bias\_constraint} 用于偏置。 20 | \end{itemize} 21 | 22 | \begin{Shaded} 23 | \begin{Highlighting}[] 24 | \ImportTok{from}\NormalTok{ keras.constraints }\ImportTok{import}\NormalTok{ max_norm} 25 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, kernel_constraint}\OperatorTok{=}\NormalTok{max_norm(}\FloatTok{2.}\NormalTok{)))} 26 | \end{Highlighting} 27 | \end{Shaded} 28 | 29 | \subsection{可用的约束} 30 | 31 | \begin{itemize} 32 | \tightlist 33 | \item 34 | \textbf{max\_norm(max\_value=2, axis=0)}: 最大范数约束 35 | \item 36 | \textbf{non\_neg()}: 非负性约束 37 | \item 38 | \textbf{unit\_norm(axis=0)}: 单位范数约束 39 | \item 40 | \textbf{min\_max\_norm(min\_value=0.0, max\_value=1.0, rate=1.0, 41 | axis=0)}: 最小/最大范数约束 42 | \end{itemize} 43 | \newpage 44 | -------------------------------------------------------------------------------- /chapter/17_visualization.tex: -------------------------------------------------------------------------------- 1 | \section{可视化 Visualization} 2 | \textbf{模型可视化}\ref{visualization} 3 | 4 | \texttt{keras.utils.vis\_utils}模块提供了一些绘制Keras模型的实用功能(使用\texttt{graphviz})。 5 | 6 | 以下实例，将绘制一张模型图，并保存为文件： 7 | 8 | \begin{Shaded} 9 | \begin{Highlighting}[] 10 | \ImportTok{from} \NormalTok{keras.utils }\ImportTok{import} \NormalTok{plot_model} 11 | \NormalTok{plot_model(model, to_file}\OperatorTok{=}\StringTok{'model.png'}\NormalTok{)} 12 | \end{Highlighting} 13 | \end{Shaded} 14 | 15 | \texttt{plot\_model}有两个可选参数: 16 | 17 | \begin{itemize} 18 | \tightlist 19 | \item 20 | \texttt{show\_shapes} (默认为False) 控制是否在图中输出各层的尺寸。 21 | \item 22 | \texttt{show\_layer\_names} (默认为True) 23 | 控制是否在图中显示每一层的名字。 24 | \end{itemize} 25 | 26 | 此外，你也可以直接取得\texttt{pydot.Graph}对象并自己渲染它。 ipython 27 | notebook中的可视化实例如下： 28 | 29 | \begin{Shaded} 30 | \begin{Highlighting}[] 31 | \ImportTok{from} \NormalTok{IPython.display }\ImportTok{import} \NormalTok{SVG} 32 | \ImportTok{from} \NormalTok{keras.utils.vis_utils }\ImportTok{import} \NormalTok{model_to_dot} 33 | 34 | \NormalTok{SVG(model_to_dot(model).create(prog}\OperatorTok{=}\StringTok{'dot'}\NormalTok{, }\BuiltInTok{format}\OperatorTok{=}\StringTok{'svg'}\NormalTok{))} 35 | \end{Highlighting} 36 | \end{Shaded} 37 | 38 | \newpage 39 | -------------------------------------------------------------------------------- /chapter/18_scikit-learn-api.tex: -------------------------------------------------------------------------------- 1 | \section{Scikit-learn API} 2 | \textbf{Scikit-Learn API的封装器} 3 | 4 | 你可以使用Keras的顺序模型(仅限单一输入)作为Scikit-Learn工作流程的一部分，通过在此找到的包装器: 5 | \texttt{keras.wrappers.scikit\_learn.py}. 6 | 7 | 有两个封装器可用: 8 | 9 | \texttt{keras.wrappers.scikit\_learn.KerasClassifier(build\_fn=None,\ **sk\_params)}, 10 | 这实现了Scikit-Learn分类器接口, 11 | 12 | \texttt{keras.wrappers.scikit\_learn.KerasRegressor(build\_fn=None,\ **sk\_params)}, 13 | 这实现了Scikit-Learn regressor界面。 14 | 15 | \textbf{参数} 16 | \begin{itemize} 17 | \tightlist 18 | \item 19 | \textbf{build\_fn}: 可调用函数或类实例 20 | \item 21 | \textbf{sk\_params}: 模型参数和拟合参数 22 | \end{itemize} 23 | 24 | \texttt{build\_fn} 25 | 这应该建立，编译，并返回一个Keras模型，将被用来拟合/预测。 26 | 以下之一三个值可以传递给\texttt{build\_fn} 27 | 28 | \begin{enumerate} 29 | \def\labelenumi{\arabic{enumi}.} 30 | \tightlist 31 | \item 32 | 函数 33 | \item 34 | 实现\texttt{\_\_call\_\_}函数的类的实例 35 | \item 36 | 没有。这意味着你实现了一个继承的类KerasClassifier或KerasRegressor。 37 | 当前类的\_\_call\_\_函数将被视为默认的\texttt{build\_fn}。 38 | \end{enumerate} 39 | 40 | \texttt{sk\_params}同时包含模型参数和拟合参数。 41 | 法律模型参数是\texttt{build\_fn}的参数。 类似于其他所有 42 | 估计者在Scikit-Learn, 43 | \texttt{build\_fn}应该为其参数提供默认值，这样就可以创建估计器，而不需要将任何值传递给\texttt{sk\_params}。 44 | 45 | \texttt{sk\_params}也可以被称为\texttt{fit}，\texttt{predict}， 46 | \texttt{predict\_proba}和\texttt{score}函数 (e.g., \texttt{epochs}, 47 | \texttt{batch\_size}). 拟合（预测）参数按以下顺序选择: 48 | 49 | \begin{enumerate} 50 | \def\labelenumi{\arabic{enumi}.} 51 | \tightlist 52 | \item 53 | 传递给\texttt{fit}，\texttt{predict}，\texttt{predict\_proba}和\texttt{score}函数的字典参数的值 54 | \item 55 | 传递给\texttt{sk\_params}的值 56 | \item 57 | \texttt{keras.models.Sequential}的默认值 58 | \texttt{fit}，\texttt{predict}，\texttt{predict\_proba}和\texttt{score}函数 59 | \end{enumerate} 60 | 61 | 当scikit-learn使用\texttt{grid\_search} 62 | API时，有效参数与\texttt{sk\_params}相同，包括拟合参数。 63 | 换句话说，你可以使用\texttt{grid\_search}来搜索最好的\texttt{batch\_size}或\texttt{epochs}以及模型参数。 64 | \newpage 65 | -------------------------------------------------------------------------------- /chapter/19_utils.tex: -------------------------------------------------------------------------------- 1 | \section{工具} 2 | 3 | 4 | \subsection{ CustomObjectScope {\href{https://github.com/keras-team/keras/blob/master/keras/utils/generic_utils.py\#L20}{{[}source{]}}}}\label{customobjectscope} 5 | 6 | \begin{Shaded} 7 | \begin{Highlighting}[] 8 | \NormalTok{keras.utils.CustomObjectScope()} 9 | \end{Highlighting} 10 | \end{Shaded} 11 | 12 | 提供一个无法转义的\texttt{\_GLOBAL\_CUSTOM\_OBJECTS} 范围。 13 | 14 | \texttt{with} 语句中的代码将能够通过名称访问自定义对象。 15 | 对全局自定义对象的更改会在封闭的 \texttt{with} 语句中持续存在。 16 | 在\texttt{with}语句结束时， 全局自定义对象将恢复到 \texttt{with} 17 | 语句开始时的状态。 18 | 19 | \textbf{例子} 20 | 21 | 考虑自定义对象 \texttt{MyObject} (例如一个类)： 22 | 23 | \begin{Shaded} 24 | \begin{Highlighting}[] 25 | \ControlFlowTok{with} \NormalTok{CustomObjectScope(\{}\StringTok{'MyObject'}\NormalTok{:MyObject\}):} 26 | \NormalTok{layer }\OperatorTok{=} \NormalTok{Dense(..., kernel_regularizer}\OperatorTok{=}\StringTok{'MyObject'}\NormalTok{)} 27 | \CommentTok{# 保存，加载等操作将按这个名称来识别自定义对象} 28 | \end{Highlighting} 29 | \end{Shaded} 30 | 31 | 32 | 33 | 34 | \subsection{ HDF5Matrix {\href{https://github.com/keras-team/keras/blob/master/keras/utils/io_utils.py\#L16}{{[}source{]}}}}\label{HDF5Matrix} 35 | 36 | \begin{Shaded} 37 | \begin{Highlighting}[] 38 | \NormalTok{keras.utils.HDF5Matrix(datapath, dataset, start}\OperatorTok{=}\DecValTok{0}\NormalTok{, end}\OperatorTok{=}\VariableTok{None}\NormalTok{, normalizer}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 39 | \end{Highlighting} 40 | \end{Shaded} 41 | 42 | 使用 HDF5 数据集表示，而不是 Numpy 数组。 43 | 44 | \textbf{例子} 45 | 46 | \begin{Shaded} 47 | \begin{Highlighting}[] 48 | \NormalTok{x_data }\OperatorTok{=} \NormalTok{HDF5Matrix(}\StringTok{'input/file.hdf5'}\NormalTok{, }\StringTok{'data'}\NormalTok{)} 49 | \NormalTok{model.predict(x_data)} 50 | \end{Highlighting} 51 | \end{Shaded} 52 | 53 | 提供 \texttt{start} 和 \texttt{end} 将允许使用数据集的一个切片。 54 | 55 | 你还可以给出标准化函数（或 lambda）（可选）。 56 | 这将在检索到的每一个数据切片上调用它。 57 | 58 | \textbf{参数} 59 | 60 | \begin{itemize} 61 | \tightlist 62 | \item 63 | \textbf{datapath}: 字符串，HDF5 文件路径。 64 | \item 65 | \textbf{dataset}: 字符串，datapath指定的文件中的 HDF5 数据集名称。 66 | \item 67 | \textbf{start}: 整数，所需的指定数据集的切片的开始位置。 68 | \item 69 | \textbf{end}: 整数，所需的指定数据集的切片的结束位置。 70 | \item 71 | \textbf{normalizer}: 在检索数据时调用的函数。 72 | \end{itemize} 73 | 74 | \textbf{返回} 75 | 76 | 一个类数组的 HDF5 数据集。 77 | 78 | 79 | 80 | 81 | \subsection{ Sequence {\href{https://github.com/keras-team/keras/blob/master/keras/utils/data_utils.py\#L303}{{[}source{]}}}} 82 | 83 | \begin{Shaded} 84 | \begin{Highlighting}[] 85 | \NormalTok{keras.utils.Sequence()} 86 | \end{Highlighting} 87 | \end{Shaded} 88 | 89 | 用于拟合数据序列的基类，例如一个数据集。 90 | 91 | 每一个 \texttt{Sequence} 必须实现 \texttt{\_\_getitem\_\_} 和 92 | \texttt{\_\_len\_\_} 方法。 如果你想在迭代之间修改你的数据集，你可以实现 93 | \texttt{on\_epoch\_end}。 \texttt{\_\_getitem\_\_} 94 | 方法应该范围一个完整的批次。 95 | 96 | \textbf{注意} 97 | 98 | \texttt{Sequence} 99 | 是进行多进程处理的更安全的方法。这种结构保证网络在每个时期每个样本只训练一次，这与生成器不同。 100 | 101 | \textbf{例子} 102 | 103 | \begin{Shaded} 104 | \begin{Highlighting}[] 105 | \ImportTok{from} \NormalTok{skimage.io }\ImportTok{import} \NormalTok{imread} 106 | \ImportTok{from} \NormalTok{skimage.transform }\ImportTok{import} \NormalTok{resize} 107 | \ImportTok{import} \NormalTok{numpy }\ImportTok{as} \NormalTok{np} 108 | \ImportTok{import} \NormalTok{math} 109 | 110 | \CommentTok{# 这里，`x_set` 是图像的路径列表} 111 | \CommentTok{# 以及 `y_set` 是对应的类别} 112 | 113 | \KeywordTok{class} \NormalTok{CIFAR10Sequence(Sequence):} 114 | 115 | \KeywordTok{def} \FunctionTok{__init__}\NormalTok{(}\VariableTok{self}\NormalTok{, x_set, y_set, batch_size):} 116 | \VariableTok{self}\NormalTok{.x, }\VariableTok{self}\NormalTok{.y }\OperatorTok{=} \NormalTok{x_set, y_set} 117 | \VariableTok{self}\NormalTok{.batch_size }\OperatorTok{=} \NormalTok{batch_size} 118 | 119 | \KeywordTok{def} \FunctionTok{__len__}\NormalTok{(}\VariableTok{self}\NormalTok{):} 120 | \ControlFlowTok{return} \NormalTok{math.ceil(}\BuiltInTok{len}\NormalTok{(}\VariableTok{self}\NormalTok{.x) }\OperatorTok{/} \VariableTok{self}\NormalTok{.batch_size)} 121 | 122 | \KeywordTok{def} \FunctionTok{__getitem__}\NormalTok{(}\VariableTok{self}\NormalTok{, idx):} 123 | \NormalTok{batch_x }\OperatorTok{=} \VariableTok{self}\NormalTok{.x[idx }\OperatorTok{*} \VariableTok{self}\NormalTok{.batch_size:(idx }\OperatorTok{+} \DecValTok{1}\NormalTok{) }\OperatorTok{*} \VariableTok{self}\NormalTok{.batch_size]} 124 | \NormalTok{batch_y }\OperatorTok{=} \VariableTok{self}\NormalTok{.y[idx }\OperatorTok{*} \VariableTok{self}\NormalTok{.batch_size:(idx }\OperatorTok{+} \DecValTok{1}\NormalTok{) }\OperatorTok{*} \VariableTok{self}\NormalTok{.batch_size]} 125 | 126 | \ControlFlowTok{return} \NormalTok{np.array([} 127 | \NormalTok{resize(imread(file_name), (}\DecValTok{200}\NormalTok{, }\DecValTok{200}\NormalTok{))} 128 | \ControlFlowTok{for} \NormalTok{file_name }\OperatorTok{in} \NormalTok{batch_x]), np.array(batch_y)} 129 | \end{Highlighting} 130 | \end{Shaded} 131 | 132 | 133 | 134 | \subsection{to\_categorical}\label{toux5fcategorical} 135 | 136 | \begin{Shaded} 137 | \begin{Highlighting}[] 138 | \NormalTok{keras.utils.to_categorical(y, num_classes}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 139 | \end{Highlighting} 140 | \end{Shaded} 141 | 142 | 将类向量（整数）转换为二进制类矩阵。 143 | 144 | 例如。用于 categorical\_crossentropy。 145 | 146 | \textbf{参数} 147 | 148 | \begin{itemize} 149 | \tightlist 150 | \item 151 | \textbf{y}: 需要转换成矩阵的类矢量 (从 0 到 num\_classes 的整数)。 152 | \item 153 | \textbf{num\_classes}: 总类别数。 154 | \end{itemize} 155 | 156 | \textbf{返回} 157 | 158 | 输入的二进制矩阵表示。 159 | 160 | 161 | 162 | \subsection{normalize}\label{normalize} 163 | 164 | \begin{Shaded} 165 | \begin{Highlighting}[] 166 | \NormalTok{keras.utils.normalize(x, axis}\OperatorTok{=-}\DecValTok{1}\NormalTok{, order}\OperatorTok{=}\DecValTok{2}\NormalTok{)} 167 | \end{Highlighting} 168 | \end{Shaded} 169 | 170 | 标准化一个 Numpy 数组。 171 | 172 | \textbf{参数} 173 | 174 | \begin{itemize} 175 | \tightlist 176 | \item 177 | \textbf{x}: 需要标准化的 Numpy 数组。 178 | \item 179 | \textbf{axis}: 需要标准化的轴。 180 | \item 181 | \textbf{order}: 标准化顺序(例如，2 表示 L2 规范化)。 182 | \end{itemize} 183 | 184 | \textbf{Returns} 185 | 186 | 数组的标准化副本。 187 | 188 | 189 | 190 | \subsection{get\_file}\label{get-file} 191 | 192 | \begin{Shaded} 193 | \begin{Highlighting}[] 194 | \NormalTok{keras.utils.get_file(fname, origin, untar}\OperatorTok{=}\VariableTok{False}\NormalTok{, md5_hash}\OperatorTok{=}\VariableTok{None}\NormalTok{, file_hash}\OperatorTok{=}\VariableTok{None}, \\ 195 | \hspace{3cm}\NormalTok{cache_subdir}\OperatorTok{=}\StringTok{'datasets'}\NormalTok{, hash_algorithm}\OperatorTok{=}\StringTok{'auto'}\NormalTok{, extract}\OperatorTok{=}\VariableTok{False}, \\ 196 | \hspace{3cm}\NormalTok{archive_format}\OperatorTok{=}\StringTok{'auto'}\NormalTok{, cache_dir}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 197 | \end{Highlighting} 198 | \end{Shaded} 199 | 200 | 从一个 URL 下载文件，如果它不存在缓存中。 201 | 202 | 默认情况下，URL \texttt{origin}处的文件 被下载到缓存目录 203 | \texttt{\textasciitilde{}/.keras} 中， 放在缓存子目录 \texttt{datasets}中，并命名为 204 | \texttt{fname}。 文件 \texttt{example.txt} 的最终位置为 205 | \texttt{\textasciitilde{}/.keras/datasets/example.txt}。 206 | 207 | tar, tar.gz, tar.bz, 以及 zip 格式的文件也可以被解压。 208 | 传递一个哈希值将在下载后校验文件。 命令行程序 \texttt{shasum} 和 209 | \texttt{sha256sum} 可以计算哈希。 210 | 211 | \textbf{参数} 212 | 213 | \begin{itemize} 214 | \tightlist 215 | \item 216 | \textbf{fname}: 文件名。如果指定了绝对路径 217 | \texttt{/path/to/file.txt}， 那么文件将会保存到那个路径。 218 | \item 219 | \textbf{origin}: 文件的原始 URL。 220 | \item 221 | \textbf{untar}: 由于使用 'extract' 而已被弃用。 222 | 布尔值，是否需要解压文件。 223 | \item 224 | \textbf{md5\_hash}: 由于使用 'file\_hash' 而已被弃用。 用于校验的 md5 225 | 哈希值。 226 | \item 227 | \textbf{file\_hash}: 下载后的文件的期望哈希字符串。 支持 sha256 和 md5 228 | 两个哈希算法。 229 | \item 230 | \textbf{cache\_subdir}: 在 Keras 缓存目录下的保存文件的子目录。 231 | 如果指定了绝对路径 \texttt{/path/to/folder}，则文件将被保存在该位置。 232 | \item 233 | \textbf{hash\_algorithm}: 选择哈希算法来校验文件。 可选的有 'md5', 234 | 'sha256', 以及 'auto'。 默认的 'auto' 将自动检测所使用的哈希算法。 235 | \item 236 | \textbf{extract}: True 的话会尝试将解压缩存档文件，如tar或zip。 237 | \item 238 | \textbf{archive\_format}: 尝试提取文件的存档格式。 可选的有 'auto', 239 | 'tar', 'zip', 以及 None。 'tar' 包含 tar, tar.gz, 和 tar.bz 文件。 240 | 默认 'auto' 为 {[}'tar', 'zip'{]}。 None 或 241 | 空列表将返回未找到任何匹配。 ke xu az z'auto', 'tar', 'zip', and None. 242 | \item 243 | \textbf{cache\_dir}: 存储缓存文件的位置，为 None 时默认为 244 | \hyperref[where-is-the-keras-configuration-file-stored]{Keras 245 | 目录}. 246 | \end{itemize} 247 | 248 | \textbf{返回} 249 | 250 | 下载的文件的路径。 251 | 252 | 253 | 254 | \subsection{print\_summary}\label{print-summary} 255 | 256 | \begin{Shaded} 257 | \begin{Highlighting}[] 258 | \NormalTok{keras.utils.print_summary(model, line_length}\OperatorTok{=}\VariableTok{None}\NormalTok{, positions}\OperatorTok{=}\VariableTok{None}\NormalTok{, print_fn}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 259 | \end{Highlighting} 260 | \end{Shaded} 261 | 262 | 打印模型概况。 263 | 264 | \textbf{参数} 265 | 266 | \begin{itemize} 267 | \tightlist 268 | \item 269 | \textbf{model}: Keras 模型实例。 270 | \item 271 | \textbf{line\_length}: 打印的每行的总长度 272 | (例如，设置此项以使其显示适应不同的终端窗口大小)。 273 | \item 274 | \textbf{positions}: 每行中日志元素的相对或绝对位置。 275 | 如果未提供，默认为 \texttt{{[}.33,\ .55,\ .67,\ 1.{]}}。 276 | \item 277 | \textbf{print\_fn}: 需要使用的打印函数。 它将在每一行概述时调用。 278 | 您可以将其设置为自定义函数以捕获字符串概述。 默认为 \texttt{print} 279 | (打印到标准输出)。 280 | \end{itemize} 281 | 282 | 283 | 284 | \subsection{plot\_model}\label{plotux5fmodel} 285 | 286 | \begin{Shaded} 287 | \begin{Highlighting}[] 288 | \NormalTok{keras.utils.plot_model(model, to_file}\OperatorTok{=}\StringTok{'model.png'}\NormalTok{, show_shapes}\OperatorTok{=}\VariableTok{False}, \\ 289 | \hspace{3cm}\NormalTok{show_layer_names}\OperatorTok{=}\VariableTok{True}\NormalTok{, rankdir}\OperatorTok{=}\StringTok{'TB'}\NormalTok{)} 290 | \end{Highlighting} 291 | \end{Shaded} 292 | 293 | 将 Keras 模型转换为 dot 格式并保存到文件中。 294 | 295 | \textbf{参数} 296 | 297 | \begin{itemize} 298 | \tightlist 299 | \item 300 | \textbf{model}: 一个 Keras 模型实例。 301 | \item 302 | \textbf{to\_file}: 绘制图像的文件名。 303 | \item 304 | \textbf{show\_shapes}: 是否显示尺寸信息。 305 | \item 306 | \textbf{show\_layer\_names}: 是否显示层的名称。 307 | \item 308 | \textbf{rankdir}: 传递给 PyDot 的 \texttt{rankdir} 参数， 309 | 一个指定绘图格式的字符串： 'TB' 创建一个垂直绘图； 'LR' 310 | 创建一个水平绘图。 311 | \end{itemize} 312 | 313 | 314 | 315 | \subsection{multi\_gpu\_model}\label{multi-gpu-model} 316 | 317 | \begin{Shaded} 318 | \begin{Highlighting}[] 319 | \NormalTok{keras.utils.multi_gpu_model(model, gpus}\OperatorTok{=}\VariableTok{None}, 320 | \NormalTok{cpu_merge}\OperatorTok{=}\VariableTok{True}, 321 | \NormalTok{cpu_relocation}\OperatorTok{=}\VariableTok{False}\NormalTok{)} 322 | \end{Highlighting} 323 | \end{Shaded} 324 | 325 | 将模型复制到不同的 GPU 上。 326 | 327 | 具体来说，该功能实现了单机多 GPU 数据并行性。 它的工作原理如下： 328 | 329 | \begin{itemize} 330 | \tightlist 331 | \item 332 | 将模型的输入分成多个子批次。 333 | \item 334 | 在每个子批次上应用模型副本。 每个模型副本都在专用 GPU 上执行。 335 | \item 336 | 将结果（在 CPU 上）连接成一个大批量。 337 | \end{itemize} 338 | 339 | 例如， 如果你的 \texttt{batch\_size} 是 64，且你使用 \texttt{gpus=2}， 340 | 那么我们将把输入分为两个 32 个样本的子批次， 在 1 个 GPU 上处理 1 341 | 个子批次，然后返回完整批次的 64 个处理过的样本。 342 | 343 | 这实现了多达 8 个 GPU 的准线性加速。 344 | 345 | 此功能目前仅适用于 TensorFlow 后端。 346 | 347 | \textbf{参数} 348 | 349 | \begin{itemize} 350 | \tightlist 351 | \item 352 | \textbf{model}: 一个 Keras 模型实例。为了避免OOM错误，该模型可以建立在 353 | CPU 上， 详见下面的使用样例。 354 | \item 355 | \textbf{gpus}: 整数 \textgreater{}= 2 或整数列表，创建模型副本的 GPU 356 | 数量， 或 GPU ID 的列表。 357 | \item 358 | \textbf{cpu\_merge}: 一个布尔值，用于标识是否强制合并 CPU 359 | 范围内的模型权重。 360 | \item 361 | \textbf{cpu\_relocation}: 一个布尔值，用来确定是否在 CPU 362 | 的范围内创建模型的权重。如果模型没有在任何一个设备范围内定义，您仍然可以通过激活这个选项来拯救它。 363 | \end{itemize} 364 | 365 | \textbf{返回} 366 | 367 | 一个 Keras \texttt{Model} 实例，它可以像初始 \texttt{model} 368 | 参数一样使用，但它将工作负载分布在多个 GPU 上。 369 | 370 | 371 | 372 | 373 | \textbf{例子} 374 | 375 | \begin{Shaded} 376 | \begin{Highlighting}[] 377 | \ImportTok{import} \NormalTok{tensorflow }\ImportTok{as} \NormalTok{tf} 378 | \ImportTok{from} \NormalTok{keras.applications }\ImportTok{import} \NormalTok{Xception} 379 | \ImportTok{from} \NormalTok{keras.utils }\ImportTok{import} \NormalTok{multi_gpu_model} 380 | \ImportTok{import} \NormalTok{numpy }\ImportTok{as} \NormalTok{np} 381 | 382 | \NormalTok{num_samples }\OperatorTok{=} \DecValTok{1000} 383 | \NormalTok{height }\OperatorTok{=} \DecValTok{224} 384 | \NormalTok{width }\OperatorTok{=} \DecValTok{224} 385 | \NormalTok{num_classes }\OperatorTok{=} \DecValTok{1000} 386 | 387 | \CommentTok{# 实例化基础模型（或「模板」模型）。} 388 | \CommentTok{# 我们建议在 CPU 设备范围内执行此操作，} 389 | \CommentTok{# 以便让模型的权值托管在 CPU 内存上。} 390 | \CommentTok{# 否则，他们可能会最终托管在 GPU 上，} 391 | \CommentTok{# 这会使权值共享变得复杂。} 392 | \ControlFlowTok{with} \NormalTok{tf.device(}\StringTok{'/cpu:0'}\NormalTok{):} 393 | \NormalTok{model }\OperatorTok{=} \NormalTok{Xception(weights}\OperatorTok{=}\VariableTok{None}\NormalTok{,} 394 | \NormalTok{input_shape}\OperatorTok{=}\NormalTok{(height, width, }\DecValTok{3}\NormalTok{),} 395 | \NormalTok{classes}\OperatorTok{=}\NormalTok{num_classes)} 396 | 397 | \CommentTok{# 将模型复制到 8 个 GPU 上。} 398 | \CommentTok{# 这假定你的机器有 8 个可用的 GPU。} 399 | \NormalTok{parallel_model }\OperatorTok{=} \NormalTok{multi_gpu_model(model, gpus}\OperatorTok{=}\DecValTok{8}\NormalTok{)} 400 | \NormalTok{parallel_model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'categorical_crossentropy'}\NormalTok{,} 401 | \NormalTok{optimizer}\OperatorTok{=}\StringTok{'rmsprop'}\NormalTok{)} 402 | 403 | \CommentTok{# 生成虚拟数据。} 404 | \NormalTok{x }\OperatorTok{=} \NormalTok{np.random.random((num_samples, height, width, }\DecValTok{3}\NormalTok{))} 405 | \NormalTok{y }\OperatorTok{=} \NormalTok{np.random.random((num_samples, num_classes))} 406 | 407 | \CommentTok{# 这个 `fit` 调用将分布在 8 个 GPU 上。} 408 | \CommentTok{# 由于 批大小为 256，每个 GPU 将处理 32 个样本。} 409 | \NormalTok{parallel_model.fit(x, y, epochs}\OperatorTok{=}\DecValTok{20}\NormalTok{, batch_size}\OperatorTok{=}\DecValTok{256}\NormalTok{)} 410 | 411 | \CommentTok{# 通过模板模型（共享相同的权值）保存模型：} 412 | \NormalTok{model.save(}\StringTok{'my_model.h5'}\NormalTok{)} 413 | \end{Highlighting} 414 | \end{Shaded} 415 | 416 | 417 | 418 | \textbf{关于模型保存} 419 | 420 | 要保存多 GPU 模型，请通过模板模型（传递给 multi\_gpu\_model 的参数）调用 421 | .save(fname) 或 .save\_weights(fname) 以进行存储，而不是通过 422 | multi\_gpu\_model 返回的模型。 423 | 424 | \newpage 425 | -------------------------------------------------------------------------------- /chapter/20_contributing.tex: -------------------------------------------------------------------------------- 1 | \section{贡献} 2 | \subsection{关于 Github Issues 和 Pull Requests}\label{contributing} 3 | 4 | 找到一个漏洞？有一个新的功能建议？想要对代码库做出贡献？请务必先阅读这些。 5 | 6 | \subsection{漏洞报告} 7 | 8 | 你的代码不起作用，你确定问题在于Keras？请按照以下步骤报告错误。 9 | 10 | \begin{enumerate} 11 | \def\labelenumi{\arabic{enumi}.} 12 | \item 13 | 你的漏洞可能已经被修复了。确保更新到目前的Keras master分支，以及最新的 14 | Theano/TensorFlow/CNTK master 分支。 轻松更新 Theano 15 | 的方法：\texttt{pip\ install\ git+git://github.com/Theano/Theano.git\ -\/-upgrade} 16 | \item 17 | 搜索相似问题。 确保在搜索已经解决的 Issue 时删除 \texttt{is:open} 18 | 标签。有可能已经有人遇到了这个漏洞。同时记得检查 Keras 19 | \hyperref[keras-faq]{FAQ}。仍然有问题？在 Github 上开一个 20 | Issue，让我们知道。 21 | \item 22 | 确保你向我们提供了有关你的配置的有用信息：什么操作系统？什么 Keras 23 | 后端？你是否在 GPU 上运行，Cuda 和 cuDNN 的版本是多少？GPU型号是什么？ 24 | \item 25 | 为我们提供一个脚本来重现这个问题。该脚本应该可以按原样运行，并且不应该要求下载外部数据（如果需要在某些测试数据上运行模型，请使用随机生成的数据）。我们建议你使用 26 | Github Gists 来张贴你的代码。任何无法重现的问题都会被关闭。 27 | \item 28 | 如果可能的话，自己动手修复这个漏洞 - 如果可以的话！ 29 | \end{enumerate} 30 | 31 | 你提供的信息越多，我们就越容易验证存在错误，并且我们可以采取更快的行动。如果你想快速解决你的问题，尊许上述步骤操作是至关重要的。 32 | 33 | 34 | \subsection{请求新功能} 35 | 36 | 你也可以使用 Github Issue 来请求你希望在 Keras 中看到的功能，或者在 37 | Keras API 中的更改。 38 | 39 | \begin{enumerate} 40 | \def\labelenumi{\arabic{enumi}.} 41 | \item 42 | 提供你想要的功能的清晰和详细的解释，以及为什么添加它很重要。请记住，我们需要的功能是对于大多数用户而言的，不仅仅是一小部分人。如果你只是针对少数用户，请考虑为 43 | Keras 编写附加库。对 Keras 来说，避免臃肿的 API 和代码库是至关重要的。 44 | \item 45 | 提供代码片段，演示您所需的 API 并说明您的功能的用例。 46 | 当然，在这一点上你不需要写任何真正的代码！ 47 | \item 48 | 讨论完该功能后，您可以选择尝试提一个 Pull 49 | Request。如果你完全可以，开始写一些代码。相比时间上，我们总是有更多的工作要做。如果你可以写一些代码，那么这将加速这个过程。 50 | \end{enumerate} 51 | 52 | 53 | \subsection{请求贡献代码} 54 | 55 | 在\href{https://github.com/keras-team/keras/projects/1}{这个板块} 56 | 我们会列出当前需要添加的出色的问题和新功能。如果你想要为 Keras 57 | 做贡献，这就是可以开始的地方。 58 | 59 | 60 | \subsection{Pull Requests 合并请求} 61 | 62 | \textbf{我应该在哪里提交我的合并请求？} 63 | 64 | \begin{enumerate} 65 | \def\labelenumi{\arabic{enumi}.} 66 | \item 67 | \textbf{Keras 改进与漏洞修复}， 68 | 请到~\href{https://github.com/keras-team/keras/tree/master}{Keras 69 | \texttt{master} 分支}。 70 | \item 71 | \textbf{测试新功能}, 例如网络层和数据集，请到 72 | \href{https://github.com/farizrahman4u/keras-contrib}{keras-contrib}。除非它是一个在 73 | \href{https://github.com/keras-team/keras/projects/1}{Requests for 74 | Contributions} 中列出的新功能，它属于 Keras 75 | 的核心部分。如果你觉得你的功能属于 Keras 76 | 核心，你可以提交一个设计文档，来解释你的功能，并争取它（请看以下解释）。 77 | \end{enumerate} 78 | 79 | 请注意任何有关 80 | \textbf{代码风格}（而不是修复修复，改进文档或添加新功能）的 PR 81 | 都会被拒绝。 82 | 83 | 以下是提交你的改进的快速指南： 84 | 85 | \begin{enumerate} 86 | \def\labelenumi{\arabic{enumi}.} 87 | \tightlist 88 | \item 89 | 如果你的 PR 介绍了功能的改变，确保你从撰写设计文档并将其发给 Keras 90 | 邮件列表开始，以讨论是否应该修改，以及如何处理。这将拯救你于 PR 91 | 关闭。当然，如果你的 PR 92 | 只是一个简单的漏洞修复，那就不需要这样做。撰写与提交设计文档的过程如下所示： 93 | \end{enumerate} 94 | 95 | \begin{itemize} 96 | \tightlist 97 | \item 98 | 从这个 99 | \href{https://docs.google.com/document/d/1ZXNfce77LDW9tFAj6U5ctaJmI5mT7CQXOFMEAZo-mAA/edit\#}{Google 100 | 文档模版} 开始，将它复制为一个新的 Google 文档。 101 | \item 102 | 填写内容。注意你需要插入代码样例。要插入代码，请使用 Google 103 | 文档插件，例如 \hyperref{https://chrome.google.com/webstore/detail/code-pretty/igjbncgfgnfpbnifnnlcmjfbnidkndnh?hl=en}{CodePretty} 104 | (有许多可用的插件)。 105 | \item 106 | 将共享设置为 「每个有链接的人都可以发表评论」。 107 | \item 108 | 将文档发给 \texttt{keras-users@googlegroups.com}，主题从 109 | \texttt{{[}API\ DESIGN\ REVIEW{]}} (全大写) 110 | 开始，这样我们才会注意到它。 111 | 112 | \begin{itemize} 113 | \tightlist 114 | \item 115 | 等待评论，回复评论。必要时修改提案。 ~ ~- 116 | 该提案最终将被批准或拒绝。一旦获得批准，您可以发出合并请求或要求他人撰写合并请求。 117 | \end{itemize} 118 | \end{itemize} 119 | 120 | \begin{enumerate} 121 | \def\labelenumi{\arabic{enumi}.} 122 | \setcounter{enumi}{1} 123 | \item 124 | 撰写代码（或者让别人写）。这是最难的一部分。 125 | \item 126 | 确保你引入的任何新功能或类都有适当的文档。确保你触摸的任何代码仍具有最新的文档。\textbf{应该严格遵循 127 | Docstring 风格}。尤其是，它们应该在 MarkDown 中格式化，并且应该有 128 | \texttt{Arguments}，\texttt{Returns}，\texttt{Raises} 129 | 部分（如果适用）。查看代码示例中的其他文档以做参考。 130 | \item 131 | 撰写测试。你的代码应该有完整的单元测试覆盖。如果你想看到你的 PR 132 | 迅速合并，这是至关重要的。 133 | \item 134 | 在本地运行测试套件。这很简单：在 Keras 目录下，直接运行： 135 | \texttt{py.test\ tests/}。 136 | \end{enumerate} 137 | 138 | \begin{itemize} 139 | \tightlist 140 | \item 141 | 您还需要安装测试包： \texttt{pip\ install\ -e\ .{[}tests{]}}。 142 | \end{itemize} 143 | 144 | \begin{enumerate} 145 | \def\labelenumi{\arabic{enumi}.} 146 | \setcounter{enumi}{5} 147 | \tightlist 148 | \item 149 | 确保通过所有测试： 150 | \end{enumerate} 151 | 152 | \begin{itemize} 153 | \tightlist 154 | \item 155 | 使用 Theano 后端，Python 2.7 和 Python 3.5。确保你有 Theano 156 | 的开发版本。 157 | \item 158 | 使用 TensorFlow 后端，Python 2.7 和 Python 3.5。确保你有 TensorFlow 159 | 的开发版本。 160 | \item 161 | 使用 CNTK 后端， Python 2.7 和 Python 3.5。确保你有 CNTK 的开发版本。 162 | \end{itemize} 163 | 164 | \begin{enumerate} 165 | \def\labelenumi{\arabic{enumi}.} 166 | \setcounter{enumi}{6} 167 | \tightlist 168 | \item 169 | 我们使用 PEP8 170 | 语法约定，但是当涉及到行长时，我们不是教条式的。尽管如此，确保你的行保持合理的大小。为了让您的生活更轻松，我们推荐使用 171 | PEP8 linter： 172 | \end{enumerate} 173 | 174 | \begin{itemize} 175 | \tightlist 176 | \item 177 | 安装 PEP8 包：\texttt{pip\ install\ pep8\ pytest-pep8\ autopep8} 178 | \item 179 | 运行独立的 PEP8 检查： \texttt{py.test\ -\/-pep8\ -m\ pep8} 180 | \item 181 | 你可以通过运行这个命令自动修复一些 PEP8 错误：\\ 182 | \texttt{autopep8\ -i\ -\/-select\ \textless{}errors\textgreater{}\ \textless{}FILENAME\textgreater{}}\\ 183 | 例如： 184 | \texttt{autopep8\ -i\ -\/-select\ E128\ tests/keras/backend/test\_backends.py} 185 | \end{itemize} 186 | 187 | \begin{enumerate} 188 | \def\labelenumi{\arabic{enumi}.} 189 | \setcounter{enumi}{7} 190 | \item 191 | 提交时，请使用适当的描述性提交消息。 192 | \item 193 | 更新文档。如果引入新功能，请确保包含演示新功能用法的代码片段。 194 | \item 195 | 提交你的 196 | PR。如果你的更改已在之前的讨论中获得批准，并且你有完整（并通过）的单元测试以及正确的 197 | docstring/文档，则你的 PR 可能会立即合并。 198 | \end{enumerate} 199 | 200 | 201 | 202 | \subsection{添加新的样例} 203 | 204 | 即使你不贡献 Keras 源代码，如果你有一个简洁而强大的 Keras 205 | 应用，请考虑将它添加到我们的样例集合中。\href{https://github.com/keras-team/keras/tree/master/examples}{现有的例子}展示惯用的 206 | Keras 代码：确保保持自己的脚本具有相同的风格。 207 | 208 | \newpage 209 | -------------------------------------------------------------------------------- /chapter/3-1_about-keras-models.tex: -------------------------------------------------------------------------------- 1 | \section{模型}\label{about-keras-models} 2 | \subsection{关于Keras模型} 3 | 在 Keras 中有两类主要的模型：\hyperref[sequential-api]{Sequential 顺序模型} 和 \hyperref[model-api]{使用函数式 API 的 Model 类模型}。 4 | 5 | 这些模型有许多共同的方法和属性： 6 | 7 | \begin{itemize} 8 | \tightlist 9 | \item \texttt{model.layers}是包含模型网络层的展平列表。 10 | \item \texttt{model.inputs}是模型输入张量的列表。 11 | \item \texttt{model.outputs}是模型输出张量的列表。 12 | \item 13 | \texttt{model.summary()}: 打印出模型概述信息。 它是 14 | \hyperref[print-summary]{utils.print\_summary} 的简捷调用。 15 | \item 16 | \texttt{model.get\_config()}: 17 | 返回包含模型配置信息的字典。通过以下代码，就可以根据这些配置信息重新实例化模型： 18 | \end{itemize} 19 | 20 | \begin{Shaded} 21 | \begin{Highlighting}[] 22 | \NormalTok{config }\OperatorTok{=} \NormalTok{model.get_config()} 23 | \NormalTok{model }\OperatorTok{=} \NormalTok{Model.from_config(config)} 24 | \CommentTok{# or, for Sequential:} 25 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential.from_config(config)} 26 | \end{Highlighting} 27 | \end{Shaded} 28 | 29 | \begin{itemize} 30 | \tightlist 31 | \item 32 | \texttt{model.get\_weights()}: 返回模型权重的张量列表，类型为 Numpy 33 | array。 34 | \item 35 | \texttt{model.set\_weights(weights)}: 从 Nympy array 36 | 中为模型设置权重。列表中的数组必须与 \texttt{get\_weights()} 37 | 返回的权重具有相同的尺寸。 38 | \item 39 | \texttt{model.to\_json()}: 以 JSON 40 | 字符串的形式返回模型的表示。请注意，该表示不包括权重，只包含结构。你可以通过以下代码，从 41 | JSON 字符串中重新实例化相同的模型（带有重新初始化的权重）： 42 | \end{itemize} 43 | 44 | \begin{Shaded} 45 | \begin{Highlighting}[] 46 | \ImportTok{from} \NormalTok{keras.models }\ImportTok{import} \NormalTok{model_from_json} 47 | 48 | \NormalTok{json_string }\OperatorTok{=} \NormalTok{model.to_json()} 49 | \NormalTok{model }\OperatorTok{=} \NormalTok{model_from_json(json_string)} 50 | \end{Highlighting} 51 | \end{Shaded} 52 | 53 | \begin{itemize} 54 | \tightlist 55 | \item 56 | \texttt{model.to\_yaml()}: 以 YAML 57 | 字符串的形式返回模型的表示。请注意，该表示不包括权重，只包含结构。你可以通过以下代码，从 58 | YAML 字符串中重新实例化相同的模型（带有重新初始化的权重）： 59 | \end{itemize} 60 | 61 | \begin{Shaded} 62 | \begin{Highlighting}[] 63 | \ImportTok{from} \NormalTok{keras.models }\ImportTok{import} \NormalTok{model_from_yaml} 64 | 65 | \NormalTok{yaml_string }\OperatorTok{=} \NormalTok{model.to_yaml()} 66 | \NormalTok{model }\OperatorTok{=} \NormalTok{model_from_yaml(yaml_string)} 67 | \end{Highlighting} 68 | \end{Shaded} 69 | 70 | \begin{itemize} 71 | \tightlist 72 | \item 73 | \texttt{model.save\_weights(filepath)}: 将模型权重存储为 HDF5 文件。 74 | \item 75 | \texttt{model.load\_weights(filepath,\ by\_name=False)}: 从 HDF5 76 | 文件（由 \texttt{save\_weights} 77 | 创建）中加载权重。默认情况下，模型的结构应该是不变的。 78 | 如果想将权重载入不同的模型（部分层相同）， 设置 \texttt{by\_name=True} 79 | 来载入那些名字相同的层的权重。 80 | \end{itemize} 81 | 82 | 注意：另请参阅\hyperref[how-can-i-install-HDF5-or-h5py-to-save-my-models-in-Keras]{如何安装HDF5 或 h5py 以保存 Keras 模型}，在常见问题中了解如何安装 \texttt{h5py} 83 | 的说明。 84 | 85 | 86 | \textbf{Model 子类} 87 | 88 | 除了这两类模型之外，你还可以通过继承 \texttt{Model} 类并在 \texttt{call} 89 | 方法中实现你自己的前向传播，以创建你自己的完全定制化的模型，（\texttt{Model} 子类 API 引入于 Keras 2.2.0）。 90 | 91 | 这里是一个用 \texttt{Model} 子类写的简单的多层感知器的例子： 92 | 93 | \begin{Shaded} 94 | \begin{Highlighting}[] 95 | \ImportTok{import}\NormalTok{ keras} 96 | 97 | \KeywordTok{class}\NormalTok{ SimpleMLP(keras.Model):} 98 | 99 | \KeywordTok{def} \FunctionTok{__init__}\NormalTok{(}\VariableTok{self}\NormalTok{, use_bn}\OperatorTok{=}\VariableTok{False}\NormalTok{, use_dp}\OperatorTok{=}\VariableTok{False}\NormalTok{, num_classes}\OperatorTok{=}\DecValTok{10}\NormalTok{):} 100 | \BuiltInTok{super}\NormalTok{(SimpleMLP, }\VariableTok{self}\NormalTok{).}\FunctionTok{__init__}\NormalTok{(name}\OperatorTok{=}\StringTok{'mlp'}\NormalTok{)} 101 | \VariableTok{self}\NormalTok{.use_bn }\OperatorTok{=}\NormalTok{ use_bn} 102 | \VariableTok{self}\NormalTok{.use_dp }\OperatorTok{=}\NormalTok{ use_dp} 103 | \VariableTok{self}\NormalTok{.num_classes }\OperatorTok{=}\NormalTok{ num_classes} 104 | 105 | \VariableTok{self}\NormalTok{.dense1 }\OperatorTok{=}\NormalTok{ keras.layers.Dense(}\DecValTok{32}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)} 106 | \VariableTok{self}\NormalTok{.dense2 }\OperatorTok{=}\NormalTok{ keras.layers.Dense(num_classes, activation}\OperatorTok{=}\StringTok{'softmax'}\NormalTok{)} 107 | \ControlFlowTok{if} \VariableTok{self}\NormalTok{.use_dp:} 108 | \VariableTok{self}\NormalTok{.dp }\OperatorTok{=}\NormalTok{ keras.layers.Dropout(}\FloatTok{0.5}\NormalTok{)} 109 | \ControlFlowTok{if} \VariableTok{self}\NormalTok{.use_bn:} 110 | \VariableTok{self}\NormalTok{.bn }\OperatorTok{=}\NormalTok{ keras.layers.BatchNormalization(axis}\OperatorTok{=-}\DecValTok{1}\NormalTok{)} 111 | 112 | \KeywordTok{def}\NormalTok{ call(}\VariableTok{self}\NormalTok{, inputs):} 113 | \NormalTok{ x }\OperatorTok{=} \VariableTok{self}\NormalTok{.dense1(inputs)} 114 | \ControlFlowTok{if} \VariableTok{self}\NormalTok{.use_dp:} 115 | \NormalTok{ x }\OperatorTok{=} \VariableTok{self}\NormalTok{.dp(x)} 116 | \ControlFlowTok{if} \VariableTok{self}\NormalTok{.use_bn:} 117 | \NormalTok{ x }\OperatorTok{=} \VariableTok{self}\NormalTok{.bn(x)} 118 | \ControlFlowTok{return} \VariableTok{self}\NormalTok{.dense2(x)} 119 | 120 | \NormalTok{model }\OperatorTok{=}\NormalTok{ SimpleMLP()} 121 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(...)} 122 | \NormalTok{model.fit(...)} 123 | \end{Highlighting} 124 | \end{Shaded} 125 | 126 | 网络层定义在 \texttt{\_\_init\_\_(self,\ ...)} 中，前向传播在 127 | \texttt{call(self,\ inputs)} 中指定。在 \texttt{call} 128 | 中，你可以指定自定义的损失函数，通过调用 129 | \texttt{self.add\_loss(loss\_tensor)} （就像你在自定义层中一样）。 130 | 131 | 在子类模型中，模型的拓扑结构是由 Python 132 | 代码定义的（而不是网络层的静态图）。这意味着该模型的拓扑结构不能被检查或序列化。因此，以下方法和属性不适用于子类模型： 133 | 134 | \begin{itemize} 135 | \tightlist 136 | \item 137 | \texttt{model.inputs} 和 \texttt{model.outputs}。 138 | \item 139 | \texttt{model.to\_yaml()} 和 \texttt{model.to\_json()}。 140 | \item 141 | \texttt{model.get\_config()} 和 \texttt{model.save()}。 142 | \end{itemize} 143 | 144 | 关键点：为每个任务使用正确的 API。\texttt{Model} 子类化 API 可以为实现复杂模型提供更大的灵活性，但它需要付出代价（比如缺失的特性）：它更冗长，更复杂，并且有更多的用户错误机会。如果可能的话，尽可能使用函数式API，这对用户更友好。 145 | -------------------------------------------------------------------------------- /chapter/3-2_Sequential.tex: -------------------------------------------------------------------------------- 1 | \subsection{Sequential 顺序模型 API}\label{sequential-api} 2 | 3 | \subsubsection{Sequential 顺序模型 API} 4 | 在阅读这片文档前，请先阅读 5 | \hyperref[sequential-model-guide]{Keras Sequential模型指引}。 6 | 7 | \subsubsection{常用 Sequential 属性}\label{ux5e38ux7528-sequential-ux5c5eux6027} 8 | 9 | \begin{itemize} 10 | \tightlist 11 | \item 12 | \texttt{model.layers} 是添加到模型的层的列表。 13 | \end{itemize} 14 | 15 | 16 | 17 | \subsubsection{Sequential 模型方法}\label{sequential-ux6a21ux578bux65b9ux6cd5} 18 | 19 | \subsubsubsection{compile}\label{compile} 20 | 21 | \begin{Shaded} 22 | \begin{Highlighting}[] 23 | \BuiltInTok{compile}\NormalTok{(}\VariableTok{self}\NormalTok{, optimizer, loss, metrics}\OperatorTok{=}\VariableTok{None}\NormalTok{, sample_weight_mode}\OperatorTok{=}\VariableTok{None}, \\ 24 | \hspace{1.4cm} \NormalTok{weighted_metrics}\OperatorTok{=}\VariableTok{None}\NormalTok{, target_tensors}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 25 | \end{Highlighting} 26 | \end{Shaded} 27 | 28 | 用于配置训练模型。 29 | 30 | \textbf{参数} 31 | 32 | \begin{itemize} 33 | \tightlist 34 | \item 35 | \textbf{optimizer}: 字符串（优化器名）或者优化器对象。详见 36 | \hyperref[optimizers]{optimizers}。 37 | \item 38 | \textbf{loss}: 字符串（目标函数名）或目标函数。详见 39 | \hyperref[losses]{losses}。 40 | 如果模型具有多个输出，则可以通过传递损失函数的字典或列表，在每个输出上使用不同的损失。模型将最小化的损失值将是所有单个损失的总和。 41 | \item 42 | \textbf{metrics}: 在训练和测试期间的模型评估标准。通常你会使用 43 | \texttt{metrics\ =\ {[}\textquotesingle{}accuracy\textquotesingle{}{]}}。 44 | 要为多输出模型的不同输出指定不同的评估标准，还可以传递一个字典，如 45 | \texttt{metrics\ =\ \{\textquotesingle{}output\_a\textquotesingle{}：\textquotesingle{}accuracy\textquotesingle{}\}}。 46 | \item 47 | \textbf{sample\_weight\_mode}: 48 | 如果你需要执行按时间步采样权重（2D权重），请将其设置为 49 | \texttt{temporal}。 默认为 50 | \texttt{None}，为采样权重（1D）。如果模型有多个输出，则可以通过传递 51 | mode 的字典或列表，以在每个输出上使用不同的 52 | \texttt{sample\_weight\_mode}。 53 | \item 54 | \textbf{weighted\_metrics}: 在训练和测试期间，由 sample\_weight 或 55 | class\_weight 评估和加权的度量标准列表。 56 | \item 57 | \textbf{target\_tensors}: 默认情况下，Keras 58 | 将为模型的目标创建一个占位符，在训练过程中将使用目标数据。相反，如果你想使用自己的目标张量（反过来说，Keras 59 | 在训练期间不会载入这些目标张量的外部 Numpy 数据），您可以通过 60 | \texttt{target\_tensors} 参数指定它们。它应该是单个张量（对于单输出 61 | Sequential 模型）。 62 | \item 63 | \_\_**kwargs\_\_: 当使用 Theano/CNTK 后端时，这些参数被传入 64 | \texttt{K.function}。当使用 TensorFlow 后端时，这些参数被传递到 65 | \texttt{tf.Session.run}。 66 | \end{itemize} 67 | 68 | \textbf{异常} 69 | 70 | \begin{itemize} 71 | \tightlist 72 | \item 73 | \textbf{ValueError}: 如果 \texttt{optimizer}, \texttt{loss}, 74 | \texttt{metrics} 或 \texttt{sample\_weight\_mode} 这些参数不合法。 75 | \end{itemize} 76 | 77 | \textbf{例} 78 | 79 | \begin{Shaded} 80 | \begin{Highlighting}[] 81 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 82 | \NormalTok{model.add(Dense(}\DecValTok{32}\NormalTok{, input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{500}\NormalTok{,)))} 83 | \NormalTok{model.add(Dense(}\DecValTok{10}\NormalTok{, activation}\OperatorTok{=}\StringTok{'softmax'}\NormalTok{))} 84 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(optimizer}\OperatorTok{=}\StringTok{'rmsprop'}\NormalTok{,} 85 | \NormalTok{loss}\OperatorTok{=}\StringTok{'categorical_crossentropy'}\NormalTok{,} 86 | \NormalTok{metrics}\OperatorTok{=}\NormalTok{[}\StringTok{'accuracy'}\NormalTok{])} 87 | \end{Highlighting} 88 | \end{Shaded} 89 | 90 | 91 | 92 | \subsubsubsection{fit}\label{fit} 93 | 94 | \begin{Shaded} 95 | \begin{Highlighting}[] 96 | \NormalTok{fit(}\VariableTok{self}\NormalTok{, x}\OperatorTok{=}\VariableTok{None}\NormalTok{, y}\OperatorTok{=}\VariableTok{None}\NormalTok{, batch_size}\OperatorTok{=}\VariableTok{None}\NormalTok{, epochs}\OperatorTok{=}\DecValTok{1}\NormalTok{, verbose}\OperatorTok{=}\DecValTok{1}\NormalTok{, callbacks}\OperatorTok{=}\VariableTok{None},\\ 97 | \hspace{0.6cm} \NormalTok{ validation_split}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, validation_data}\OperatorTok{=}\VariableTok{None}\NormalTok{, shuffle}\OperatorTok{=}\VariableTok{True}\NormalTok{, class_weight}\OperatorTok{=}\VariableTok{None}, \\ 98 | \hspace{0.8cm} \NormalTok{sample_weight}\OperatorTok{=}\VariableTok{None}\NormalTok{, initial_epoch}\OperatorTok{=}\DecValTok{0}\NormalTok{, steps_per_epoch}\OperatorTok{=}\VariableTok{None}\NormalTok{, validation_steps}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 99 | \end{Highlighting} 100 | \end{Shaded} 101 | 102 | 以固定数量的轮次（数据集上的迭代）训练模型。 103 | 104 | \textbf{参数} 105 | 106 | \begin{itemize} 107 | \tightlist 108 | \item 109 | \textbf{x}: 训练数据的 Numpy 数组。 110 | 如果模型中的输入层被命名，你也可以传递一个字典，将输入层名称映射到 111 | Numpy 数组。 如果从本地框架张量馈送（例如 TensorFlow 数据张量）数据，x 112 | 可以是 \texttt{None}（默认）。 113 | \item 114 | \textbf{y}: 目标（标签）数据的 Numpy 数组。 115 | 如果模型中的输出层被命名，你也可以传递一个字典，将输出层名称映射到 116 | Numpy 数组。 如果从本地框架张量馈送（例如 TensorFlow 数据张量）数据，y 117 | 可以是 \texttt{None}（默认）。 118 | \item 119 | \textbf{batch\_size}: 整数或 120 | \texttt{None}。每次提度更新的样本数。如果未指定，默认为 32. 121 | \item 122 | \textbf{epochs}: 整数。训练模型迭代轮次。一个轮次是在整个 \texttt{x} 123 | 或 \texttt{y} 上的一轮迭代。请注意，与 \texttt{initial\_epoch} 124 | 一起，\texttt{epochs} 被理解为 「最终轮次」。模型并不是训练了 125 | \texttt{epochs} 轮，而是到第 \texttt{epochs} 轮停止训练。 126 | \item 127 | \textbf{verbose}: 0, 1 或 2。日志显示模式。 0 = 安静模式, 1 = 进度条, 128 | 2 = 每轮一行。 129 | \item 130 | \textbf{callbacks}: 一系列的 \texttt{keras.callbacks.Callback} 131 | 实例。一系列可以在训练时使用的回调函数。详见 132 | \hyperref[callbacks]{callbacks}。 133 | \item 134 | \textbf{validation\_split}: 在 0 和 1 135 | 之间浮动。用作验证集的训练数据的比例。模型将分出一部分不会被训练的验证数据，并将在每一轮结束时评估这些验证数据的误差和任何其他模型指标。验证数据是混洗之前 136 | \texttt{x} 和\texttt{y} 数据的最后一部分样本中。 137 | \item 138 | \textbf{validation\_data}: 元组 \texttt{(x\_val，y\_val)} 或元组 139 | \texttt{(x\_val，y\_val，val\_sample\_weights)}，用来评估损失，以及在每轮结束时的任何模型度量指标。模型将不会在这个数据上进行训练。这个参数会覆盖 140 | \texttt{validation\_split}。 141 | \item 142 | \textbf{shuffle}: 布尔值（是否在每轮迭代之前混洗数据）或者 字符串 143 | (\texttt{batch})。\texttt{batch} 是处理 HDF5 144 | 数据限制的特殊选项，它对一个 batch 内部的数据进行混洗。当 145 | \texttt{steps\_per\_epoch} 非 \texttt{None} 时，这个参数无效。 146 | \item 147 | \textbf{class\_weight}: 148 | 可选的字典，用来映射类索引（整数）到权重（浮点）值，用于加权损失函数（仅在训练期间）。这可能有助于告诉模型 149 | 「更多关注」来自代表性不足的类的样本。 150 | \item 151 | \textbf{sample\_weight}: 训练样本的可选 Numpy 152 | 权重数组，用于对损失函数进行加权（仅在训练期间）。您可以传递与输入样本长度相同的平坦（1D）Numpy 153 | 数组（权重和样本之间的 1：1 154 | 映射），或者在时序数据的情况下，可以传递尺寸为 155 | \texttt{(samples,\ sequence\_length)} 的 2D 156 | 数组，以对每个样本的每个时间步施加不同的权重。在这种情况下，你应该确保在 157 | \texttt{compile()} 中指定 \texttt{sample\_weight\_mode="temporal"}。 158 | \item 159 | \textbf{initial\_epoch}: 开始训练的轮次（有助于恢复之前的训练）。 160 | \item 161 | \textbf{steps\_per\_epoch}: 162 | 在声明一个轮次完成并开始下一个轮次之前的总步数（样品批次）。使用 163 | TensorFlow 数据张量等输入张量进行训练时，默认值 \texttt{None} 164 | 等于数据集中样本的数量除以 batch 的大小，如果无法确定，则为 1。 165 | \item 166 | \textbf{validation\_steps}: 只有在指定了 167 | \texttt{steps\_per\_epoch}时才有用。停止前要验证的总步数（批次样本）。 168 | \end{itemize} 169 | 170 | \textbf{返回} 171 | 172 | 一个 \texttt{History} 对象。其 \texttt{History.history} 属性是连续 epoch 173 | 训练损失和评估值，以及验证集损失和评估值的记录（如果适用）​​。 174 | 175 | \textbf{异常} 176 | 177 | \begin{itemize} 178 | \tightlist 179 | \item 180 | \textbf{RuntimeError}: 如果模型从未编译。 181 | \item 182 | \textbf{ValueError}: 在提供的输入数据与模型期望的不匹配的情况下。 183 | \end{itemize} 184 | 185 | 186 | 187 | \subsubsubsection{evaluate}\label{evaluate} 188 | 189 | \begin{Shaded} 190 | \begin{Highlighting}[] 191 | \NormalTok{evaluate(}\VariableTok{self}\NormalTok{, x}\OperatorTok{=}\VariableTok{None}\NormalTok{, y}\OperatorTok{=}\VariableTok{None}\NormalTok{, batch_size}\OperatorTok{=}\VariableTok{None}\NormalTok{, verbose}\OperatorTok{=}\DecValTok{1}\NormalTok{, sample_weight}\OperatorTok{=}\VariableTok{None}, \\ 192 | \hspace{2cm}\NormalTok{steps}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 193 | \end{Highlighting} 194 | \end{Shaded} 195 | 196 | 计算一些输入数据的误差，逐批次。 197 | 198 | \textbf{参数} 199 | 200 | \begin{itemize} 201 | \tightlist 202 | \item 203 | \textbf{x}: 输入数据，Numpy 数组或列表（如果模型有多输入）。 204 | 如果从本地框架张量馈送（例如 TensorFlow 数据张量）数据，x 可以是 205 | \texttt{None}（默认）。 206 | \item 207 | \textbf{y}: 标签，Numpy 数组。 如果从本地框架张量馈送（例如 TensorFlow 208 | 数据张量）数据，y 可以是 \texttt{None}（默认）。 209 | \item 210 | \textbf{batch\_size}: 整数。每次梯度更新的样本数。如果未指定，默认为 211 | 32。 212 | \item 213 | \textbf{verbose}: 日志显示模式，0 或 1。 214 | \item 215 | \textbf{sample\_weight}: 样本权重，Numpy 数组。 216 | \item 217 | \textbf{steps}: 整数或 \texttt{None}。 218 | 声明评估结束之前的总步数（批次样本）。默认值 \texttt{None}。 219 | \end{itemize} 220 | 221 | \textbf{返回} 222 | 223 | 标量测试误差（如果模型没有评估指标）或标量列表（如果模型计算其他指标）。 224 | 属性 \texttt{model.metrics\_names} 将提供标量输出的显示标签。 225 | 226 | \textbf{异常} 227 | 228 | \begin{itemize} 229 | \tightlist 230 | \item 231 | \textbf{RuntimeError}: 如果模型从未编译。 232 | \end{itemize} 233 | 234 | 235 | 236 | \subsubsubsection{predict}\label{predict} 237 | 238 | \begin{Shaded} 239 | \begin{Highlighting}[] 240 | \NormalTok{predict(}\VariableTok{self}\NormalTok{, x, batch_size}\OperatorTok{=}\VariableTok{None}\NormalTok{, verbose}\OperatorTok{=}\DecValTok{0}\NormalTok{, steps}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 241 | \end{Highlighting} 242 | \end{Shaded} 243 | 244 | 为输入样本生成输出预测。 245 | 246 | 输入样本逐批处理。 247 | 248 | \textbf{参数} 249 | 250 | \begin{itemize} 251 | \tightlist 252 | \item 253 | \textbf{x}: 输入数据，Numpy 数组。 254 | \item 255 | \textbf{batch\_size}: 整数。如未指定，默认为 32。 256 | \item 257 | \textbf{verbose}: 日志显示模式，0 或 1。 258 | \item 259 | \textbf{steps}: 声明预测结束之前的总步数（批次样本）。默认值 260 | \texttt{None}。 261 | \end{itemize} 262 | 263 | \textbf{返回} 264 | 265 | 预测的 Numpy 数组。 266 | 267 | 268 | 269 | \subsubsubsection{train\_on\_batch}\label{trainux5fonux5fbatch} 270 | 271 | \begin{Shaded} 272 | \begin{Highlighting}[] 273 | \NormalTok{train_on_batch(}\VariableTok{self}\NormalTok{, x, y, class_weight}\OperatorTok{=}\VariableTok{None}\NormalTok{, sample_weight}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 274 | \end{Highlighting} 275 | \end{Shaded} 276 | 277 | 一批样品的单次梯度更新。 278 | 279 | \textbf{Arguments} 280 | 281 | \begin{itemize} 282 | \tightlist 283 | \item 284 | \textbf{x}: 输入数据，Numpy 数组或列表（如果模型有多输入）。 285 | \item 286 | \textbf{y}: 标签，Numpy 数组。 287 | \item 288 | \textbf{class\_weight}: 289 | 将类别映射为权重的字典，用于在训练时缩放损失函数。 290 | \item 291 | \textbf{sample\_weight}: 样本权重，Numpy 数组。 292 | \end{itemize} 293 | 294 | \textbf{返回} 295 | 296 | 标量训练误差（如果模型没有评估指标）或标量列表（如果模型计算其他指标）。 297 | 属性 \texttt{model.metrics\_names} 将提供标量输出的显示标签。 298 | 299 | \textbf{异常} 300 | 301 | \begin{itemize} 302 | \tightlist 303 | \item 304 | \textbf{RuntimeError}: 如果模型从未编译。 305 | \end{itemize} 306 | 307 | 308 | 309 | \subsubsubsection{test\_on\_batch}\label{testux5fonux5fbatch} 310 | 311 | \begin{Shaded} 312 | \begin{Highlighting}[] 313 | \NormalTok{test_on_batch(}\VariableTok{self}\NormalTok{, x, y, sample_weight}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 314 | \end{Highlighting} 315 | \end{Shaded} 316 | 317 | 在一批样本上评估模型。 318 | 319 | \textbf{参数} 320 | 321 | \begin{itemize} 322 | \tightlist 323 | \item 324 | \textbf{x}: 输入数据，Numpy 数组或列表（如果模型有多输入）。 325 | \item 326 | \textbf{y}: 标签，Numpy 数组。 327 | \item 328 | \textbf{sample\_weight}: 样本权重，Numpy 数组。 329 | \end{itemize} 330 | 331 | \textbf{返回} 332 | 333 | 标量测试误差（如果模型没有评估指标）或标量列表（如果模型计算其他指标）。 334 | 属性 \texttt{model.metrics\_names} 将提供标量输出的显示标签。 335 | 336 | \textbf{异常} 337 | 338 | \begin{itemize} 339 | \tightlist 340 | \item 341 | \textbf{RuntimeError}: 如果模型从未编译。 342 | \end{itemize} 343 | 344 | 345 | 346 | \subsubsubsection{predict\_on\_batch}\label{predictux5fonux5fbatch} 347 | 348 | \begin{Shaded} 349 | \begin{Highlighting}[] 350 | \NormalTok{predict_on_batch(}\VariableTok{self}\NormalTok{, x)} 351 | \end{Highlighting} 352 | \end{Shaded} 353 | 354 | 返回一批样本的模型预测值。 355 | 356 | \textbf{参数} 357 | 358 | \begin{itemize} 359 | \tightlist 360 | \item 361 | \textbf{x}: 输入数据，Numpy 数组或列表（如果模型有多输入）。 362 | \end{itemize} 363 | 364 | \textbf{返回} 365 | 366 | 预测值的 Numpy 数组。 367 | 368 | 369 | 370 | \subsubsubsection{fit\_generator}\label{fitux5fgenerator} 371 | 372 | \begin{Shaded} 373 | \begin{Highlighting}[] 374 | \NormalTok{fit_generator(}\VariableTok{self}\NormalTok{, generator, steps_per_epoch}\OperatorTok{=}\VariableTok{None}\NormalTok{, epochs}\OperatorTok{=}\DecValTok{1}\NormalTok{, verbose}\OperatorTok{=}\DecValTok{1}, \\ 375 | \hspace{1cm}\NormalTok{callbacks}\OperatorTok{=}\VariableTok{None}\NormalTok{, validation_data}\OperatorTok{=}\VariableTok{None}\NormalTok{, validation_steps}\OperatorTok{=}\VariableTok{None}\NormalTok{, class_weight}\OperatorTok{=}\VariableTok{None}, \\ 376 | \hspace{1cm}\NormalTok{max_queue_size}\OperatorTok{=}\DecValTok{10}\NormalTok{, workers}\OperatorTok{=}\DecValTok{1}\NormalTok{, use_multiprocessing}\OperatorTok{=}\VariableTok{False}\NormalTok{, shuffle}\OperatorTok{=}\VariableTok{True}, \\ 377 | \hspace{1cm}\NormalTok{initial_epoch}\OperatorTok{=}\DecValTok{0}\NormalTok{)} 378 | \end{Highlighting} 379 | \end{Shaded} 380 | 381 | 使用 Python 生成器逐批生成的数据，按批次训练模型。 382 | 383 | 生成器与模型并行运行，以提高效率。 例如，这可以让你在 CPU 384 | 上对图像进行实时数据增强，以在 GPU 上训练模型。 385 | 386 | \textbf{参数} 387 | 388 | \begin{itemize} 389 | \tightlist 390 | \item 391 | \textbf{generator}: 一个生成器。 生成器的输出应该为以下之一： 392 | \item 393 | 一个 (inputs, targets) 元组 394 | \item 395 | 一个 (inputs, targets, sample\_weights) 元组。 396 | 所有的数组都必须包含同样数量的样本。生成器将无限地在数据集上循环。当运行到第 397 | \texttt{steps\_per\_epoch} 时，记一个 epoch 结束。 398 | \item 399 | \textbf{steps\_per\_epoch}: 在声明一个 epoch 完成并开始下一个 epoch 400 | 之前从 \texttt{generator} 401 | 产生的总步数（批次样本）。它通常应该等于你的数据集的样本数量除以批量大小。可选参数 402 | \texttt{Sequence}：如果未指定，将使用\texttt{len(generator)} 403 | 作为步数。 404 | \item 405 | \textbf{epochs}: 整数，数据的迭代总轮数。请注意，与 initial\_epoch 406 | 一起，参数 \texttt{epochs} 应被理解为 「最终轮数」。模型并不是训练了 407 | \texttt{epochs} 轮，而是到第 \texttt{epochs} 轮停止训练。 408 | \item 409 | \textbf{verbose}: 日志显示模式。0，1 或 2。 410 | \item 411 | \textbf{callbacks}: 在训练时调用的一系列回调函数。 412 | \item 413 | \textbf{validation\_data}: 它可以是以下之一： 414 | \item 415 | 验证数据的生成器 416 | \item 417 | 一个 (inputs, targets) 元组 418 | \item 419 | 一个 (inputs, targets, sample\_weights) 元组。 420 | \item 421 | \textbf{validation\_steps}: 仅当 \texttt{validation\_data} 422 | 是一个生成器时才可用。 每个 epoch 423 | 结束时验证集生成器产生的步数。它通常应该等于你的数据集的样本数量除以批量大小。可选参数 424 | \texttt{Sequence}：如果未指定，将使用\texttt{len(generator)} 425 | 作为步数。 426 | \item 427 | \textbf{class\_weight}: 将类别映射为权重的字典。 428 | \item 429 | \textbf{max\_queue\_size}: 生成器队列的最大尺寸。 430 | \item 431 | \textbf{workers}: 使用的最大进程数量。 432 | \item 433 | \textbf{use\_multiprocessing}: 如果 True，则使用基于进程的多线程。 434 | 请注意，因为此实现依赖于多进程，所以不应将不可传递的参数传递给生成器，因为它们不能被轻易地传递给子进程。 435 | \item 436 | \textbf{shuffle}: 是否在每轮迭代之前打乱 batch 的顺序。只能与 437 | \texttt{Sequence} (keras.utils.Sequence) 实例同用。 438 | \item 439 | \textbf{initial\_epoch}: 开始训练的轮次（有助于恢复之前的训练）。 440 | \end{itemize} 441 | 442 | \textbf{返回} 443 | 444 | 一个 \texttt{History} 对象。 445 | 446 | \textbf{异常} 447 | 448 | \begin{itemize} 449 | \tightlist 450 | \item 451 | \textbf{RuntimeError}: 如果模型从未编译。 452 | \end{itemize} 453 | 454 | \textbf{例} 455 | 456 | \begin{Shaded} 457 | \begin{Highlighting}[] 458 | \KeywordTok{def} \NormalTok{generate_arrays_from_file(path):} 459 | \ControlFlowTok{while} \DecValTok{1}\NormalTok{:} 460 | \NormalTok{f }\OperatorTok{=} \BuiltInTok{open}\NormalTok{(path)} 461 | \ControlFlowTok{for} \NormalTok{line }\OperatorTok{in} \NormalTok{f:} 462 | \CommentTok{# create Numpy arrays of input data} 463 | \CommentTok{# and labels, from each line in the file} 464 | \NormalTok{x, y }\OperatorTok{=} \NormalTok{process_line(line)} 465 | \ControlFlowTok{yield} \NormalTok{(x, y)} 466 | \NormalTok{f.close()} 467 | 468 | \NormalTok{model.fit_generator(generate_arrays_from_file(}\StringTok{'/my_file.txt'}\NormalTok{),} 469 | \NormalTok{steps_per_epoch}\OperatorTok{=}\DecValTok{1000}\NormalTok{, epochs}\OperatorTok{=}\DecValTok{10}\NormalTok{)} 470 | \end{Highlighting} 471 | \end{Shaded} 472 | 473 | 474 | 475 | \subsubsubsection{evaluate\_generator}\label{evaluateux5fgenerator} 476 | 477 | \begin{Shaded} 478 | \begin{Highlighting}[] 479 | \NormalTok{evaluate_generator(}\VariableTok{self}\NormalTok{, generator, steps}\OperatorTok{=}\VariableTok{None}\NormalTok{, max_queue_size}\OperatorTok{=}\DecValTok{10}\NormalTok{, workers}\OperatorTok{=}\DecValTok{1}, \\ 480 | \hspace{4cm}\NormalTok{use_multiprocessing}\OperatorTok{=}\VariableTok{False}\NormalTok{)} 481 | \end{Highlighting} 482 | \end{Shaded} 483 | 484 | 在数据生成器上评估模型。 485 | 486 | 这个生成器应该返回与 \texttt{test\_on\_batch} 所接收的同样的数据。 487 | 488 | \textbf{参数} 489 | 490 | \begin{itemize} 491 | \tightlist 492 | \item 493 | \textbf{generator}: 生成器，生成 (inputs, targets) 或 (inputs, 494 | targets, sample\_weights) 495 | \item 496 | \textbf{steps}: 在停止之前，来自 \texttt{generator} 的总步数 497 | (样本批次)。 可选参数 498 | \texttt{Sequence}：如果未指定，将使用\texttt{len(generator)} 499 | 作为步数。 500 | \item 501 | \textbf{max\_queue\_size}: 生成器队列的最大尺寸。 502 | \item 503 | \textbf{workers}: 使用的最大进程数量。 504 | \item 505 | \textbf{use\_multiprocessing}: 如果 True，则使用基于进程的多线程。 506 | 请注意，因为此实现依赖于多进程，所以不应将不可传递的参数传递给生成器，因为它们不能被轻易地传递给子进程。 507 | \end{itemize} 508 | 509 | \textbf{返回} 510 | 511 | 标量测试误差（如果模型没有评估指标）或标量列表（如果模型计算其他指标）。 512 | 属性 \texttt{model.metrics\_names} 将提供标量输出的显示标签。 513 | 514 | \textbf{异常} 515 | 516 | \begin{itemize} 517 | \tightlist 518 | \item 519 | \textbf{RuntimeError}: 如果模型从未编译。 520 | \end{itemize} 521 | 522 | 523 | 524 | \subsubsubsection{predict\_generator}\label{predictux5fgenerator} 525 | 526 | \begin{Shaded} 527 | \begin{Highlighting}[] 528 | \NormalTok{predict_generator(}\VariableTok{self}\NormalTok{, generator, steps}\OperatorTok{=}\VariableTok{None}\NormalTok{, max_queue_size}\OperatorTok{=}\DecValTok{10}\NormalTok{, workers}\OperatorTok{=}\DecValTok{1}, \\ 529 | \hspace{4cm}\NormalTok{use_multiprocessing}\OperatorTok{=}\VariableTok{False}\NormalTok{, verbose}\OperatorTok{=}\DecValTok{0}\NormalTok{)} 530 | \end{Highlighting} 531 | \end{Shaded} 532 | 533 | 为来自数据生成器的输入样本生成预测。 534 | 535 | 这个生成器应该返回与 \texttt{predict\_on\_batch} 所接收的同样的数据。 536 | 537 | \textbf{参数} 538 | 539 | \begin{itemize} 540 | \tightlist 541 | \item 542 | \textbf{generator}: 返回批量输入样本的生成器。 543 | \item 544 | \textbf{steps}: 在停止之前，来自 \texttt{generator} 的总步数 545 | (样本批次)。 可选参数 546 | \texttt{Sequence}：如果未指定，将使用\texttt{len(generator)} 547 | 作为步数。 548 | \item 549 | \textbf{max\_queue\_size}: 生成器队列的最大尺寸。 550 | \item 551 | \textbf{workers}: 使用的最大进程数量。 552 | \item 553 | \textbf{use\_multiprocessing}: 如果 True，则使用基于进程的多线程。 554 | 请注意，因为此实现依赖于多进程，所以不应将不可传递的参数传递给生成器，因为它们不能被轻易地传递给子进程。 555 | \item 556 | \textbf{verbose}: 日志显示模式， 0 或 1。 557 | \end{itemize} 558 | 559 | \textbf{返回} 560 | 561 | 预测值的 Numpy 数组。 562 | 563 | 564 | 565 | \subsubsubsection{get\_layer}\label{getux5flayer} 566 | 567 | \begin{Shaded} 568 | \begin{Highlighting}[] 569 | \NormalTok{get_layer(}\VariableTok{self}\NormalTok{, name}\OperatorTok{=}\VariableTok{None}\NormalTok{, index}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 570 | \end{Highlighting} 571 | \end{Shaded} 572 | 573 | 提取模型的某一层。 574 | 575 | 根据网络层的名称（唯一）或其索引返回该层。索引是基于水平图遍历的顺序（自下而上）。 576 | 577 | \textbf{参数} 578 | 579 | \begin{itemize} 580 | \tightlist 581 | \item 582 | \textbf{name}: 字符串，层的名字。 583 | \item 584 | \textbf{index}: 整数，层的索引。 585 | \end{itemize} 586 | 587 | \textbf{返回} 588 | 589 | 一个层实例。 590 | \newpage 591 | -------------------------------------------------------------------------------- /chapter/4-10_normalization.tex: -------------------------------------------------------------------------------- 1 | \subsection{标准化层 Normalization} 2 | 3 | \subsubsection{BatchNormalization {\href{https://github.com/keras-team/keras/blob/master/keras/layers/normalization.py\#L16}{{[}source{]}}}} 4 | 5 | \begin{Shaded} 6 | \begin{Highlighting}[] 7 | \NormalTok{keras.layers.BatchNormalization(axis}\OperatorTok{=-}\DecValTok{1}\NormalTok{, momentum}\OperatorTok{=}\FloatTok{0.99}\NormalTok{, epsilon}\OperatorTok{=}\FloatTok{0.001}, \\ 8 | \hspace{3cm}\NormalTok{center}\OperatorTok{=}\VariableTok{True}\NormalTok{, scale}\OperatorTok{=}\VariableTok{True}\NormalTok{, beta_initializer}\OperatorTok{=}\StringTok{'zeros'}, \\ 9 | \hspace{3cm}\NormalTok{gamma_initializer}\OperatorTok{=}\StringTok{'ones'}\NormalTok{, moving_mean_initializer}\OperatorTok{=}\StringTok{'zeros'}, \\ 10 | \hspace{3cm}\NormalTok{moving_variance_initializer}\OperatorTok{=}\StringTok{'ones'}\NormalTok{, beta_regularizer}\OperatorTok{=}\VariableTok{None}, \\ 11 | \hspace{3cm}\NormalTok{gamma_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, beta_constraint}\OperatorTok{=}\VariableTok{None}, \\ 12 | \hspace{3cm}\NormalTok{gamma_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 13 | \end{Highlighting} 14 | \end{Shaded} 15 | 16 | 批量标准化层 (Ioffe and Szegedy, 2014)。 17 | 18 | 在每一个批次的数据中标准化前一层的激活项， 19 | 即，应用一个维持激活项平均值接近 0，标准差接近 1 的转换。 20 | 21 | \textbf{参数} 22 | 23 | \begin{itemize} 24 | \tightlist 25 | \item 26 | \textbf{axis}: 整数，需要标准化的轴 （通常是特征轴）。 例如，在 27 | \texttt{data\_format="channels\_first"} 的 \texttt{Conv2D} 层之后， 在 28 | \texttt{BatchNormalization} 中设置 \texttt{axis=1}。 29 | \item 30 | \textbf{momentum}: 移动均值和移动方差的动量。 31 | \item 32 | \textbf{epsilon}: 增加到方差的小的浮点数，以避免除以零。 33 | \item 34 | \textbf{center}: 如果为 True，把 \texttt{beta} 35 | 的偏移量加到标准化的张量上。 如果为 False， \texttt{beta} 被忽略。 36 | \item 37 | \textbf{scale}: 如果为 True，乘以 \texttt{gamma}。 如果为 38 | False，\texttt{gamma} 不使用。 当下一层为线性层（或者例如 39 | \texttt{nn.relu}）， 这可以被禁用，因为缩放将由下一层完成。 40 | \item 41 | \textbf{beta\_initializer}: beta 权重的初始化方法。 42 | \item 43 | \textbf{gamma\_initializer}: gamma 权重的初始化方法。 44 | \item 45 | \textbf{moving\_mean\_initializer}: 移动均值的初始化方法。 46 | \item 47 | \textbf{moving\_variance\_initializer}: 移动方差的初始化方法。 48 | \item 49 | \textbf{beta\_regularizer}: 可选的 beta 权重的正则化方法。 50 | \item 51 | \textbf{gamma\_regularizer}: 可选的 gamma 权重的正则化方法。 52 | \item 53 | \textbf{beta\_constraint}: 可选的 beta 权重的约束方法。 54 | \item 55 | \textbf{gamma\_constraint}: 可选的 gamma 权重的约束方法。 56 | \end{itemize} 57 | 58 | \textbf{输入尺寸} 59 | 60 | 可以是任意的。如果将这一层作为模型的第一层， 则需要指定 input\_shape 61 | 参数 （整数元组，不包含样本数量的维度）。 62 | 63 | \textbf{输出尺寸} 64 | 65 | 与输入相同。 66 | 67 | \textbf{参考文献} 68 | 69 | \begin{itemize} 70 | \tightlist 71 | \item 72 | \href{https://arxiv.org/abs/1502.03167}{Batch Normalization: 73 | Accelerating Deep Network Training by Reducing Internal Covariate 74 | Shift} 75 | \end{itemize} 76 | \newpage 77 | -------------------------------------------------------------------------------- /chapter/4-11_noise.tex: -------------------------------------------------------------------------------- 1 | \subsection{噪声层 Noise} 2 | 3 | \subsubsection{GaussianNoise {\href{https://github.com/keras-team/keras/blob/master/keras/layers/noise.py\#L14}{{[}source{]}}}} 4 | 5 | \begin{Shaded} 6 | \begin{Highlighting}[] 7 | \NormalTok{keras.layers.GaussianNoise(stddev)} 8 | \end{Highlighting} 9 | \end{Shaded} 10 | 11 | 应用以 0 为中心的加性高斯噪声。 12 | 13 | 这对缓解过拟合很有用 （你可以将其视为随机数据增强的一种形式）。 14 | 高斯噪声（GS）是对真实输入的腐蚀过程的自然选择。 15 | 16 | 由于它是一个正则化层，因此它只在训练时才被激活。 17 | 18 | \textbf{参数} 19 | 20 | \begin{itemize} 21 | \tightlist 22 | \item 23 | \textbf{stddev}: float，噪声分布的标准差。 24 | \end{itemize} 25 | 26 | \textbf{输入尺寸} 27 | 28 | 可以是任意的。 如果将该层作为模型的第一层，则需要指定 29 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 30 | 31 | \textbf{输出尺寸} 32 | 33 | 与输入相同。 34 | 35 | 36 | 37 | 38 | \subsubsection{GaussianDropout {\href{https://github.com/keras-team/keras/blob/master/keras/layers/noise.py\#L58}{{[}source{]}}}} 39 | 40 | \begin{Shaded} 41 | \begin{Highlighting}[] 42 | \NormalTok{keras.layers.GaussianDropout(rate)} 43 | \end{Highlighting} 44 | \end{Shaded} 45 | 46 | 应用以 1 为中心的 乘性高斯噪声。 47 | 48 | 由于它是一个正则化层，因此它只在训练时才被激活。 49 | 50 | \textbf{参数} 51 | 52 | \begin{itemize} 53 | \tightlist 54 | \item 55 | \textbf{rate}: float，丢弃概率（与 \texttt{Dropout} 相同）。 56 | 这个乘性噪声的标准差为 \texttt{sqrt(rate\ /\ (1\ -\ rate))}。 57 | \end{itemize} 58 | 59 | \textbf{输入尺寸} 60 | 61 | 可以是任意的。 如果将该层作为模型的第一层，则需要指定 62 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 63 | 64 | \textbf{输出尺寸} 65 | 66 | 与输入相同。 67 | 68 | \textbf{参考文献} 69 | 70 | \begin{itemize} 71 | \tightlist 72 | \item 73 | \href{http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf}{Dropout: 74 | A Simple Way to Prevent Neural Networks from Overfitting Srivastava, 75 | Hinton, et al. 2014} 76 | \end{itemize} 77 | 78 | 79 | 80 | 81 | \subsubsection{AlphaDropout {\href{https://github.com/keras-team/keras/blob/master/keras/layers/noise.py\#L105}{{[}source{]}}}} 82 | 83 | \begin{Shaded} 84 | \begin{Highlighting}[] 85 | \NormalTok{keras.layers.AlphaDropout(rate, noise_shape}\OperatorTok{=}\VariableTok{None}\NormalTok{, seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 86 | \end{Highlighting} 87 | \end{Shaded} 88 | 89 | 将 Alpha Dropout 应用到输入。 90 | 91 | Alpha Dropout是一种 92 | \texttt{Dropout}，它保持输入的平均值和方差与原来的值不变， 已在 dropout 93 | 之后仍然保证数据的自规范性。 通过随机将激活设置为负饱和值，Alpha Dropout 94 | 非常适合按比例缩放的指数线性单元（SELU）。 95 | 96 | \textbf{参数} 97 | 98 | \begin{itemize} 99 | \tightlist 100 | \item 101 | \textbf{rate}: float，丢弃概率（与 \texttt{Dropout} 相同）。 102 | 这个乘性噪声的标准差为 \texttt{sqrt(rate\ /\ (1\ -\ rate))}。 103 | \item 104 | \textbf{seed}: 用作随机种子的 Python 整数。 105 | \end{itemize} 106 | 107 | \textbf{输入尺寸} 108 | 109 | 可以是任意的。 如果将该层作为模型的第一层，则需要指定 110 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 111 | 112 | \textbf{输出尺寸} 113 | 114 | 与输入相同。 115 | 116 | \textbf{参考文献} 117 | 118 | \begin{itemize} 119 | \tightlist 120 | \item 121 | \href{https://arxiv.org/abs/1706.02515}{Self-Normalizing Neural 122 | Networks} 123 | \end{itemize} 124 | \newpage -------------------------------------------------------------------------------- /chapter/4-12_wrappers.tex: -------------------------------------------------------------------------------- 1 | 2 | \subsection{层封装器 wrappers } 3 | \subsubsection{TimeDistributed {\href{https://github.com/keras-team/keras/blob/master/keras/layers/wrappers.py\#L104}{{[}source{]}}}} 4 | 5 | \begin{Shaded} 6 | \begin{Highlighting}[] 7 | \NormalTok{keras.layers.TimeDistributed(layer)} 8 | \end{Highlighting} 9 | \end{Shaded} 10 | 11 | 这个封装器将一个层应用于输入的每个时间片。 12 | 13 | 输入至少为 3D，且第一个维度应该是时间所表示的维度。 14 | 15 | 考虑 32 个样本的一个 batch， 其中每个样本是 10 个 16 维向量的序列。 16 | 那么这个 batch 的输入尺寸为 \texttt{(32,\ 10,\ 16)}， 而 17 | \texttt{input\_shape} 不包含样本数量的维度，为 \texttt{(10,\ 16)}。 18 | 19 | 你可以使用 \texttt{TimeDistributed} 来将 \texttt{Dense} 层独立地应用到 20 | 这 10 个时间步的每一个： 21 | 22 | \begin{Shaded} 23 | \begin{Highlighting}[] 24 | \CommentTok{# 作为模型第一层} 25 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 26 | \NormalTok{model.add(TimeDistributed(Dense(}\DecValTok{8}\NormalTok{), input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{10}\NormalTok{, }\DecValTok{16}\NormalTok{)))} 27 | \CommentTok{# 现在 model.output_shape == (None, 10, 8)} 28 | \end{Highlighting} 29 | \end{Shaded} 30 | 31 | 输出的尺寸为 \texttt{(32,\ 10,\ 8)}。 32 | 33 | 在后续的层中，将不再需要 \texttt{input\_shape}： 34 | 35 | \begin{Shaded} 36 | \begin{Highlighting}[] 37 | \NormalTok{model.add(TimeDistributed(Dense(}\DecValTok{32}\NormalTok{)))} 38 | \CommentTok{# 现在 model.output_shape == (None, 10, 32)} 39 | \end{Highlighting} 40 | \end{Shaded} 41 | 42 | 输出的尺寸为 \texttt{(32,\ 10,\ 32)}。 43 | 44 | \texttt{TimeDistributed} 可以应用于任意层，不仅仅是 \texttt{Dense}， 45 | 例如运用于 \texttt{Conv2D} 层： 46 | 47 | \begin{Shaded} 48 | \begin{Highlighting}[] 49 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 50 | \NormalTok{model.add(TimeDistributed(Conv2D(}\DecValTok{64}\NormalTok{, (}\DecValTok{3}\NormalTok{, }\DecValTok{3}\NormalTok{)),} 51 | \NormalTok{input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{10}\NormalTok{, }\DecValTok{299}\NormalTok{, }\DecValTok{299}\NormalTok{, }\DecValTok{3}\NormalTok{)))} 52 | \end{Highlighting} 53 | \end{Shaded} 54 | 55 | \textbf{参数} 56 | 57 | \begin{itemize} 58 | \tightlist 59 | \item 60 | \textbf{layer}: 一个网络层实例。 61 | \end{itemize} 62 | 63 | 64 | 65 | \subsubsection{Bidirectional {\href{https://github.com/keras-team/keras/blob/master/keras/layers/wrappers.py\#L221}{{[}source{]}}}} 66 | 67 | \begin{Shaded} 68 | \begin{Highlighting}[] 69 | \NormalTok{keras.layers.Bidirectional(layer, merge_mode}\OperatorTok{=}\StringTok{'concat'}\NormalTok{, weights}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 70 | \end{Highlighting} 71 | \end{Shaded} 72 | 73 | RNN 的双向封装器，对序列进行前向和后向计算。 74 | 75 | \textbf{参数} 76 | 77 | \begin{itemize} 78 | \tightlist 79 | \item 80 | \textbf{layer}: \texttt{Recurrent} 实例。 81 | \item 82 | \textbf{merge\_mode}: 前向和后向 RNN 的输出的结合模式。 为 \{'sum', 83 | 'mul', 'concat', 'ave', None\} 其中之一。 如果是 84 | None，输出不会被结合，而是作为一个列表被返回。 85 | \end{itemize} 86 | 87 | \textbf{异常} 88 | 89 | \begin{itemize} 90 | \tightlist 91 | \item 92 | \textbf{ValueError}: 如果参数 \texttt{merge\_mode} 非法。 93 | \end{itemize} 94 | 95 | \textbf{例} 96 | 97 | \begin{Shaded} 98 | \begin{Highlighting}[] 99 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 100 | \NormalTok{model.add(Bidirectional(LSTM(}\DecValTok{10}\NormalTok{, return_sequences}\OperatorTok{=}\VariableTok{True}\NormalTok{),} 101 | \NormalTok{input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{5}\NormalTok{, }\DecValTok{10}\NormalTok{)))} 102 | \NormalTok{model.add(Bidirectional(LSTM(}\DecValTok{10}\NormalTok{)))} 103 | \NormalTok{model.add(Dense(}\DecValTok{5}\NormalTok{))} 104 | \NormalTok{model.add(Activation(}\StringTok{'softmax'}\NormalTok{))} 105 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'categorical_crossentropy'}\NormalTok{, optimizer}\OperatorTok{=}\StringTok{'rmsprop'}\NormalTok{)} 106 | \end{Highlighting} 107 | \end{Shaded} 108 | 109 | \newpage -------------------------------------------------------------------------------- /chapter/4-13_writing-your-own-keras-layers.tex: -------------------------------------------------------------------------------- 1 | 2 | \subsection{编写你自己的Keras层}\label{ux7f16ux5199ux4f60ux81eaux5df1ux7684kerasux5c42} 3 | 4 | 对于简单、无状态的自定义操作，你也许可以通过\texttt{layers.core.Lambda}层来实现。但是对于那些包含了可训练权重的自定义层，你应该自己实现这种层。 5 | 6 | 这是一个\textbf{Keras2.0}中，Keras层的骨架（如果你用的是旧的版本，请你更新）。你只需要实现三个方法即可: 7 | 8 | \begin{itemize} 9 | \tightlist 10 | \item 11 | \texttt{build(input\_shape)}: 12 | 这是你定义权重的地方。这个方法必须设\texttt{self.built\ =\ True}，可以通过调用\texttt{super({[}Layer{]},\ self).build()}完成。 13 | \item 14 | \texttt{call(x)}: 15 | 这里是编写层的功能逻辑的地方。你只需要关注传入\texttt{call}的第一个参数：输入张量，除非你希望你的层支持masking。 16 | \item 17 | \texttt{compute\_output\_shape(input\_shape)}: 18 | 如果你的层更改了输入张量的形状，你应该在这里定义形状变化的逻辑，这让Keras能够自动推断各层的形状。 19 | \end{itemize} 20 | 21 | \begin{Shaded} 22 | \begin{Highlighting}[] 23 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{backend }\ImportTok{as} \NormalTok{K} 24 | \ImportTok{from} \NormalTok{keras.engine.topology }\ImportTok{import} \NormalTok{Layer} 25 | \ImportTok{import} \NormalTok{numpy }\ImportTok{as} \NormalTok{np} 26 | 27 | \KeywordTok{class} \NormalTok{MyLayer(Layer):} 28 | 29 | \KeywordTok{def} \FunctionTok{__init__}\NormalTok{(}\VariableTok{self}\NormalTok{, output_dim, }\OperatorTok{**}\NormalTok{kwargs):} 30 | \VariableTok{self}\NormalTok{.output_dim }\OperatorTok{=} \NormalTok{output_dim} 31 | \BuiltInTok{super}\NormalTok{(MyLayer, }\VariableTok{self}\NormalTok{).}\FunctionTok{__init__}\NormalTok{(}\OperatorTok{**}\NormalTok{kwargs)} 32 | 33 | \KeywordTok{def} \NormalTok{build(}\VariableTok{self}\NormalTok{, input_shape):} 34 | \CommentTok{# Create a trainable weight variable for this layer.} 35 | \VariableTok{self}\NormalTok{.kernel }\OperatorTok{=} \VariableTok{self}\NormalTok{.add_weight(name}\OperatorTok{=}\StringTok{'kernel'}\NormalTok{, } 36 | \NormalTok{shape}\OperatorTok{=}\NormalTok{(input_shape[}\DecValTok{1}\NormalTok{], }\VariableTok{self}\NormalTok{.output_dim),} 37 | \NormalTok{initializer}\OperatorTok{=}\StringTok{'uniform'}\NormalTok{,} 38 | \NormalTok{trainable}\OperatorTok{=}\VariableTok{True}\NormalTok{)} 39 | \BuiltInTok{super}\NormalTok{(MyLayer, }\VariableTok{self}\NormalTok{).build(input_shape) }\CommentTok{# Be sure to call this somewhere!} 40 | 41 | \KeywordTok{def} \NormalTok{call(}\VariableTok{self}\NormalTok{, x):} 42 | \ControlFlowTok{return} \NormalTok{K.dot(x, }\VariableTok{self}\NormalTok{.kernel)} 43 | 44 | \KeywordTok{def} \NormalTok{compute_output_shape(}\VariableTok{self}\NormalTok{, input_shape):} 45 | \ControlFlowTok{return} \NormalTok{(input_shape[}\DecValTok{0}\NormalTok{], }\VariableTok{self}\NormalTok{.output_dim)} 46 | \end{Highlighting} 47 | \end{Shaded} 48 | 49 | 已有的Keras层就是实现层的很好例子。不要犹豫阅读源码！ 50 | 51 | 52 | \newpage -------------------------------------------------------------------------------- /chapter/4-1_about-keras-layers.tex: -------------------------------------------------------------------------------- 1 | \section{关于 Keras 网络层}\label{ux5173ux4e8ekerasux5c42} 2 | \subsection{关于Keras层} 3 | 所有Keras层都有很多共同的函数： 4 | 5 | \begin{itemize} 6 | \tightlist 7 | \item 8 | \texttt{layer.get\_weights()}: 以含有Numpy矩阵的列表形式返回层的权重。 9 | \item 10 | \texttt{layer.set\_weights(weights)}: 11 | 从含有Numpy矩阵的列表中设置层的权重（与\texttt{get\_weights}的输出形状相同）。 12 | \item 13 | \texttt{layer.get\_config()}: 14 | 返回包含层配置的字典。此图层可以通过以下方式重置： 15 | \end{itemize} 16 | 17 | \begin{Shaded} 18 | \begin{Highlighting}[] 19 | \NormalTok{layer }\OperatorTok{=} \NormalTok{Dense(}\DecValTok{32}\NormalTok{)} 20 | \NormalTok{config }\OperatorTok{=} \NormalTok{layer.get_config()} 21 | \NormalTok{reconstructed_layer }\OperatorTok{=} \NormalTok{Dense.from_config(config)} 22 | \end{Highlighting} 23 | \end{Shaded} 24 | 25 | 或: 26 | 27 | \begin{Shaded} 28 | \begin{Highlighting}[] 29 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{layers} 30 | 31 | \NormalTok{config }\OperatorTok{=} \NormalTok{layer.get_config()} 32 | \NormalTok{layer }\OperatorTok{=} \NormalTok{layers.deserialize(\{}\StringTok{'class_name'}\NormalTok{: layer.__class__.}\VariableTok{__name__}\NormalTok{,} 33 | \StringTok{'config'}\NormalTok{: config\})} 34 | \end{Highlighting} 35 | \end{Shaded} 36 | 37 | 如果一个层具有单个节点 (i.e. 如果它不是共享层), 38 | 你可以得到它的输入张量，输出张量，输入尺寸和输出尺寸: 39 | 40 | \begin{itemize} 41 | \tightlist 42 | \item 43 | \texttt{layer.input} 44 | \item 45 | \texttt{layer.output} 46 | \item 47 | \texttt{layer.input\_shape} 48 | \item 49 | \texttt{layer.output\_shape} 50 | \end{itemize} 51 | 52 | 如果层有多个节点 (参见: 53 | \hyperref[the-concept-of-layer-node]{层节点和共享层的概念}), 54 | 您可以使用以下函数: 55 | 56 | \begin{itemize} 57 | \tightlist 58 | \item 59 | \texttt{layer.get\_input\_at(node\_index)} 60 | \item 61 | \texttt{layer.get\_output\_at(node\_index)} 62 | \item 63 | \texttt{layer.get\_input\_shape\_at(node\_index)} 64 | \item 65 | \texttt{layer.get\_output\_shape\_at(node\_index)} 66 | \end{itemize} 67 | \newpage 68 | -------------------------------------------------------------------------------- /chapter/4-2_core.tex: -------------------------------------------------------------------------------- 1 | \subsection{核心网络层} 2 | \subsubsection{Dense {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L743}{{[}source{]}}}} 3 | 4 | \begin{Shaded} 5 | \begin{Highlighting}[] 6 | \NormalTok{keras.layers.Dense(units, activation}\OperatorTok{=}\VariableTok{None}\NormalTok{, use_bias}\OperatorTok{=}\VariableTok{True}, \\ 7 | \hspace{3.5cm}\NormalTok{kernel_initializer}\OperatorTok{=}\StringTok{'glorot_uniform'}\NormalTok{, bias_initializer}\OperatorTok{=}\StringTok{'zeros'}, \\ 8 | \hspace{3.5cm}\NormalTok{kernel_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, bias_regularizer}\OperatorTok{=}\VariableTok{None}, \\ 9 | \hspace{3.5cm}\NormalTok{activity_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, kernel_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{, bias_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 10 | \end{Highlighting} 11 | \end{Shaded} 12 | 13 | 就是普通的全连接层。 14 | 15 | \texttt{Dense} 实现以下操作： 16 | \texttt{output\ =\ activation(dot(input,\ kernel)\ +\ bias)} 其中 17 | \texttt{activation} 是按逐个元素计算的激活函数，\texttt{kernel} 18 | 是由网络层创建的权值矩阵，以及 \texttt{bias} 是其创建的偏置向量 (只在 19 | \texttt{use\_bias} 为 \texttt{True} 时才有用)。 20 | 21 | \begin{itemize} 22 | \tightlist 23 | \item 24 | \textbf{注意}: 如果该层的输入的秩大于2，那么它首先被展平然后 再计算与 25 | \texttt{kernel} 的点乘。 26 | \end{itemize} 27 | 28 | \textbf{例} 29 | 30 | \begin{Shaded} 31 | \begin{Highlighting}[] 32 | \CommentTok{# 作为 Sequential 模型的第一层} 33 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 34 | \NormalTok{model.add(Dense(}\DecValTok{32}\NormalTok{, input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{16}\NormalTok{,)))} 35 | \CommentTok{# 现在模型就会以尺寸为 (*, 16) 的数组作为输入，} 36 | \CommentTok{# 其输出数组的尺寸为 (*, 32)} 37 | 38 | \CommentTok{# 在第一层之后，你就不再需要指定输入的尺寸了：} 39 | \NormalTok{model.add(Dense(}\DecValTok{32}\NormalTok{))} 40 | \end{Highlighting} 41 | \end{Shaded} 42 | 43 | \textbf{参数} 44 | 45 | \begin{itemize} 46 | \tightlist 47 | \item 48 | \textbf{units}: 正整数，输出空间维度。 49 | \item 50 | \textbf{activation}: 激活函数 (详见 51 | \hyperref[activations]{activations})。 若不指定，则不使用激活函数 52 | (即， ``线性''激活: \texttt{a(x)\ =\ x})。 53 | \item 54 | \textbf{use\_bias}: 布尔值，该层是否使用偏置向量。 55 | \item 56 | \textbf{kernel\_initializer}: \texttt{kernel} 权值矩阵的初始化器 (详见 57 | \hyperref[initializers]{initializers})。 58 | \item 59 | \textbf{bias\_initializer}: 偏置向量的初始化器 (see 60 | \hyperref[initializers]{initializers}). 61 | \item 62 | \textbf{kernel\_regularizer}: 运用到 \texttt{kernel} 63 | 权值矩阵的正则化函数 (详见 \hyperref[regularizers]{regularizer})。 64 | \item 65 | \textbf{bias\_regularizer}: 运用到偏置向的的正则化函数 (详见 66 | \hyperref[regularizers]{regularizer})。 67 | \item 68 | \textbf{activity\_regularizer}: 运用到层的输出的正则化函数 (它的 69 | ``activation")。 (详见 \hyperref[regularizers]{regularizer})。 70 | \item 71 | \textbf{kernel\_constraint}: 运用到 \texttt{kernel} 权值矩阵的约束函数 72 | (详见 \hyperref[constraints]{constraints})。 73 | \item 74 | \textbf{bias\_constraint}: 运用到偏置向量的约束函数 (详见 75 | \hyperref[constraints]{constraints})。 76 | \end{itemize} 77 | 78 | \textbf{输入尺寸} 79 | 80 | nD 张量，尺寸: \texttt{(batch\_size,\ ...,\ input\_dim)}。 81 | 最常见的情况是一个尺寸为 \texttt{(batch\_size,\ input\_dim)} 的 2D 82 | 输入。 83 | 84 | \textbf{输出尺寸} 85 | 86 | nD 张量，尺寸: \texttt{(batch\_size,\ ...,\ units)}。 例如，对于尺寸为 87 | \texttt{(batch\_size,\ input\_dim)} 的 2D 输入， 输出的尺寸为 88 | \texttt{(batch\_size,\ units)}。 89 | 90 | 91 | 92 | 93 | \subsubsection{Activation {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L280}{{[}source{]}}}} 94 | 95 | 96 | \begin{Shaded} 97 | \begin{Highlighting}[] 98 | \NormalTok{keras.layers.Activation(activation)} 99 | \end{Highlighting} 100 | \end{Shaded} 101 | 102 | 将激活函数应用于输出。 103 | 104 | \textbf{参数} 105 | 106 | \begin{itemize} 107 | \tightlist 108 | \item 109 | \textbf{activation}: 要使用的激活函数的名称 (详见: 110 | hyperref[activations]{activations})， 或者选择一个 Theano 或 111 | TensorFlow 操作。 112 | \end{itemize} 113 | 114 | \textbf{输入尺寸} 115 | 116 | 任意尺寸。 当使用此层作为模型中的第一层时， 使用参数 117 | \texttt{input\_shape} （整数元组，不包括样本数的轴）。 118 | 119 | \textbf{输出尺寸} 120 | 121 | 与输入相同。 122 | 123 | 124 | 125 | \subsubsection{Dropout {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L78}{{[}source{]}}}} 126 | 127 | \begin{Shaded} 128 | \begin{Highlighting}[] 129 | \NormalTok{keras.layers.Dropout(rate, noise_shape}\OperatorTok{=}\VariableTok{None}\NormalTok{, seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 130 | \end{Highlighting} 131 | \end{Shaded} 132 | 133 | 将 Dropout 应用于输入。 134 | 135 | Dropout 包括在训练中每次更新时， 将输入单元的按比率随机设置为 0， 136 | 这有助于防止过拟合。 137 | 138 | \textbf{参数} 139 | 140 | \begin{itemize} 141 | \tightlist 142 | \item 143 | \textbf{rate}: 在 0 和 1 之间浮动。需要丢弃的输入比例。 144 | \item 145 | \textbf{noise\_shape}: 1D 整数张量， 表示将与输入相乘的二进制 dropout 146 | 掩层的形状。 例如，如果你的输入尺寸为 147 | \texttt{(batch\_size,\ timesteps,\ features)}，然后 你希望 dropout 148 | 掩层在所有时间步都是一样的， 你可以使用 149 | \texttt{noise\_shape=(batch\_size,\ 1,\ features)}。 150 | \item 151 | \textbf{seed}: 一个作为随机种子的 Python 整数。 152 | \end{itemize} 153 | 154 | \textbf{参考文献} 155 | 156 | \begin{itemize} 157 | \tightlist 158 | \item 159 | \href{http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf}{Dropout: 160 | A Simple Way to Prevent Neural Networks from Overfitting} 161 | \end{itemize} 162 | 163 | 164 | 165 | 166 | \subsubsection{Flatten {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L465}{{[}source{]}}}} 167 | 168 | \begin{Shaded} 169 | \begin{Highlighting}[] 170 | \NormalTok{keras.layers.Flatten()} 171 | \end{Highlighting} 172 | \end{Shaded} 173 | 174 | 将输入展平。不影响批量大小。 175 | 176 | \textbf{例} 177 | 178 | \begin{Shaded} 179 | \begin{Highlighting}[] 180 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 181 | \NormalTok{model.add(Conv2D(}\DecValTok{64}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{3}\NormalTok{,} 182 | \NormalTok{border_mode}\OperatorTok{=}\StringTok{'same'}\NormalTok{,} 183 | \NormalTok{input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{3}\NormalTok{, }\DecValTok{32}\NormalTok{, }\DecValTok{32}\NormalTok{)))} 184 | \CommentTok{# 现在：model.output_shape == (None, 64, 32, 32)} 185 | 186 | \NormalTok{model.add(Flatten())} 187 | \CommentTok{# 现在：model.output_shape == (None, 65536)} 188 | \end{Highlighting} 189 | \end{Shaded} 190 | 191 | 192 | \subsubsection{Input {\href{https://github.com/keras-team/keras/blob/master/keras/engine/topology.py\#L1391}{{[}source{]}}}} 193 | 194 | \begin{Shaded} 195 | \begin{Highlighting}[] 196 | \NormalTok{keras.engine.topology.Input()} 197 | \end{Highlighting} 198 | \end{Shaded} 199 | 200 | \texttt{Input()} 用于实例化 Keras 张量。 201 | 202 | Keras 张量是底层后端(Theano, TensorFlow or CNTK) 203 | 的张量对象，我们增加了一些特性，使得能够通过了解模型的输入 204 | 和输出来构建Keras模型。 205 | 206 | 例如，如果 a, b 和 c 都是 Keras 张量， 那么以下操作是可行的： 207 | \texttt{model\ =\ Model(input={[}a,\ b{]},\ output=c)} 208 | 209 | 添加的 Keras 属性是： - \textbf{\texttt{\_keras\_shape}}: 通过 210 | Keras端的尺寸推理 进行传播的整数尺寸元组。 - 211 | \textbf{\texttt{\_keras\_history}}: 应用于张量的最后一层。 212 | 整个网络层计算图可以递归地从该层中检索。 213 | 214 | \textbf{参数} 215 | 216 | \begin{itemize} 217 | \tightlist 218 | \item 219 | \textbf{shape}: 一个尺寸元组（整数），不包含批量大小。A shape tuple 220 | (integer), not including the batch size. 例如，\texttt{shape=(32,)} 221 | 表明期望的输入是按批次的 32 维向量。 222 | \item 223 | \textbf{batch\_shape}: 一个尺寸元组（整数），包含批量大小。 224 | 例如，\texttt{batch\_shape=(10,\ 32)} 表明期望的输入是 10 个 32 225 | 维向量。 \texttt{batch\_shape=(None,\ 32)} 表明任意批次大小的 32 226 | 维向量。 227 | \item 228 | \textbf{name}: 一个可选的层的名称的字符串。 229 | 在一个模型中应该是唯一的（不可以重用一个名字两次）。 230 | 如未提供，将自动生成。 231 | \item 232 | \textbf{dtype}: 输入所期望的数据类型，字符串表示 (\texttt{float32}, 233 | \texttt{float64}, \texttt{int32}...) 234 | \item 235 | \textbf{sparse}: 一个布尔值，指明需要创建的占位符是否是稀疏的。 236 | \item 237 | \textbf{tensor}: 可选的可封装到 \texttt{Input} 层的现有张量。 238 | 如果设定了，那么这个层将不会创建占位符张量。 239 | \end{itemize} 240 | 241 | \textbf{返回} 242 | 243 | 一个张量。 244 | 245 | \textbf{例} 246 | 247 | \begin{Shaded} 248 | \begin{Highlighting}[] 249 | \CommentTok{# 这是 Keras 中的一个逻辑回归} 250 | \NormalTok{x }\OperatorTok{=} \NormalTok{Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{32}\NormalTok{,))} 251 | \NormalTok{y }\OperatorTok{=} \NormalTok{Dense(}\DecValTok{16}\NormalTok{, activation}\OperatorTok{=}\StringTok{'softmax'}\NormalTok{)(x)} 252 | \NormalTok{model }\OperatorTok{=} \NormalTok{Model(x, y)} 253 | \end{Highlighting} 254 | \end{Shaded} 255 | 256 | 257 | \subsubsection{Reshape {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L314}{{[}source{]}}}} 258 | 259 | \begin{Shaded} 260 | \begin{Highlighting}[] 261 | \NormalTok{keras.layers.Reshape(target_shape)} 262 | \end{Highlighting} 263 | \end{Shaded} 264 | 265 | 将输入重新调整为特定的尺寸。 266 | 267 | \textbf{参数} 268 | 269 | \begin{itemize} 270 | \tightlist 271 | \item 272 | \textbf{target\_shape}: 目标尺寸。整数元组。 不包含表示批量的轴。 273 | \end{itemize} 274 | 275 | \textbf{输入尺寸} 276 | 277 | 任意，尽管输入尺寸中的所有维度必须是固定的。 278 | 当使用此层作为模型中的第一层时， 使用参数 \texttt{input\_shape} 279 | （整数元组，不包括样本数的轴）。 280 | 281 | \textbf{输出尺寸} 282 | 283 | \texttt{(batch\_size,)\ +\ target\_shape} 284 | 285 | \textbf{例} 286 | 287 | \begin{Shaded} 288 | \begin{Highlighting}[] 289 | \CommentTok{# 作为 Sequential 模型的第一层} 290 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 291 | \NormalTok{model.add(Reshape((}\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{), input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{12}\NormalTok{,)))} 292 | \CommentTok{# 现在：model.output_shape == (None, 3, 4)} 293 | \CommentTok{# 注意： `None` 是批表示的维度} 294 | 295 | \CommentTok{# 作为 Sequential 模型的中间层} 296 | \NormalTok{model.add(Reshape((}\DecValTok{6}\NormalTok{, }\DecValTok{2}\NormalTok{)))} 297 | \CommentTok{# 现在： model.output_shape == (None, 6, 2)} 298 | 299 | \CommentTok{# 还支持使用 `-1` 表示维度的尺寸推断} 300 | \NormalTok{model.add(Reshape((}\OperatorTok{-}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{)))} 301 | \CommentTok{# 现在： model.output_shape == (None, 3, 2, 2)} 302 | \end{Highlighting} 303 | \end{Shaded} 304 | 305 | 306 | \subsubsection{Permute {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L413}{{[}source{]}}}} 307 | 308 | \begin{Shaded} 309 | \begin{Highlighting}[] 310 | \NormalTok{keras.layers.Permute(dims)} 311 | \end{Highlighting} 312 | \end{Shaded} 313 | 314 | 根据给定的模式置换输入的维度。 315 | 316 | 在某些场景下很有用，例如将 RNN 和 CNN 连接在一起。 317 | 318 | \textbf{例} 319 | 320 | \begin{Shaded} 321 | \begin{Highlighting}[] 322 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 323 | \NormalTok{model.add(Permute((}\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{), input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{10}\NormalTok{, }\DecValTok{64}\NormalTok{)))} 324 | \CommentTok{# 现在： model.output_shape == (None, 64, 10)} 325 | \CommentTok{# 注意： `None` 是批表示的维度} 326 | \end{Highlighting} 327 | \end{Shaded} 328 | 329 | \textbf{参数} 330 | 331 | \begin{itemize} 332 | \tightlist 333 | \item 334 | \textbf{dims}: 整数元组。置换模式，不包含样本维度。 索引从 1 开始。 335 | 例如, \texttt{(2,\ 1)} 置换输入的第一和第二个维度。 336 | \end{itemize} 337 | 338 | \textbf{输入尺寸} 339 | 340 | 任意。当使用此层作为模型中的第一层时， 使用参数 \texttt{input\_shape} 341 | （整数元组，不包括样本数的轴）。 342 | 343 | \textbf{输出尺寸} 344 | 345 | 与输入尺寸相同，但是维度根据指定的模式重新排列。 346 | 347 | 348 | 349 | \subsubsection{RepeatVector {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L500}{{[}source{]}}}} 350 | 351 | \begin{Shaded} 352 | \begin{Highlighting}[] 353 | \NormalTok{keras.layers.RepeatVector(n)} 354 | \end{Highlighting} 355 | \end{Shaded} 356 | 357 | 将输入重复 n 次。 358 | 359 | \textbf{例} 360 | 361 | \begin{Shaded} 362 | \begin{Highlighting}[] 363 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 364 | \NormalTok{model.add(Dense(}\DecValTok{32}\NormalTok{, input_dim}\OperatorTok{=}\DecValTok{32}\NormalTok{))} 365 | \CommentTok{# 现在： model.output_shape == (None, 32)} 366 | \CommentTok{# 注意： `None` 是批表示的维度} 367 | 368 | \NormalTok{model.add(RepeatVector(}\DecValTok{3}\NormalTok{))} 369 | \CommentTok{# 现在： model.output_shape == (None, 3, 32)} 370 | \end{Highlighting} 371 | \end{Shaded} 372 | 373 | \textbf{参数} 374 | 375 | \begin{itemize} 376 | \tightlist 377 | \item 378 | \textbf{n}: 整数，重复次数。 379 | \end{itemize} 380 | 381 | \textbf{输入尺寸} 382 | 383 | 2D 张量，尺寸为 \texttt{(num\_samples,\ features)}。 384 | 385 | \textbf{输出尺寸} 386 | 387 | 3D 张量，尺寸为 \texttt{(num\_samples,\ n,\ features)}。 388 | 389 | \subsubsection{Lambda {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L542}{{[}source{]}}}} 390 | 391 | \begin{Shaded} 392 | \begin{Highlighting}[] 393 | \NormalTok{keras.layers.Lambda(function, output_shape}\OperatorTok{=}\VariableTok{None}\NormalTok{, mask}\OperatorTok{=}\VariableTok{None}\NormalTok{, arguments}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 394 | \end{Highlighting} 395 | \end{Shaded} 396 | 397 | 将任意表达式封装为 \texttt{Layer} 对象。 398 | 399 | \textbf{例} 400 | 401 | \begin{Shaded} 402 | \begin{Highlighting}[] 403 | \CommentTok{# 添加一个 x -> x^2 层} 404 | \NormalTok{model.add(Lambda(}\KeywordTok{lambda} \NormalTok{x: x }\OperatorTok{**} \DecValTok{2}\NormalTok{))} 405 | \end{Highlighting} 406 | \end{Shaded} 407 | 408 | \begin{Shaded} 409 | \begin{Highlighting}[] 410 | \CommentTok{# 添加一个网络层，返回输入的正数部分} 411 | \CommentTok{# 与负数部分的反面的连接} 412 | 413 | \KeywordTok{def} \NormalTok{antirectifier(x):} 414 | \NormalTok{x }\OperatorTok{-=} \NormalTok{K.mean(x, axis}\OperatorTok{=}\DecValTok{1}\NormalTok{, keepdims}\OperatorTok{=}\VariableTok{True}\NormalTok{)} 415 | \NormalTok{x }\OperatorTok{=} \NormalTok{K.l2_normalize(x, axis}\OperatorTok{=}\DecValTok{1}\NormalTok{)} 416 | \NormalTok{pos }\OperatorTok{=} \NormalTok{K.relu(x)} 417 | \NormalTok{neg }\OperatorTok{=} \NormalTok{K.relu(}\OperatorTok{-}\NormalTok{x)} 418 | \ControlFlowTok{return} \NormalTok{K.concatenate([pos, neg], axis}\OperatorTok{=}\DecValTok{1}\NormalTok{)} 419 | 420 | \KeywordTok{def} \NormalTok{antirectifier_output_shape(input_shape):} 421 | \NormalTok{shape }\OperatorTok{=} \BuiltInTok{list}\NormalTok{(input_shape)} 422 | \ControlFlowTok{assert} \BuiltInTok{len}\NormalTok{(shape) }\OperatorTok{==} \DecValTok{2} \CommentTok{# only valid for 2D tensors} 423 | \NormalTok{shape[}\OperatorTok{-}\DecValTok{1}\NormalTok{] }\OperatorTok{*=} \DecValTok{2} 424 | \ControlFlowTok{return} \BuiltInTok{tuple}\NormalTok{(shape)} 425 | 426 | \NormalTok{model.add(Lambda(antirectifier,} 427 | \NormalTok{output_shape}\OperatorTok{=}\NormalTok{antirectifier_output_shape))} 428 | \end{Highlighting} 429 | \end{Shaded} 430 | 431 | \textbf{参数} 432 | 433 | \begin{itemize} 434 | \tightlist 435 | \item 436 | \textbf{function}: 需要封装的函数。 将输入张量作为第一个参数。 437 | \item 438 | \textbf{output\_shape}: 预期的函数输出尺寸。 只在使用 Theano 439 | 时有意义。 可以是元组或者函数。 如果是元组，它只指定第一个维度； 440 | 样本维度假设与输入相同： 441 | \texttt{output\_shape\ =\ (input\_shape{[}0{]},\ )\ +\ output\_shape} 442 | 或者，输入是 \texttt{None} 且样本维度也是 \texttt{None}： 443 | \texttt{output\_shape\ =\ (None,\ )\ +\ output\_shape} 444 | 如果是函数，它指定整个尺寸为输入尺寸的一个函数： 445 | \texttt{output\_shape\ =\ f(input\_shape)} 446 | \item 447 | \textbf{arguments}: 可选的需要传递给函数的关键字参数。 448 | \end{itemize} 449 | 450 | \textbf{输入尺寸} 451 | 452 | 任意。当使用此层作为模型中的第一层时， 使用参数 \texttt{input\_shape} 453 | （整数元组，不包括样本数的轴）。 454 | 455 | \textbf{输出尺寸} 456 | 457 | 由 \texttt{output\_shape} 参数指定 (或者在使用 TensorFlow 458 | 时，自动推理得到)。 459 | 460 | 461 | \subsubsection{ActivityRegularization {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L886}{{[}source{]}}}} 462 | 463 | \begin{Shaded} 464 | \begin{Highlighting}[] 465 | \NormalTok{keras.layers.ActivityRegularization(l1}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, l2}\OperatorTok{=}\FloatTok{0.0}\NormalTok{)} 466 | \end{Highlighting} 467 | \end{Shaded} 468 | 469 | 网络层，对基于代价函数的输入活动应用一个更新。 470 | 471 | \textbf{参数} 472 | 473 | \begin{itemize} 474 | \tightlist 475 | \item 476 | \textbf{l1}: L1 正则化因子 (正数浮点型)。 477 | \item 478 | \textbf{l2}: L2 正则化因子 (正数浮点型)。 479 | \end{itemize} 480 | 481 | \textbf{输入尺寸} 482 | 483 | 任意。当使用此层作为模型中的第一层时， 使用参数 \texttt{input\_shape} 484 | （整数元组，不包括样本数的轴）。 485 | 486 | \textbf{输出尺寸} 487 | 488 | 与输入相同。 489 | 490 | 491 | \subsubsection{Masking {\href{https://github.com/keras-team/keras/blob/master/keras/layers/core.py\#L28}{{[}source{]}}}} 492 | 493 | \begin{Shaded} 494 | \begin{Highlighting}[] 495 | \NormalTok{keras.layers.Masking(mask_value}\OperatorTok{=}\FloatTok{0.0}\NormalTok{)} 496 | \end{Highlighting} 497 | \end{Shaded} 498 | 499 | 使用覆盖值覆盖序列，以跳过时间步。 500 | 501 | 对于输入张量的每一个时间步（张量的第一个维度）， 502 | 如果所有时间步中输入张量的值与 \texttt{mask\_value} 相等， 503 | 那么这个时间步将在所有下游层被覆盖 (跳过) （只要它们支持覆盖）。 504 | 505 | 如果任何下游层不支持覆盖但仍然收到此类输入覆盖信息，会引发异常。 506 | 507 | \textbf{例} 508 | 509 | 考虑将要喂入一个 LSTM 层的 Numpy 矩阵~\texttt{x}， 尺寸为 510 | \texttt{(samples,\ timesteps,\ features)}。 你想要覆盖时间步 \#3 和 511 | \#5，因为你缺乏这几个 时间步的数据。你可以： 512 | 513 | \begin{itemize} 514 | \tightlist 515 | \item 516 | 设置 \texttt{x{[}:,\ 3,\ :{]}\ =\ 0.} 以及 517 | \texttt{x{[}:,\ 5,\ :{]}\ =\ 0.} 518 | \item 519 | 在 LSTM 层之前，插入一个 \texttt{mask\_value=0} 的~\texttt{Masking} 520 | 层： 521 | \end{itemize} 522 | 523 | \begin{Shaded} 524 | \begin{Highlighting}[] 525 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 526 | \NormalTok{model.add(Masking(mask_value}\OperatorTok{=}\DecValTok{0}\NormalTok{., input_shape}\OperatorTok{=}\NormalTok{(timesteps, features)))} 527 | \NormalTok{model.add(LSTM(}\DecValTok{32}\NormalTok{))} 528 | \end{Highlighting} 529 | \end{Shaded} 530 | \newpage -------------------------------------------------------------------------------- /chapter/4-5_locally-connected.tex: -------------------------------------------------------------------------------- 1 | \subsection{局部连接层 Locally-connected} 2 | 3 | \subsubsection{ LocallyConnected1D {\href{https://github.com/keras-team/keras/blob/master/keras/layers/local.py\#L19}{{[}source{]}}}} 4 | 5 | \begin{Shaded} 6 | \begin{Highlighting}[] 7 | \NormalTok{keras.layers.LocallyConnected1D(filters, kernel_size, strides}\OperatorTok{=}\DecValTok{1}\NormalTok{, padding}\OperatorTok{=}\StringTok{'valid'},\\ 8 | \hspace{3cm}\NormalTok{data_format}\OperatorTok{=}\VariableTok{None}\NormalTok{, activation}\OperatorTok{=}\VariableTok{None}\NormalTok{, use_bias}\OperatorTok{=}\VariableTok{True},\\ 9 | \hspace{3cm}\NormalTok{kernel_initializer}\OperatorTok{=}\StringTok{'glorot_uniform'}\NormalTok{, bias_initializer}\OperatorTok{=}\StringTok{'zeros'},\\ 10 | \hspace{3cm}\NormalTok{kernel_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, bias_regularizer}\OperatorTok{=}\VariableTok{None},\\ 11 | \hspace{3cm}\NormalTok{activity_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, kernel_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{, bias_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 12 | \end{Highlighting} 13 | \end{Shaded} 14 | 15 | 1D 输入的局部连接层。 16 | 17 | \texttt{LocallyConnected1D} 层与 \texttt{Conv1D} 18 | 层的工作方式相同，除了权值不共享外， 19 | 也就是说，在输入的每个不同部分应用不同的一组过滤器。 20 | 21 | \textbf{例子} 22 | 23 | \begin{Shaded} 24 | \begin{Highlighting}[] 25 | \CommentTok{# 将长度为 3 的非共享权重 1D 卷积应用于} 26 | \CommentTok{# 具有 10 个时间步长的序列，并使用 64个 输出滤波器} 27 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 28 | \NormalTok{model.add(LocallyConnected1D(}\DecValTok{64}\NormalTok{, }\DecValTok{3}\NormalTok{, input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{10}\NormalTok{, }\DecValTok{32}\NormalTok{)))} 29 | \CommentTok{# 现在 model.output_shape == (None, 8, 64)} 30 | \CommentTok{# 在上面再添加一个新的 conv1d} 31 | \NormalTok{model.add(LocallyConnected1D(}\DecValTok{32}\NormalTok{, }\DecValTok{3}\NormalTok{))} 32 | \CommentTok{# 现在 model.output_shape == (None, 6, 32)} 33 | \end{Highlighting} 34 | \end{Shaded} 35 | 36 | \textbf{参数} 37 | 38 | \begin{itemize} 39 | \tightlist 40 | \item 41 | \textbf{filters}: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。 42 | \item 43 | \textbf{kernel\_size}: 一个整数，或者单个整数表示的元组或列表， 指明 44 | 1D 卷积窗口的长度。 45 | \item 46 | \textbf{strides}: 一个整数，或者单个整数表示的元组或列表， 47 | 指明卷积的步长。 指定任何 stride 值 != 1 与指定 48 | \texttt{dilation\_rate} 值 != 1 两者不兼容。 49 | \item 50 | \textbf{padding}: 当前仅支持 \texttt{"valid"} (大小写敏感)。 51 | \texttt{"same"} 可能会在未来支持。 52 | \item 53 | \textbf{activation}: 要使用的激活函数 (详见 54 | \hyperref[activations]{activations})。 55 | 如果你不指定，则不使用激活函数 (即线性激活： \texttt{a(x)\ =\ x})。 56 | \item 57 | \textbf{use\_bias}: 布尔值，该层是否使用偏置向量。 58 | \item 59 | \textbf{kernel\_initializer}: \texttt{kernel} 权值矩阵的初始化器 (详见 60 | \hyperref[initializers]{initializers})。 61 | \item 62 | \textbf{bias\_initializer}: 偏置向量的初始化器 (详见 63 | \hyperref[initializers]{initializers})。 64 | \item 65 | \textbf{kernel\_regularizer}: 运用到 \texttt{kernel} 66 | 权值矩阵的正则化函数 (详见 \hyperref[regularizers]{regularizer})。 67 | \item 68 | \textbf{bias\_regularizer}: 运用到偏置向量的正则化函数 (详见 69 | \hyperref[regularizers]{regularizer})。 70 | \item 71 | \textbf{activity\_regularizer}: 运用到层输出（它的激活值）的正则化函数 72 | (详见 \hyperref[regularizers]{regularizer})。 73 | \item 74 | \textbf{kernel\_constraint}: 运用到 \texttt{kernel} 权值矩阵的约束函数 75 | (详见 \hyperref[constraints]{constraints})。 76 | \item 77 | \textbf{bias\_constraint}: 运用到偏置向量的约束函数 (详见 78 | \hyperref[constraints]{constraints})。 79 | \end{itemize} 80 | 81 | \textbf{输入尺寸} 82 | 83 | 3D 张量，尺寸为： \texttt{(batch\_size,\ steps,\ input\_dim)}。 84 | 85 | \textbf{输出尺寸} 86 | 87 | 3D 张量~，尺寸为：\texttt{(batch\_size,\ new\_steps,\ filters)}， 88 | \texttt{steps} 值可能因填充或步长而改变。 89 | 90 | 91 | 92 | \subsubsection{ LocallyConnected2D {\href{https://github.com/keras-team/keras/blob/master/keras/layers/local.py\#L181}{{[}source{]}}}} 93 | 94 | \begin{Shaded} 95 | \begin{Highlighting}[] 96 | \NormalTok{keras.layers.LocallyConnected2D(filters, kernel_size, strides}\OperatorTok{=}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{1}\NormalTok{), padding}\OperatorTok{=}\StringTok{'valid'},\\ 97 | \hspace{3cm}\NormalTok{data_format}\OperatorTok{=}\VariableTok{None}\NormalTok{, activation}\OperatorTok{=}\VariableTok{None}\NormalTok{, use_bias}\OperatorTok{=}\VariableTok{True},\\ 98 | \hspace{3cm}\NormalTok{kernel_initializer}\OperatorTok{=}\StringTok{'glorot_uniform'}\NormalTok{, bias_initializer}\OperatorTok{=}\StringTok{'zeros'},\\ 99 | \hspace{3cm}\NormalTok{kernel_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, bias_regularizer}\OperatorTok{=}\VariableTok{None},\\ 100 | \hspace{3cm}\NormalTok{activity_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, kernel_constraint}\OperatorTok{=}\VariableTok{None},\\ 101 | \hspace{3cm}\NormalTok{bias_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 102 | \end{Highlighting} 103 | \end{Shaded} 104 | 105 | 2D 输入的局部连接层。 106 | 107 | \texttt{LocallyConnected2D} 层与 \texttt{Conv2D} 108 | 层的工作方式相同，除了权值不共享外， 109 | 也就是说，在输入的每个不同部分应用不同的一组过滤器。 110 | 111 | \textbf{例子} 112 | 113 | \begin{Shaded} 114 | \begin{Highlighting}[] 115 | \CommentTok{# 在 32x32 图像上应用 3x3 非共享权值和64个输出过滤器的卷积} 116 | \CommentTok{# 数据格式 `data_format="channels_last"`：} 117 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 118 | \NormalTok{model.add(LocallyConnected2D(}\DecValTok{64}\NormalTok{, (}\DecValTok{3}\NormalTok{, }\DecValTok{3}\NormalTok{), input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{32}\NormalTok{, }\DecValTok{32}\NormalTok{, }\DecValTok{3}\NormalTok{)))} 119 | \CommentTok{# 现在 model.output_shape == (None, 30, 30, 64)} 120 | \CommentTok{# 注意这一层的参数数量为 (30*30)*(3*3*3*64) + (30*30)*64} 121 | 122 | \CommentTok{# 在上面再加一个 3x3 非共享权值和 32 个输出滤波器的卷积：} 123 | \NormalTok{model.add(LocallyConnected2D(}\DecValTok{32}\NormalTok{, (}\DecValTok{3}\NormalTok{, }\DecValTok{3}\NormalTok{)))} 124 | \CommentTok{# 现在 model.output_shape == (None, 28, 28, 32)} 125 | \end{Highlighting} 126 | \end{Shaded} 127 | 128 | \textbf{参数} 129 | 130 | \begin{itemize} 131 | \tightlist 132 | \item 133 | \textbf{filters}: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。 134 | \item 135 | \textbf{kernel\_size}: 一个整数，或者 2 个整数表示的元组或列表， 指明 136 | 2D 卷积窗口的宽度和高度。 可以是一个整数，为所有空间维度指定相同的值。 137 | \item 138 | \textbf{strides}: 一个整数，或者 2 个整数表示的元组或列表， 139 | 指明卷积沿宽度和高度方向的步长。 140 | 可以是一个整数，为所有空间维度指定相同的值。 141 | \item 142 | \textbf{padding}: 当前仅支持 \texttt{"valid"} (大小写敏感)。 143 | \texttt{"same"} 可能会在未来支持。 144 | \item 145 | \textbf{data\_format}: 字符串， \texttt{channels\_last} (默认) 或 146 | \texttt{channels\_first} 之一。 输入中维度的顺序。 147 | \texttt{channels\_last} 对应输入尺寸为 148 | \texttt{(batch,\ height,\ width,\ channels)}， 149 | \texttt{channels\_first} 对应输入尺寸为 150 | \texttt{(batch,\ channels,\ height,\ width)}。 它默认为从 Keras 151 | 配置文件 \texttt{\textasciitilde{}/.keras/keras.json} 中 找到的 152 | \texttt{image\_data\_format} 值。 如果你从未设置它，将使用 153 | "channels\_last"。 154 | \item 155 | \textbf{activation}: 要使用的激活函数 (详见 156 | \hyperref[activations]{activations})。 157 | 如果你不指定，则不使用激活函数 (即线性激活： \texttt{a(x)\ =\ x})。 158 | \item 159 | \textbf{use\_bias}: 布尔值，该层是否使用偏置向量。 160 | \item 161 | \textbf{kernel\_initializer}: \texttt{kernel} 权值矩阵的初始化器 (详见 162 | \hyperref[initializers]{initializers})。 163 | \item 164 | \textbf{bias\_initializer}: 偏置向量的初始化器 (详见 165 | \hyperref[initializers]{initializers})。 166 | \item 167 | \textbf{kernel\_regularizer}: 运用到 \texttt{kernel} 168 | 权值矩阵的正则化函数 (详见 \hyperref[regularizers]{regularizer})。 169 | \item 170 | \textbf{bias\_regularizer}: 运用到偏置向量的正则化函数 (详见 171 | \hyperref[regularizers]{regularizer})。 172 | \item 173 | \textbf{activity\_regularizer}: 运用到层输出（它的激活值）的正则化函数 174 | (详见 \hyperref[regularizers]{regularizer})。 175 | \item 176 | \textbf{kernel\_constraint}: 运用到 \texttt{kernel} 权值矩阵的约束函数 177 | (详见 \hyperref[constraints]{constraints})。 178 | \item 179 | \textbf{bias\_constraint}: 运用到偏置向量的约束函数 (详见 180 | \hyperref[constraints]{constraints})。 181 | \end{itemize} 182 | 183 | \textbf{输入尺寸} 184 | 185 | 4D 张量，尺寸为： \texttt{(samples,\ channels,\ rows,\ cols)}，如果 186 | data\_format='channels\_first'； 或者 4D 张量，尺寸为： 187 | \texttt{(samples,\ rows,\ cols,\ channels)}，如果 188 | data\_format='channels\_last'。 189 | 190 | \textbf{输出尺寸} 191 | 192 | 4D 张量，尺寸为： 193 | \texttt{(samples,\ filters,\ new\_rows,\ new\_cols)}，如果 194 | data\_format='channels\_first'； 或者 4D 张量，尺寸为： 195 | \texttt{(samples,\ new\_rows,\ new\_cols,\ filters)}，如果 196 | data\_format='channels\_last'。 \texttt{rows} 和 \texttt{cols} 197 | 的值可能因填充而改变。 198 | 199 | \newpage -------------------------------------------------------------------------------- /chapter/4-7_embedding.tex: -------------------------------------------------------------------------------- 1 | \subsection{嵌入层 Embedding} 2 | \subsubsection{Embedding {\href{https://github.com/keras-team/keras/blob/master/keras/layers/embeddings.py\#L15}{{[}source{]}}}} 3 | 4 | \begin{Shaded} 5 | \begin{Highlighting}[] 6 | \NormalTok{keras.layers.Embedding(input_dim, output_dim, embeddings_initializer}\OperatorTok{=}\StringTok{'uniform'},\\ 7 | \hspace{3cm}\NormalTok{embeddings_regularizer}\OperatorTok{=}\VariableTok{None}\NormalTok{, activity_regularizer}\OperatorTok{=}\VariableTok{None},\\ 8 | \hspace{3cm}\NormalTok{embeddings_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{, mask_zero}\OperatorTok{=}\VariableTok{False}\NormalTok{, input_length}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 9 | \end{Highlighting} 10 | \end{Shaded} 11 | 12 | 将正整数（索引值）转换为固定尺寸的稠密向量。 例如： {[}{[}4{]}, 13 | {[}20{]}{]} -\textgreater{} {[}{[}0.25, 0.1{]}, {[}0.6, -0.2{]}{]} 14 | 15 | 该层只能用作模型中的第一层。 16 | 17 | \textbf{例子} 18 | 19 | \begin{Shaded} 20 | \begin{Highlighting}[] 21 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 22 | \NormalTok{model.add(Embedding(}\DecValTok{1000}\NormalTok{, }\DecValTok{64}\NormalTok{, input_length}\OperatorTok{=}\DecValTok{10}\NormalTok{))} 23 | \CommentTok{# 模型将输入一个大小为 (batch, input_length) 的整数矩阵。} 24 | \CommentTok{# 输入中最大的整数（即词索引）不应该大于 999 （词汇表大小）} 25 | \CommentTok{# 现在 model.output_shape == (None, 10, 64)，其中 None 是 batch 的维度。} 26 | 27 | \NormalTok{input_array }\OperatorTok{=} \NormalTok{np.random.randint(}\DecValTok{1000}\NormalTok{, size}\OperatorTok{=}\NormalTok{(}\DecValTok{32}\NormalTok{, }\DecValTok{10}\NormalTok{))} 28 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(}\StringTok{'rmsprop'}\NormalTok{, }\StringTok{'mse'}\NormalTok{)} 29 | \NormalTok{output_array }\OperatorTok{=} \NormalTok{model.predict(input_array)} 30 | \ControlFlowTok{assert} \NormalTok{output_array.shape }\OperatorTok{==} \NormalTok{(}\DecValTok{32}\NormalTok{, }\DecValTok{10}\NormalTok{, }\DecValTok{64}\NormalTok{)} 31 | \end{Highlighting} 32 | \end{Shaded} 33 | 34 | \textbf{参数} 35 | 36 | \begin{itemize} 37 | \tightlist 38 | \item 39 | \textbf{input\_dim}: int \textgreater{} 0。词汇表大小， 即，最大整数 40 | index + 1。 41 | \item 42 | \textbf{output\_dim}: int \textgreater{}= 0。词向量的维度。 43 | \item 44 | \textbf{embeddings\_initializer}: \texttt{embeddings} 矩阵的初始化方法 45 | (详见 \hyperref[initializers]{initializers})。 46 | \item 47 | \textbf{embeddings\_regularizer}: \texttt{embeddings} matrix 48 | 的正则化方法 (详见 \hyperref[regularizers]{regularizer})。 49 | \item 50 | \textbf{embeddings\_constraint}: \texttt{embeddings} matrix 的约束函数 51 | (详见 \hyperref[constraints]{constraints})。 52 | \item 53 | \textbf{mask\_zero}: 是否把 0 看作为一个应该被遮蔽的特殊的 "padding" 54 | 值。 这对于可变长的 \hyperref[recurrent]{循环神经网络层} 十分有用。 55 | 如果设定为 \texttt{True}，那么接下来的所有层都必须支持 56 | masking，否则就会抛出异常。 如果 mask\_zero 为 57 | \texttt{True}，作为结果，索引 0 就不能被用于词汇表中 （input\_dim 58 | 应该与 vocabulary + 1 大小相同）。 59 | \item 60 | \textbf{input\_length}: 输入序列的长度，当它是固定的时。 61 | 如果你需要连接 \texttt{Flatten} 和 \texttt{Dense} 62 | 层，则这个参数是必须的 （没有它，dense 层的输出尺寸就无法计算）。 63 | \end{itemize} 64 | 65 | \textbf{输入尺寸} 66 | 67 | 尺寸为 \texttt{(batch\_size,\ sequence\_length)} 的 2D 张量。 68 | 69 | \textbf{输出尺寸} 70 | 71 | 尺寸为 \texttt{(batch\_size,\ sequence\_length,\ output\_dim)} 的 3D 72 | 张量。 73 | 74 | \textbf{参考文献} 75 | 76 | \begin{itemize} 77 | \tightlist 78 | \item 79 | \href{http://arxiv.org/abs/1512.05287}{A Theoretically Grounded 80 | Application of Dropout in Recurrent Neural Networks} 81 | \end{itemize} 82 | 83 | \newpage -------------------------------------------------------------------------------- /chapter/4-8_merge.tex: -------------------------------------------------------------------------------- 1 | 2 | \subsection{融合层 Merge} 3 | \subsubsection{Add {\href{https://github.com/keras-team/keras/blob/master/keras/layers/merge.py\#L193}{{[}source{]}}}} 4 | 5 | \begin{Shaded} 6 | \begin{Highlighting}[] 7 | \NormalTok{keras.layers.Add()} 8 | \end{Highlighting} 9 | \end{Shaded} 10 | 11 | 计算一个列表的输入张量的和。 12 | 13 | 相加层接受一个列表的张量， 所有的张量必须有相同的输入尺寸， 14 | 然后返回一个张量（和输入张量尺寸相同）。 15 | 16 | \textbf{例子} 17 | 18 | \begin{Shaded} 19 | \begin{Highlighting}[] 20 | \ImportTok{import} \NormalTok{keras} 21 | 22 | \NormalTok{input1 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{16}\NormalTok{,))} 23 | \NormalTok{x1 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input1)} 24 | \NormalTok{input2 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{32}\NormalTok{,))} 25 | \NormalTok{x2 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input2)} 26 | \NormalTok{added }\OperatorTok{=} \NormalTok{keras.layers.Add()([x1, x2]) }\CommentTok{# 相当于 added = keras.layers.add([x1, x2])} 27 | 28 | \NormalTok{out }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{4}\NormalTok{)(added)} 29 | \NormalTok{model }\OperatorTok{=} \NormalTok{keras.models.Model(inputs}\OperatorTok{=}\NormalTok{[input1, input2], outputs}\OperatorTok{=}\NormalTok{out)} 30 | \end{Highlighting} 31 | \end{Shaded} 32 | 33 | 34 | 35 | 36 | \subsubsection{Subtract {\href{https://github.com/keras-team/keras/blob/master/keras/layers/merge.py\#L223}{{[}source{]}}}} 37 | 38 | \begin{Shaded} 39 | \begin{Highlighting}[] 40 | \NormalTok{keras.layers.Subtract()} 41 | \end{Highlighting} 42 | \end{Shaded} 43 | 44 | 计算两个输入张量的差。 45 | 46 | 相减层接受一个长度为 2 的张量列表， 47 | 两个张量必须有相同的尺寸，然后返回一个值为 (inputs{[}0{]} - 48 | inputs{[}1{]}) 的张量， 输出张量和输入张量尺寸相同。 49 | 50 | \textbf{例子} 51 | 52 | \begin{Shaded} 53 | \begin{Highlighting}[] 54 | \ImportTok{import} \NormalTok{keras} 55 | 56 | \NormalTok{input1 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{16}\NormalTok{,))} 57 | \NormalTok{x1 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input1)} 58 | \NormalTok{input2 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{32}\NormalTok{,))} 59 | \NormalTok{x2 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input2)} 60 | \CommentTok{# 相当于 subtracted = keras.layers.subtract([x1, x2])} 61 | \NormalTok{subtracted }\OperatorTok{=} \NormalTok{keras.layers.Subtract()([x1, x2])} 62 | 63 | \NormalTok{out }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{4}\NormalTok{)(subtracted)} 64 | \NormalTok{model }\OperatorTok{=} \NormalTok{keras.models.Model(inputs}\OperatorTok{=}\NormalTok{[input1, input2], outputs}\OperatorTok{=}\NormalTok{out)} 65 | \end{Highlighting} 66 | \end{Shaded} 67 | 68 | 69 | 70 | 71 | \subsubsection{Multiply {\href{https://github.com/keras-team/keras/blob/master/keras/layers/merge.py\#L260}{{[}source{]}}}} 72 | 73 | \begin{Shaded} 74 | \begin{Highlighting}[] 75 | \NormalTok{keras.layers.Multiply()} 76 | \end{Highlighting} 77 | \end{Shaded} 78 | 79 | 计算一个列表的输入张量的（逐元素间的）乘积。 80 | 81 | 相乘层接受一个列表的张量， 所有的张量必须有相同的输入尺寸， 82 | 然后返回一个张量（和输入张量尺寸相同）。 83 | 84 | 85 | 86 | 87 | \subsubsection{Average {\href{https://github.com/keras-team/keras/blob/master/keras/layers/merge.py\#L275}{{[}source{]}}}} 88 | 89 | \begin{Shaded} 90 | \begin{Highlighting}[] 91 | \NormalTok{keras.layers.Average()} 92 | \end{Highlighting} 93 | \end{Shaded} 94 | 95 | 计算一个列表的输入张量的平均值。 96 | 97 | 平均层接受一个列表的张量， 所有的张量必须有相同的输入尺寸， 98 | 然后返回一个张量（和输入张量尺寸相同）。 99 | 100 | 101 | 102 | 103 | \subsubsection{Maximum {\href{https://github.com/keras-team/keras/blob/master/keras/layers/merge.py\#L290}{{[}source{]}}}} 104 | 105 | \begin{Shaded} 106 | \begin{Highlighting}[] 107 | \NormalTok{keras.layers.Maximum()} 108 | \end{Highlighting} 109 | \end{Shaded} 110 | 111 | 计算一个列表的输入张量的（逐元素间的）最大值。 112 | 113 | 最大层接受一个列表的张量， 所有的张量必须有相同的输入尺寸， 114 | 然后返回一个张量（和输入张量尺寸相同）。 115 | 116 | 117 | 118 | 119 | \subsubsection{Concatenate {\href{https://github.com/keras-team/keras/blob/master/keras/layers/merge.py\#L320}{{[}source{]}}}} 120 | 121 | \begin{Shaded} 122 | \begin{Highlighting}[] 123 | \NormalTok{keras.layers.Concatenate(axis}\OperatorTok{=-}\DecValTok{1}\NormalTok{)} 124 | \end{Highlighting} 125 | \end{Shaded} 126 | 127 | 串联一个列表的输入张量。 128 | 129 | 串联层接受一个列表的张量， 除了串联轴之外，其他的尺寸都必须相同， 130 | 然后返回一个由所有输入张量串联起来的输出张量。 131 | 132 | \textbf{参数} 133 | 134 | \begin{itemize} 135 | \tightlist 136 | \item 137 | \textbf{axis}: 串联的轴。 138 | \item 139 | \_\_**kwargs\_\_: 层关键字参数。 140 | \end{itemize} 141 | 142 | 143 | 144 | 145 | \subsubsection{Dot {\href{https://github.com/keras-team/keras/blob/master/keras/layers/merge.py\#L408}{{[}source{]}}}} 146 | 147 | \begin{Shaded} 148 | \begin{Highlighting}[] 149 | \NormalTok{keras.layers.Dot(axes, normalize}\OperatorTok{=}\VariableTok{False}\NormalTok{)} 150 | \end{Highlighting} 151 | \end{Shaded} 152 | 153 | 计算两个张量之间样本的点积。 154 | 155 | 例如，如果作用于输入尺寸为 \texttt{(batch\_size,\ n)} 的两个张量 156 | \texttt{a} 和 \texttt{b}， 那么输出结果就会是尺寸为 157 | \texttt{(batch\_size,\ 1)} 的一个张量。 在这个张量中，每一个条目 158 | \texttt{i} 是 \texttt{a{[}i{]}} 和 \texttt{b{[}i{]}} 之间的点积。 159 | 160 | \textbf{参数} 161 | 162 | \begin{itemize} 163 | \tightlist 164 | \item 165 | \textbf{axes}: 整数或者整数元组， 一个或者几个进行点积的轴。 166 | \item 167 | \textbf{normalize}: 是否在点积之前对即将进行点积的轴进行 L2 标准化。 168 | 如果设置成 True，那么输出两个样本之间的余弦相似值。 169 | \item 170 | \_\_**kwargs\_\_: 层关键字参数。 171 | \end{itemize} 172 | 173 | 174 | \subsubsection{add}\label{add} 175 | 176 | \begin{Shaded} 177 | \begin{Highlighting}[] 178 | \NormalTok{keras.layers.add(inputs)} 179 | \end{Highlighting} 180 | \end{Shaded} 181 | 182 | \texttt{Add} 层的函数式接口。 183 | 184 | \textbf{参数} 185 | 186 | \begin{itemize} 187 | \tightlist 188 | \item 189 | \textbf{inputs}: 一个列表的输入张量（列表大小至少为 2）。 190 | \item 191 | \_\_**kwargs\_\_: 层关键字参数。 192 | \end{itemize} 193 | 194 | \textbf{返回} 195 | 196 | 一个张量，所有输入张量的和。 197 | 198 | \textbf{例子} 199 | 200 | \begin{Shaded} 201 | \begin{Highlighting}[] 202 | \ImportTok{import} \NormalTok{keras} 203 | 204 | \NormalTok{input1 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{16}\NormalTok{,))} 205 | \NormalTok{x1 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input1)} 206 | \NormalTok{input2 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{32}\NormalTok{,))} 207 | \NormalTok{x2 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input2)} 208 | \NormalTok{added }\OperatorTok{=} \NormalTok{keras.layers.add([x1, x2])} 209 | 210 | \NormalTok{out }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{4}\NormalTok{)(added)} 211 | \NormalTok{model }\OperatorTok{=} \NormalTok{keras.models.Model(inputs}\OperatorTok{=}\NormalTok{[input1, input2], outputs}\OperatorTok{=}\NormalTok{out)} 212 | \end{Highlighting} 213 | \end{Shaded} 214 | 215 | 216 | 217 | \subsubsection{subtract}\label{subtract} 218 | 219 | \begin{Shaded} 220 | \begin{Highlighting}[] 221 | \NormalTok{keras.layers.subtract(inputs)} 222 | \end{Highlighting} 223 | \end{Shaded} 224 | 225 | \texttt{Subtract} 层的函数式接口。 226 | 227 | \textbf{参数} 228 | 229 | \begin{itemize} 230 | \tightlist 231 | \item 232 | \textbf{inputs}: 一个列表的输入张量（列表大小准确为 2）。 233 | \item 234 | \_\_**kwargs\_\_: 层的关键字参数。 235 | \end{itemize} 236 | 237 | \textbf{返回} 238 | 239 | 一个张量，两个输入张量的差。 240 | 241 | \textbf{例子} 242 | 243 | \begin{Shaded} 244 | \begin{Highlighting}[] 245 | \ImportTok{import} \NormalTok{keras} 246 | 247 | \NormalTok{input1 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{16}\NormalTok{,))} 248 | \NormalTok{x1 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input1)} 249 | \NormalTok{input2 }\OperatorTok{=} \NormalTok{keras.layers.Input(shape}\OperatorTok{=}\NormalTok{(}\DecValTok{32}\NormalTok{,))} 250 | \NormalTok{x2 }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{8}\NormalTok{, activation}\OperatorTok{=}\StringTok{'relu'}\NormalTok{)(input2)} 251 | \NormalTok{subtracted }\OperatorTok{=} \NormalTok{keras.layers.subtract([x1, x2])} 252 | 253 | \NormalTok{out }\OperatorTok{=} \NormalTok{keras.layers.Dense(}\DecValTok{4}\NormalTok{)(subtracted)} 254 | \NormalTok{model }\OperatorTok{=} \NormalTok{keras.models.Model(inputs}\OperatorTok{=}\NormalTok{[input1, input2], outputs}\OperatorTok{=}\NormalTok{out)} 255 | \end{Highlighting} 256 | \end{Shaded} 257 | 258 | 259 | 260 | \subsubsection{multiply}\label{multiply} 261 | 262 | \begin{Shaded} 263 | \begin{Highlighting}[] 264 | \NormalTok{keras.layers.multiply(inputs)} 265 | \end{Highlighting} 266 | \end{Shaded} 267 | 268 | \texttt{Multiply} 层的函数式接口。 269 | 270 | \textbf{参数} 271 | 272 | \begin{itemize} 273 | \tightlist 274 | \item 275 | \textbf{inputs}: 一个列表的输入张量（列表大小至少为 2）。 276 | \item 277 | \_\_**kwargs\_\_: 层的关键字参数。 278 | \end{itemize} 279 | 280 | \textbf{返回} 281 | 282 | 一个张量，所有输入张量的逐元素乘积。 283 | 284 | 285 | 286 | \subsubsection{average}\label{average} 287 | 288 | \begin{Shaded} 289 | \begin{Highlighting}[] 290 | \NormalTok{keras.layers.average(inputs)} 291 | \end{Highlighting} 292 | \end{Shaded} 293 | 294 | \texttt{Average} 层的函数式接口。 295 | 296 | \textbf{参数} 297 | 298 | \begin{itemize} 299 | \tightlist 300 | \item 301 | \textbf{inputs}: 一个列表的输入张量（列表大小至少为 2）。 302 | \item 303 | \_\_**kwargs\_\_: 层的关键字参数。 304 | \end{itemize} 305 | 306 | \textbf{返回} 307 | 308 | 一个张量，所有输入张量的平均值。 309 | 310 | 311 | 312 | \subsubsection{maximum}\label{maximum} 313 | 314 | \begin{Shaded} 315 | \begin{Highlighting}[] 316 | \NormalTok{keras.layers.maximum(inputs)} 317 | \end{Highlighting} 318 | \end{Shaded} 319 | 320 | \texttt{Maximum} 层的函数式接口。 321 | 322 | \textbf{参数} 323 | 324 | \begin{itemize} 325 | \tightlist 326 | \item 327 | \textbf{inputs}: 一个列表的输入张量（列表大小至少为 2）。 328 | \item 329 | \_\_**kwargs\_\_: 层的关键字参数。 330 | \end{itemize} 331 | 332 | \textbf{返回} 333 | 334 | 一个张量，所有张量的逐元素的最大值。 335 | 336 | 337 | 338 | \subsubsection{concatenate}\label{concatenate} 339 | 340 | \begin{Shaded} 341 | \begin{Highlighting}[] 342 | \NormalTok{keras.layers.concatenate(inputs, axis}\OperatorTok{=-}\DecValTok{1}\NormalTok{)} 343 | \end{Highlighting} 344 | \end{Shaded} 345 | 346 | \texttt{Concatenate} 层的函数式接口。 347 | 348 | \textbf{参数} 349 | 350 | \begin{itemize} 351 | \tightlist 352 | \item 353 | \textbf{inputs}: 一个列表的输入张量（列表大小至少为 2）。 354 | \item 355 | \textbf{axis}: 串联的轴。 356 | \item 357 | \_\_**kwargs\_\_: 层的关键字参数。 358 | \end{itemize} 359 | 360 | \textbf{返回} 361 | 362 | 一个张量，所有输入张量通过 \texttt{axis} 轴串联起来的输出张量。 363 | 364 | 365 | 366 | \subsubsection{dot}\label{dot} 367 | 368 | \begin{Shaded} 369 | \begin{Highlighting}[] 370 | \NormalTok{keras.layers.dot(inputs, axes, normalize}\OperatorTok{=}\VariableTok{False}\NormalTok{)} 371 | \end{Highlighting} 372 | \end{Shaded} 373 | 374 | \texttt{Dot} 层的函数式接口。 375 | 376 | \textbf{参数} 377 | 378 | \begin{itemize} 379 | \tightlist 380 | \item 381 | \textbf{inputs}: 一个列表的输入张量（列表大小至少为 2）。 382 | \item 383 | \textbf{axes}: 整数或者整数元组， 一个或者几个进行点积的轴。 384 | \item 385 | \textbf{normalize}: 是否在点积之前对即将进行点积的轴进行 L2 标准化。 386 | 如果设置成 True，那么输出两个样本之间的余弦相似值。 387 | \item 388 | \_\_**kwargs\_\_: 层的关键字参数。 389 | \end{itemize} 390 | 391 | \textbf{返回} 392 | 393 | 一个张量，所有输入张量样本之间的点积。 394 | 395 | \newpage 396 | -------------------------------------------------------------------------------- /chapter/4-9_advanced-activations.tex: -------------------------------------------------------------------------------- 1 | \subsection{高级激活层 Advanced Activations}\label{advanced-activations} 2 | 3 | 4 | \subsubsection{LeakyReLU {\href{https://github.com/keras-team/keras/blob/master/keras/layers/advanced_activations.py\#L18}{{[}source{]}}}} 5 | 6 | \begin{Shaded} 7 | \begin{Highlighting}[] 8 | \NormalTok{keras.layers.LeakyReLU(alpha}\OperatorTok{=}\FloatTok{0.3}\NormalTok{)} 9 | \end{Highlighting} 10 | \end{Shaded} 11 | 12 | 带泄漏的修正线性单元。 13 | 14 | 当神经元未激活时，它仍可以赋予其一个很小的梯度： 15 | \texttt{f(x)\ =\ alpha\ *\ x\ for\ x\ \textless{}\ 0}, 16 | \texttt{f(x)\ =\ x\ for\ x\ \textgreater{}=\ 0}. 17 | 18 | \textbf{输入尺寸} 19 | 20 | 可以是任意的。如果将该层作为模型的第一层， 则需要指定 21 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 22 | 23 | \textbf{输出尺寸} 24 | 25 | 与输入相同。 26 | 27 | \textbf{参数} 28 | 29 | \begin{itemize} 30 | \tightlist 31 | \item 32 | \textbf{alpha}: float \textgreater{}= 0。负斜率系数。 33 | \end{itemize} 34 | 35 | \textbf{参考文献} 36 | 37 | \begin{itemize} 38 | \tightlist 39 | \item 40 | \href{https://web.stanford.edu/~awni/papers/relu_hybrid_icml2013_final.pdf}{Rectifier 41 | Nonlinearities Improve Neural Network Acoustic Models} 42 | \end{itemize} 43 | 44 | 45 | 46 | 47 | \subsubsection{PReLU {\href{https://github.com/keras-team/keras/blob/master/keras/layers/advanced_activations.py\#L57}{{[}source{]}}}} 48 | 49 | \begin{Shaded} 50 | \begin{Highlighting}[] 51 | \NormalTok{keras.layers.PReLU(alpha_initializer}\OperatorTok{=}\StringTok{'zeros'}\NormalTok{, alpha_regularizer}\OperatorTok{=}\VariableTok{None}, \\ 52 | \hspace{3cm}\NormalTok{alpha_constraint}\OperatorTok{=}\VariableTok{None}\NormalTok{, shared_axes}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 53 | \end{Highlighting} 54 | \end{Shaded} 55 | 56 | 参数化的修正线性单元。 57 | 58 | 形式： \texttt{f(x)\ =\ alpha\ *\ x\ for\ x\ \textless{}\ 0}, 59 | \texttt{f(x)\ =\ x\ for\ x\ \textgreater{}=\ 0}, 其中 \texttt{alpha} 60 | 是一个可学习的数组，尺寸与 x 相同。 61 | 62 | \textbf{输入尺寸} 63 | 64 | 可以是任意的。如果将这一层作为模型的第一层， 则需要指定 65 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 66 | 67 | \textbf{输出尺寸} 68 | 69 | 与输入相同。 70 | 71 | \textbf{参数} 72 | 73 | \begin{itemize} 74 | \tightlist 75 | \item 76 | \textbf{alpha\_initializer}: 权重的初始化函数。 77 | \item 78 | \textbf{alpha\_regularizer}: 权重的正则化方法。 79 | \item 80 | \textbf{alpha\_constraint}: 权重的约束。 81 | \item 82 | \textbf{shared\_axes}: 激活函数共享可学习参数的轴。 83 | 例如，如果输入特征图来自输出形状为 84 | \texttt{(batch,\ height,\ width,\ channels)} 的 2D 85 | 卷积层，而且你希望跨空间共享参数，以便每个滤波器只有一组参数， 可设置 86 | \texttt{shared\_axes={[}1,\ 2{]}}。 87 | \end{itemize} 88 | 89 | \textbf{参考文献} 90 | 91 | \begin{itemize} 92 | \tightlist 93 | \item 94 | \href{https://arxiv.org/abs/1502.01852}{Delving Deep into Rectifiers: 95 | Surpassing Human-Level Performance on ImageNet Classification} 96 | \end{itemize} 97 | 98 | 99 | 100 | 101 | \subsubsection{ELU {\href{https://github.com/keras-team/keras/blob/master/keras/layers/advanced_activations.py\#L152}{{[}source{]}}}} 102 | 103 | \begin{Shaded} 104 | \begin{Highlighting}[] 105 | \NormalTok{keras.layers.ELU(alpha}\OperatorTok{=}\FloatTok{1.0}\NormalTok{)} 106 | \end{Highlighting} 107 | \end{Shaded} 108 | 109 | 指数线性单元。 110 | 111 | 形式： 112 | \texttt{f(x)\ =\ \ alpha\ *\ (exp(x)\ -\ 1.)\ for\ x\ \textless{}\ 0}, 113 | \texttt{f(x)\ =\ x\ for\ x\ \textgreater{}=\ 0}. 114 | 115 | \textbf{输入尺寸} 116 | 117 | 可以是任意的。如果将这一层作为模型的第一层， 则需要指定 118 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 119 | 120 | \textbf{输出尺寸} 121 | 122 | 与输入相同。 123 | 124 | \textbf{参数} 125 | 126 | \begin{itemize} 127 | \tightlist 128 | \item 129 | \textbf{alpha}: 负因子的尺度。 130 | \end{itemize} 131 | 132 | \textbf{参考文献} 133 | 134 | \begin{itemize} 135 | \tightlist 136 | \item 137 | \href{https://arxiv.org/abs/1511.07289v1}{Fast and Accurate Deep 138 | Network Learning by Exponential Linear Units (ELUs)} 139 | \end{itemize} 140 | 141 | 142 | 143 | \subsubsection{ThresholdedReLU {\href{https://github.com/keras-team/keras/blob/master/keras/layers/advanced_activations.py\#L191}{{[}source{]}}}} 144 | 145 | \begin{Shaded} 146 | \begin{Highlighting}[] 147 | \NormalTok{keras.layers.ThresholdedReLU(theta}\OperatorTok{=}\FloatTok{1.0}\NormalTok{)} 148 | \end{Highlighting} 149 | \end{Shaded} 150 | 151 | 带阈值的修正线性单元。 152 | 153 | 形式： \texttt{f(x)\ =\ x\ for\ x\ \textgreater{}\ theta}, 154 | \texttt{f(x)\ =\ 0\ otherwise}. 155 | 156 | \textbf{输入尺寸} 157 | 158 | 可以是任意的。如果将这一层作为模型的第一层， 则需要指定 159 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 160 | 161 | \textbf{输出尺寸} 162 | 163 | 与输入相同。 164 | 165 | \textbf{参数} 166 | 167 | \begin{itemize} 168 | \tightlist 169 | \item 170 | \textbf{theta}: float \textgreater{}= 0。激活的阈值位。 171 | \end{itemize} 172 | 173 | \textbf{参考文献} 174 | 175 | \begin{itemize} 176 | \tightlist 177 | \item 178 | \href{http://arxiv.org/abs/1402.3337}{Zero-Bias Autoencoders and the 179 | Benefits of Co-Adapting Features} 180 | \end{itemize} 181 | 182 | 183 | 184 | \subsubsection{Softmax {\href{https://github.com/keras-team/keras/blob/master/keras/layers/advanced_activations.py\#L230}{{[}source{]}}}} 185 | 186 | \begin{Shaded} 187 | \begin{Highlighting}[] 188 | \NormalTok{keras.layers.Softmax(axis}\OperatorTok{=-}\DecValTok{1}\NormalTok{)} 189 | \end{Highlighting} 190 | \end{Shaded} 191 | 192 | Softmax 激活函数。 193 | 194 | \textbf{输入尺寸} 195 | 196 | 可以是任意的。如果将这一层作为模型的第一层， 则需要指定 197 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 198 | 199 | \textbf{输出尺寸} 200 | 201 | 与输入相同。 202 | 203 | \textbf{参数} 204 | 205 | \begin{itemize} 206 | \tightlist 207 | \item 208 | \textbf{axis}: 整数，应用 softmax 标准化的轴。 209 | \end{itemize} 210 | 211 | 212 | \subsubsection{ReLU{\href{https://github.com/keras-team/keras/blob/master/keras/layers/advanced_activations.py\#L262}{{[}source{]}}}} 213 | 214 | \begin{Shaded} 215 | \begin{Highlighting}[] 216 | \NormalTok{keras.layers.ReLU(max_value}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 217 | \end{Highlighting} 218 | \end{Shaded} 219 | 220 | ReLU 激活函数。 221 | 222 | \textbf{输入尺寸} 223 | 224 | 可以是任意的。如果将这一层作为模型的第一层， 则需要指定 225 | \texttt{input\_shape} 参数 （整数元组，不包含样本数量的维度）。 226 | 227 | \textbf{输出尺寸} 228 | 229 | 与输入相同。 230 | 231 | \textbf{参数} 232 | 233 | \begin{itemize} 234 | \tightlist 235 | \item 236 | \textbf{max\_value}: 浮点数，最大的输出值。 237 | \end{itemize} 238 | 239 | \newpage 240 | -------------------------------------------------------------------------------- /chapter/5-1_preprocessing-sequence.tex: -------------------------------------------------------------------------------- 1 | \section{数据预处理} 2 | \subsection{序列预处理} 3 | \subsubsection{TimeseriesGenerator}\label{preprocessing-sequence} 4 | 5 | \begin{Shaded} 6 | \begin{Highlighting}[] 7 | \NormalTok{keras.preprocessing.sequence.TimeseriesGenerator(data, targets, length, 8 | sampling_rate}\OperatorTok{=}\DecValTok{1,} 9 | \NormalTok{ stride}\OperatorTok{=}\DecValTok{1,} 10 | \NormalTok{ start_index}\OperatorTok{=}\DecValTok{0,} 11 | \NormalTok{ end_index}\OperatorTok{=}\VariableTok{None,} 12 | \NormalTok{ shuffle}\OperatorTok{=}\VariableTok{False,} 13 | \NormalTok{ reverse}\OperatorTok{=}\VariableTok{False,} 14 | \NormalTok{ batch_size}\OperatorTok{=}\DecValTok{128}\NormalTok{)} 15 | \end{Highlighting} 16 | \end{Shaded} 17 | 18 | 用于生成批量时序数据的实用工具类。 19 | 20 | 这个类以一系列由相等间隔以及一些时间序列参数（例如步长、历史长度等）汇集的数据点作为输入，以生成用于训练/验证的批次数据。 21 | 22 | \textbf{参数} 23 | 24 | \begin{itemize} 25 | \tightlist 26 | \item 27 | data: 可索引的生成器（例如列表或 Numpy 28 | 数组），包含连续数据点（时间步）。数据应该是 2D 的，且第 0 29 | 个轴为时间维度。 30 | \item 31 | targets: 对应于 \texttt{data} 的时间步的目标值。它应该与 \texttt{data} 32 | 的长度相同。 33 | \item 34 | length: 输出序列的长度（以时间步数表示）。 35 | \item 36 | sampling\_rate: 序列内连续各个时间步之间的周期。对于周期 \texttt{r}, 37 | 时间步 \texttt{data{[}i{]}}, \texttt{data{[}i-r{]}}, \ldots{} 38 | \texttt{data{[}i\ -\ length{]}} 被用于生成样本序列。 39 | \item 40 | stride: 连续输出序列之间的周期. 对于周期 \texttt{s}, 连续输出样本将为 41 | \texttt{data{[}i{]}}, \texttt{data{[}i+s{]}}, \texttt{data{[}i+2*s{]}} 42 | 等。 43 | \item 44 | start\_index: 在 \texttt{start\_index} 45 | 之前的数据点在输出序列中将不被使用。这对保留部分数据以进行测试或验证很有用。 46 | \item 47 | end\_index: 在 \texttt{end\_index} 48 | 之后的数据点在输出序列中将不被使用。这对保留部分数据以进行测试或验证很有用。 49 | \item 50 | shuffle: 是否打乱输出样本，还是按照时间顺序绘制它们。 51 | \item 52 | reverse: 布尔值: 如果 \texttt{true}, 53 | 每个输出样本中的时间步将按照时间倒序排列。 54 | \item 55 | batch\_size: 每个批次中的时间序列样本数（可能除最后一个外）。 56 | \end{itemize} 57 | 58 | \textbf{返回} 59 | 60 | 一个 \href{https://keras.io/zh/utils/\#sequence}{Sequence} 实例。 61 | 62 | \textbf{例子} 63 | 64 | \begin{Shaded} 65 | \begin{Highlighting}[] 66 | \ImportTok{from}\NormalTok{ keras.preprocessing.sequence }\ImportTok{import}\NormalTok{ TimeseriesGenerator} 67 | \ImportTok{import}\NormalTok{ numpy }\ImportTok{as}\NormalTok{ np} 68 | 69 | \NormalTok{data }\OperatorTok{=}\NormalTok{ np.array([[i] }\ControlFlowTok{for}\NormalTok{ i }\KeywordTok{in} \BuiltInTok{range}\NormalTok{(}\DecValTok{50}\NormalTok{)])} 70 | \NormalTok{targets }\OperatorTok{=}\NormalTok{ np.array([[i] }\ControlFlowTok{for}\NormalTok{ i }\KeywordTok{in} \BuiltInTok{range}\NormalTok{(}\DecValTok{50}\NormalTok{)])} 71 | 72 | \NormalTok{data_gen }\OperatorTok{=}\NormalTok{ TimeseriesGenerator(data, targets,} 73 | \NormalTok{ length}\OperatorTok{=}\DecValTok{10}\NormalTok{, sampling_rate}\OperatorTok{=}\DecValTok{2}\NormalTok{,} 74 | \NormalTok{ batch_size}\OperatorTok{=}\DecValTok{2}\NormalTok{)} 75 | \ControlFlowTok{assert} \BuiltInTok{len}\NormalTok{(data_gen) }\OperatorTok{==} \DecValTok{20} 76 | 77 | \NormalTok{batch_0 }\OperatorTok{=}\NormalTok{ data_gen[}\DecValTok{0}\NormalTok{]} 78 | \NormalTok{x, y }\OperatorTok{=}\NormalTok{ batch_0} 79 | \ControlFlowTok{assert}\NormalTok{ np.array_equal(x,} 80 | \NormalTok{ np.array([[[}\DecValTok{0}\NormalTok{], [}\DecValTok{2}\NormalTok{], [}\DecValTok{4}\NormalTok{], [}\DecValTok{6}\NormalTok{], [}\DecValTok{8}\NormalTok{]],} 81 | \NormalTok{ [[}\DecValTok{1}\NormalTok{], [}\DecValTok{3}\NormalTok{], [}\DecValTok{5}\NormalTok{], [}\DecValTok{7}\NormalTok{], [}\DecValTok{9}\NormalTok{]]]))} 82 | \ControlFlowTok{assert}\NormalTok{ np.array_equal(y,} 83 | \NormalTok{ np.array([[}\DecValTok{10}\NormalTok{], [}\DecValTok{11}\NormalTok{]]))} 84 | \end{Highlighting} 85 | \end{Shaded} 86 | 87 | 88 | \subsubsection{pad\_sequences}\label{pad_sequences} 89 | 90 | \begin{Shaded} 91 | \begin{Highlighting}[] 92 | \NormalTok{keras.preprocessing.sequence.pad_sequences(sequences, maxlen}\OperatorTok{=}\VariableTok{None,} 93 | \NormalTok{ dtype}\OperatorTok{=}\StringTok{'int32',} 94 | \NormalTok{ padding}\OperatorTok{=}\StringTok{'pre',} 95 | \NormalTok{ truncating}\OperatorTok{=}\StringTok{'pre',} 96 | \NormalTok{ value}\OperatorTok{=}\FloatTok{0.0}\NormalTok{)} 97 | \end{Highlighting} 98 | \end{Shaded} 99 | 100 | 将多个序列截断或补齐为相同长度。 101 | 102 | 该函数将一个 \texttt{num\_samples} 的序列（整数列表）转化为一个 2D Numpy 103 | 矩阵，其尺寸为 \texttt{(num\_samples,\ num\_timesteps)}。 104 | \texttt{num\_timesteps} 要么是给定的 \texttt{maxlen} 105 | 参数，要么是最长序列的长度。 106 | 107 | 比 \texttt{num\_timesteps} 短的序列将在末端以 \texttt{value} 值补齐。 108 | 109 | 比 \texttt{num\_timesteps} 110 | 长的序列将会被截断以满足所需要的长度。补齐或截断发生的位置分别由参数 111 | \texttt{pading} 和 \texttt{truncating} 决定。 112 | 113 | 向前补齐为默认操作。 114 | 115 | \textbf{参数} 116 | 117 | \begin{itemize} 118 | \tightlist 119 | \item 120 | \textbf{sequences}: 列表的列表，每一个元素是一个序列。 121 | \item 122 | \textbf{maxlen}: 整数，所有序列的最大长度。 123 | \item 124 | \textbf{dtype}: 输出序列的类型。 125 | \item 126 | \textbf{padding}: 字符串，`pre' 或 `post' 127 | ，表示长度不足时是在序列的前端补齐还是在后端补齐。 128 | \item 129 | \textbf{truncating}: 字符串，`pre' 或 `post' ，移除长度大于 130 | \texttt{maxlen} 的序列的值，要么在序列前端截断，要么在后端。 131 | \item 132 | \textbf{value}: 浮点数，表示用来补齐的值。 133 | \end{itemize} 134 | 135 | \textbf{返回} 136 | 137 | \begin{itemize} 138 | \tightlist 139 | \item 140 | x: Numpy 矩阵，尺寸为 \texttt{(len(sequences),\ maxlen)}。 141 | \end{itemize} 142 | 143 | \textbf{异常} 144 | 145 | \begin{itemize} 146 | \tightlist 147 | \item 148 | ValueError: 如果截断或补齐的值无效，或者序列条目的形状无效。 149 | \end{itemize} 150 | 151 | 152 | \subsubsection{skipgrams}\label{skipgrams} 153 | 154 | \begin{Shaded} 155 | \begin{Highlighting}[] 156 | \NormalTok{keras.preprocessing.sequence.skipgrams(sequence, vocabulary_size, 157 | window_size}\OperatorTok{=}\DecValTok{4,} 158 | \NormalTok{ negative_samples}\OperatorTok{=}\FloatTok{1.0,} 159 | \NormalTok{ shuffle}\OperatorTok{=}\VariableTok{True,} 160 | \NormalTok{ categorical}\OperatorTok{=}\VariableTok{False,} 161 | \NormalTok{ sampling_table}\OperatorTok{=}\VariableTok{None,} 162 | \NormalTok{ seed}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 163 | \end{Highlighting} 164 | \end{Shaded} 165 | 166 | 生成 skipgram 词对。 167 | 168 | 该函数将一个单词索引序列（整数列表）转化为以下形式的单词元组： 169 | 170 | \begin{itemize} 171 | \tightlist 172 | \item 173 | （单词, 同窗口的单词），标签为 1（正样本）。 174 | \item 175 | （单词, 来自词汇表的随机单词），标签为 0（负样本）。 176 | \end{itemize} 177 | 178 | 若要了解更多和 Skipgram 有关的知识，请参阅这份由 Mikolov 等人发表的经典论文： 179 | \href{http://arxiv.org/pdf/1301.3781v3.pdf}{Efficient Estimation of Word Representations in Vector Space} 180 | 181 | \textbf{参数} 182 | 183 | \begin{itemize} 184 | \tightlist 185 | \item 186 | sequence: 一个编码为单词索引（整数）列表的词序列（句子）。如果使用一个 187 | \texttt{sampling\_table}，词索引应该以一个相关数据集的词的排名匹配（例如，10 188 | 将会编码为第 10 个最长出现的词）。注意词汇表中的索引 0 189 | 是非单词，将被跳过。 190 | \item 191 | vocabulary\_size: 整数，最大可能词索引 + 1 192 | \item 193 | window\_size: 整数，采样窗口大小（技术上是半个窗口）。词 \texttt{w\_i} 194 | 的窗口是 \texttt{{[}i\ -\ window\_size,\ i\ +\ window\_size+1{]}}。 195 | \item 196 | negative\_samples: 大于等于 0 的浮点数。0 表示非负（即随机）采样。1 197 | 表示与正样本数相同。 198 | \item 199 | shuffle: 是否在返回之前将这些词语打乱。 200 | \item 201 | categorical: 布尔值。如果 False，标签将为整数（例如 202 | \texttt{{[}0,\ 1,\ 1\ ..\ {]}}），如果 True，标签将为分类，例如 203 | \texttt{{[}{[}1,0{]},{[}0,1{]},{[}0,1{]}\ ..\ {]}}。 204 | \item 205 | sampling\_table: 尺寸为 \texttt{vocabulary\_size} 的 1D 数组，其中第 i 206 | 项编码了排名为 i 的词的采样概率。 207 | \item 208 | seed: 随机种子。 209 | \end{itemize} 210 | 211 | \textbf{返回} 212 | 213 | couples, labels: 其中 \texttt{couples} 是整数对，\texttt{labels} 是 0 或 214 | 1。 215 | 216 | \textbf{注意} 217 | 218 | 按照惯例，词汇表中的索引 0 是非单词，将被跳过。 219 | 220 | 221 | \subsubsection{make\_sampling\_table}\label{make_sampling_table} 222 | 223 | \begin{Shaded} 224 | \begin{Highlighting}[] 225 | \NormalTok{keras.preprocessing.sequence.make_sampling_table(size, sampling_factor}\OperatorTok{=}\FloatTok{1e-05}\NormalTok{)} 226 | \end{Highlighting} 227 | \end{Shaded} 228 | 229 | 生成一个基于单词的概率采样表。 230 | 231 | 用来生成 \texttt{skipgrams} 的 \texttt{sampling\_table} 232 | 参数。\texttt{sampling\_table{[}i{]}} 是数据集中第 i 233 | 个最常见词的采样概率（出于平衡考虑，出现更频繁的词应该被更少地采样）。 234 | 235 | 采样概率根据 word2vec 中使用的采样分布生成： 236 | 237 | \begin{Shaded} 238 | \begin{Highlighting}[] 239 | \NormalTok{p(word) }\OperatorTok{=}\NormalTok{ (}\BuiltInTok{min}\NormalTok{(}\DecValTok{1}\NormalTok{, sqrt(word_frequency }\OperatorTok{/}\NormalTok{ sampling_factor) }\OperatorTok{/} 240 | \NormalTok{ (word_frequency }\OperatorTok{/}\NormalTok{ sampling_factor)))} 241 | \end{Highlighting} 242 | \end{Shaded} 243 | 244 | 我们假设单词频率遵循 Zipf 定律（s=1），来导出 frequency(rank) 245 | 的数值近似： 246 | 247 | \texttt{frequency(rank)\ \textasciitilde{}\ 1/(rank\ *\ (log(rank)\ +\ gamma)\ +\ 1/2\ -\ 1/(12*rank))}，其中 248 | \texttt{gamma} 为 Euler-Mascheroni 常量。 249 | 250 | \textbf{参数} 251 | 252 | \begin{itemize} 253 | \tightlist 254 | \item 255 | \textbf{size}: 整数，可能采样的单词数量。 256 | \item 257 | \textbf{sampling\_factor}: word2vec 公式中的采样因子。 258 | \end{itemize} 259 | 260 | \textbf{返回} 261 | 262 | A 1D Numpy array of length size where the ith entry is the probability 263 | that a word of rank i should be sampled. 264 | 265 | 一个长度为 \texttt{size} 大小的 1D Numpy 数组，其中第 i 项是排名为 i 266 | 的单词的采样概率。 267 | 268 | 269 | \newpage 270 | -------------------------------------------------------------------------------- /chapter/5-2_preprocessing-text.tex: -------------------------------------------------------------------------------- 1 | \subsection{文本预处理} 2 | \subsubsection{Tokenizer}\label{tokenizer} 3 | 4 | \begin{Shaded} 5 | \begin{Highlighting}[] 6 | \NormalTok{keras.preprocessing.text.Tokenizer(num_words}\OperatorTok{=}\VariableTok{None}\NormalTok{, } 7 | \NormalTok{ filters}\OperatorTok{=}\StringTok{'!"#$%&()*+,-./:;<=>?@[\textbackslash{}]^_`\{|\}~'}\NormalTok{, } 8 | \NormalTok{ lower}\OperatorTok{=}\VariableTok{True}\NormalTok{, split}\OperatorTok{=}\StringTok{' '}\NormalTok{, } 9 | \NormalTok{ char_level}\OperatorTok{=}\VariableTok{False}\NormalTok{, } 10 | \NormalTok{ oov_token}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 11 | \end{Highlighting} 12 | \end{Shaded} 13 | 14 | 文本标记实用类。 15 | 16 | 该类允许使用两种方法向量化一个文本语料库： 17 | 将每个文本转化为一个整数序列（每个整数都是词典中标记的索引）； 18 | 或者将其转化为一个向量，其中每个标记的系数可以是二进制值、词频、TF-IDF权重等。 19 | 20 | \textbf{参数} 21 | 22 | \begin{itemize} 23 | \tightlist 24 | \item 25 | num\_words: 需要保留的最大词数，基于词频。只有最常出现的 26 | \texttt{num\_words} 词会被保留。 27 | \item 28 | filters: 29 | 一个字符串，其中每个元素是一个将从文本中过滤掉的字符。默认值是所有标点符号，加上制表符和换行符，减去 30 | \texttt{\textquotesingle{}} 字符。 31 | \item 32 | lower: 布尔值。是否将文本转换为小写。 33 | \item 34 | split: 字符串。按该字符串切割文本。 35 | \item 36 | char\_level: 如果为 True，则每个字符都将被视为标记。 37 | \item 38 | oov\_token: 如果给出，它将被添加到 word\_index 中，并用于在 39 | \texttt{text\_to\_sequence} 调用期间替换词汇表外的单词。 40 | \end{itemize} 41 | 42 | 默认情况下，删除所有标点符号，将文本转换为空格分隔的单词序列（单词可能包含 43 | \texttt{\textquotesingle{}} 字符）。 44 | 这些序列然后被分割成标记列表。然后它们将被索引或向量化。 45 | 46 | \texttt{0} 是不会被分配给任何单词的保留索引。 47 | 48 | \hypertarget{hashing_trick}{% 49 | \subsubsection{hashing\_trick}\label{hashing_trick}} 50 | 51 | \begin{Shaded} 52 | \begin{Highlighting}[] 53 | \NormalTok{keras.preprocessing.text.hashing_trick(text, n, } 54 | \NormalTok{ hash_function}\OperatorTok{=}\VariableTok{None}\NormalTok{, } 55 | \NormalTok{ filters}\OperatorTok{=}\StringTok{'!"#$%&()*+,-./:;<=>?@[\textbackslash{}]^_`\{|\}~'}\NormalTok{, } 56 | \NormalTok{ lower}\OperatorTok{=}\VariableTok{True}\NormalTok{, split}\OperatorTok{=}\StringTok{' '}\NormalTok{)} 57 | \end{Highlighting} 58 | \end{Shaded} 59 | 60 | 将文本转换为固定大小散列空间中的索引序列。 61 | 62 | \textbf{参数} 63 | 64 | \begin{itemize} 65 | \tightlist 66 | \item 67 | text: 输入文本（字符串）。 68 | \item 69 | n: 散列空间维度。 70 | \item 71 | hash\_function: 默认为 python 散列函数，可以是 `md5' 72 | 或任意接受输入字符串并返回整数的函数。注意 `hash' 73 | 不是稳定的散列函数，所以它在不同的运行中不一致，而 `md5' 74 | 是一个稳定的散列函数。 75 | \item 76 | filters: 77 | 要过滤的字符列表（或连接），如标点符号。默认：\texttt{!"\#\$\%\&()*+,-./:;\textless{}=\textgreater{}?@{[}\textbackslash{}{]}\^{}\_\{\textbar{}\}\textasciitilde{}}，包含基本标点符号，制表符和换行符。 78 | \item 79 | lower: 布尔值。是否将文本转换为小写。 80 | \item 81 | split: 字符串。按该字符串切割文本。 82 | \end{itemize} 83 | 84 | \textbf{返回} 85 | 86 | 整数词索引列表（唯一性无法保证）。 87 | 88 | \texttt{0} 是不会被分配给任何单词的保留索引。 89 | 90 | 由于哈希函数可能发生冲突，可能会将两个或更多字分配给同一索引。 91 | 碰撞的概率与散列空间的维度和不同对象的数量有关。 92 | 93 | \hypertarget{one_hot}{% 94 | \subsubsection{one\_hot}\label{one_hot}} 95 | 96 | \begin{Shaded} 97 | \begin{Highlighting}[] 98 | \NormalTok{keras.preprocessing.text.one_hot(text, n, } 99 | \NormalTok{ filters}\OperatorTok{=}\StringTok{'!"#$%&()*+,-./:;<=>?@[\textbackslash{}]^_`\{|\}~'}\NormalTok{, } 100 | \NormalTok{ lower}\OperatorTok{=}\VariableTok{True}\NormalTok{, split}\OperatorTok{=}\StringTok{' '}\NormalTok{)} 101 | \end{Highlighting} 102 | \end{Shaded} 103 | 104 | One-hot 将文本编码为大小为 n 的单词索引列表。 105 | 106 | \textbf{参数} 107 | 108 | \begin{itemize} 109 | \tightlist 110 | \item 111 | text: 输入文本（字符串）。 112 | \item 113 | n: 整数。词汇表尺寸。 114 | \item 115 | filters: 116 | 要过滤的字符列表（或连接），如标点符号。默认：\texttt{!"\#\$\%\&()*+,-./:;\textless{}=\textgreater{}?@{[}\textbackslash{}{]}\^{}\_\{\textbar{}\}\textasciitilde{}}，包含基本标点符号，制表符和换行符。 117 | \item 118 | lower: 布尔值。是否将文本转换为小写。 119 | \item 120 | split: 字符串。按该字符串切割文本。 121 | \end{itemize} 122 | 123 | \textbf{返回} 124 | 125 | {[}1, n{]} 之间的整数列表。每个整数编码一个词（唯一性无法保证）。 126 | 127 | \hypertarget{text_to_word_sequence}{% 128 | \subsubsection{text\_to\_word\_sequence}\label{text_to_word_sequence}} 129 | 130 | \begin{Shaded} 131 | \begin{Highlighting}[] 132 | \NormalTok{keras.preprocessing.text.text_to_word_sequence(text, } 133 | \NormalTok{ filters}\OperatorTok{=}\StringTok{'!"#$%&()*+,-./:;<=>?@[\textbackslash{}]^_`\{|\}~'}\NormalTok{, } 134 | \NormalTok{ lower}\OperatorTok{=}\VariableTok{True}\NormalTok{, split}\OperatorTok{=}\StringTok{' '}\NormalTok{)} 135 | \end{Highlighting} 136 | \end{Shaded} 137 | 138 | 将文本转换为单词（或标记）的序列。 139 | 140 | \textbf{参数} 141 | 142 | \begin{itemize} 143 | \tightlist 144 | \item 145 | text: 输入文本（字符串）。 146 | \item 147 | filters: 148 | 要过滤的字符列表（或连接），如标点符号。默认：\texttt{!"\#\$\%\&()*+,-./:;\textless{}=\textgreater{}?@{[}\textbackslash{}{]}\^{}\_\{\textbar{}\}\textasciitilde{}}，包含基本标点符号，制表符和换行符。 149 | \item 150 | lower: 布尔值。是否将文本转换为小写。 151 | \item 152 | split: 字符串。按该字符串切割文本。 153 | \end{itemize} 154 | 155 | \textbf{返回} 156 | 157 | 词或标记的列表。 158 | 159 | \newpage 160 | -------------------------------------------------------------------------------- /chapter/6_losses.tex: -------------------------------------------------------------------------------- 1 | \section{损失函数 Losses}\label{losses} 2 | 3 | \subsection{损失函数的使用} 4 | 5 | 损失函数（或称目标函数、优化评分函数）是编译模型时所需的两个参数之一： 6 | 7 | \begin{Shaded} 8 | \begin{Highlighting}[] 9 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'mean_squared_error'}\NormalTok{, optimizer}\OperatorTok{=}\StringTok{'sgd'}\NormalTok{)} 10 | \end{Highlighting} 11 | \end{Shaded} 12 | 13 | \begin{Shaded} 14 | \begin{Highlighting}[] 15 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{losses} 16 | 17 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\NormalTok{losses.mean_squared_error, optimizer}\OperatorTok{=}\StringTok{'sgd'}\NormalTok{)} 18 | \end{Highlighting} 19 | \end{Shaded} 20 | 21 | 你可以传递一个现有的损失函数名，或者一个TensorFlow/Theano符号函数。 22 | 该符号函数为每个数据点返回一个标量，有以下两个参数: 23 | 24 | \begin{itemize} 25 | \tightlist 26 | \item 27 | \textbf{y\_true}: 真实标签. TensorFlow/Theano张量。 28 | \item 29 | \textbf{y\_pred}: 预测值. 30 | TensorFlow/Theano张量，其shape与y\_true相同。 31 | \end{itemize} 32 | 33 | 实际的优化目标是所有数据点的输出数组的平均值。 34 | 35 | 有关这些函数的几个例子，请查看\href{https://github.com/keras-team/keras/blob/master/keras/losses.py}{losses 36 | source}。 37 | 38 | \subsection{可用损失函数}\label{ux53efux7528ux635fux5931ux51fdux6570} 39 | 40 | \subsubsection{mean\_squared\_error}\label{meanux5fsquaredux5ferror} 41 | 42 | \begin{Shaded} 43 | \begin{Highlighting}[] 44 | \NormalTok{mean_squared_error(y_true, y_pred)} 45 | \end{Highlighting} 46 | \end{Shaded} 47 | 48 | 49 | 50 | \subsubsection{mean\_absolute\_error}\label{meanux5fabsoluteux5ferror} 51 | 52 | \begin{Shaded} 53 | \begin{Highlighting}[] 54 | \NormalTok{mean_absolute_error(y_true, y_pred)} 55 | \end{Highlighting} 56 | \end{Shaded} 57 | 58 | 59 | 60 | \subsubsection{mean\_absolute\_percentage\_error}\label{meanux5fabsoluteux5fpercentageux5ferror} 61 | 62 | \begin{Shaded} 63 | \begin{Highlighting}[] 64 | \NormalTok{mean_absolute_percentage_error(y_true, y_pred)} 65 | \end{Highlighting} 66 | \end{Shaded} 67 | 68 | 69 | 70 | \subsubsection{mean\_squared\_logarithmic\_error}\label{meanux5fsquaredux5flogarithmicux5ferror} 71 | 72 | \begin{Shaded} 73 | \begin{Highlighting}[] 74 | \NormalTok{mean_squared_logarithmic_error(y_true, y_pred)} 75 | \end{Highlighting} 76 | \end{Shaded} 77 | 78 | 79 | 80 | \subsubsection{squared\_hinge}\label{squaredux5fhinge} 81 | 82 | \begin{Shaded} 83 | \begin{Highlighting}[] 84 | \NormalTok{squared_hinge(y_true, y_pred)} 85 | \end{Highlighting} 86 | \end{Shaded} 87 | 88 | 89 | 90 | \subsubsection{hinge}\label{hinge} 91 | 92 | \begin{Shaded} 93 | \begin{Highlighting}[] 94 | \NormalTok{hinge(y_true, y_pred)} 95 | \end{Highlighting} 96 | \end{Shaded} 97 | 98 | 99 | 100 | \subsubsection{categorical\_hinge}\label{categoricalux5fhinge} 101 | 102 | \begin{Shaded} 103 | \begin{Highlighting}[] 104 | \NormalTok{categorical_hinge(y_true, y_pred)} 105 | \end{Highlighting} 106 | \end{Shaded} 107 | 108 | 109 | 110 | \subsubsection{logcosh}\label{logcosh} 111 | 112 | \begin{Shaded} 113 | \begin{Highlighting}[] 114 | \NormalTok{logcosh(y_true, y_pred)} 115 | \end{Highlighting} 116 | \end{Shaded} 117 | 118 | 预测误差的双曲余弦的对数。 119 | 120 | 对于小的\texttt{x}，\texttt{log(cosh(x))}近似等于\texttt{(x\ **\ 2)\ /\ 2}。对于大的\texttt{x}，近似于\texttt{abs(x)\ -\ log(2)}。这表示'logcosh'与均方误差大致相同，但是不会受到偶尔疯狂的错误预测的强烈影响。 121 | 122 | \textbf{Arguments} 123 | 124 | \begin{itemize} 125 | \tightlist 126 | \item 127 | \textbf{y\_true}: 目标真实值的张量。 128 | \item 129 | \textbf{y\_pred}: 目标预测值的张量。 130 | \end{itemize} 131 | 132 | \textbf{Returns} 133 | 134 | 每个样本都有一个标量损失的张量。 135 | 136 | 137 | 138 | \subsubsection{categorical\_crossentropy}\label{categoricalux5fcrossentropy} 139 | 140 | \begin{Shaded} 141 | \begin{Highlighting}[] 142 | \NormalTok{categorical_crossentropy(y_true, y_pred)} 143 | \end{Highlighting} 144 | \end{Shaded} 145 | 146 | 147 | 148 | \subsubsection{sparse\_categorical\_crossentropy}\label{sparseux5fcategoricalux5fcrossentropy} 149 | 150 | \begin{Shaded} 151 | \begin{Highlighting}[] 152 | \NormalTok{sparse_categorical_crossentropy(y_true, y_pred)} 153 | \end{Highlighting} 154 | \end{Shaded} 155 | 156 | 157 | 158 | \subsubsection{binary\_crossentropy}\label{binaryux5fcrossentropy} 159 | 160 | \begin{Shaded} 161 | \begin{Highlighting}[] 162 | \NormalTok{binary_crossentropy(y_true, y_pred)} 163 | \end{Highlighting} 164 | \end{Shaded} 165 | 166 | 167 | 168 | \subsubsection{kullback\_leibler\_divergence}\label{kullbackux5fleiblerux5fdivergence} 169 | 170 | \begin{Shaded} 171 | \begin{Highlighting}[] 172 | \NormalTok{kullback_leibler_divergence(y_true, y_pred)} 173 | \end{Highlighting} 174 | \end{Shaded} 175 | 176 | 177 | 178 | \subsubsection{poisson}\label{poisson} 179 | 180 | \begin{Shaded} 181 | \begin{Highlighting}[] 182 | \NormalTok{poisson(y_true, y_pred)} 183 | \end{Highlighting} 184 | \end{Shaded} 185 | 186 | 187 | 188 | \subsubsection{cosine\_proximity}\label{cosineux5fproximity} 189 | 190 | \begin{Shaded} 191 | \begin{Highlighting}[] 192 | \NormalTok{cosine_proximity(y_true, y_pred)} 193 | \end{Highlighting} 194 | \end{Shaded} 195 | 196 | 197 | 198 | \textbf{注意}: 199 | 当使用\texttt{categorical\_crossentropy}损失时，你的目标值应该是分类格式 200 | (即，如果你有10个类，每个样本的目标值应该是一个10维的向量，这个向量除了表示类别的那个索引为1，其他均为0)。 201 | 为了将 \emph{整数目标值} 转换为 202 | \emph{分类目标值}，你可以使用Keras实用函数\texttt{to\_categorical}： 203 | 204 | \begin{Shaded} 205 | \begin{Highlighting}[] 206 | \ImportTok{from} \NormalTok{keras.utils.np_utils }\ImportTok{import} \NormalTok{to_categorical} 207 | 208 | \NormalTok{categorical_labels }\OperatorTok{=} \NormalTok{to_categorical(int_labels, num_classes}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 209 | \end{Highlighting} 210 | \end{Shaded} 211 | \newpage -------------------------------------------------------------------------------- /chapter/7_metrics.tex: -------------------------------------------------------------------------------- 1 | \section{评估标准 Metrics} 2 | \subsection{评价函数的用法}\label{ux8bc4ux4ef7ux51fdux6570ux7684ux7528ux6cd5} 3 | 4 | 评价函数用于评估当前训练模型的性能。当模型编译后（compile），评价函数应该作为 5 | \texttt{metrics} 的参数来输入。 6 | 7 | \begin{Shaded} 8 | \begin{Highlighting}[] 9 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'mean_squared_error'}\NormalTok{,} 10 | \NormalTok{optimizer}\OperatorTok{=}\StringTok{'sgd'}\NormalTok{,} 11 | \NormalTok{metrics}\OperatorTok{=}\NormalTok{[}\StringTok{'mae'}\NormalTok{, }\StringTok{'acc'}\NormalTok{])} 12 | \end{Highlighting} 13 | \end{Shaded} 14 | 15 | \begin{Shaded} 16 | \begin{Highlighting}[] 17 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{metrics} 18 | 19 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'mean_squared_error'}\NormalTok{,} 20 | \NormalTok{optimizer}\OperatorTok{=}\StringTok{'sgd'}\NormalTok{,} 21 | \NormalTok{metrics}\OperatorTok{=}\NormalTok{[metrics.mae, metrics.categorical_accuracy])} 22 | \end{Highlighting} 23 | \end{Shaded} 24 | 25 | 评价函数和 \hyperref[losses]{损失函数} 26 | 相似，只不过评价函数的结果不会用于训练过程中。 27 | 28 | 我们可以传递已有的评价函数名称，或者传递一个自定义的 Theano/TensorFlow 29 | 函数来使用（查阅\hyperref[custom-metrics]{自定义评价函数}）。 30 | 31 | \subsubsection{参数}\label{ux53c2ux6570} 32 | 33 | \begin{itemize} 34 | \tightlist 35 | \item 36 | \textbf{y\_true}: 真实标签，Theano/Tensorflow 张量。 37 | \item 38 | \textbf{y\_pred}: 预测值。和 y\_true 相同尺寸的 Theano/TensorFlow 39 | 张量。 40 | \end{itemize} 41 | 42 | \subsubsection{返回值}\label{ux8fd4ux56deux503c} 43 | 44 | ~返回一个表示全部数据点平均值的张量。 45 | 46 | 47 | 48 | \subsection{可使用的评价函数}\label{ux53efux4f7fux7528ux7684ux8bc4ux4ef7ux51fdux6570} 49 | 50 | \subsubsection{binary\_accuracy}\label{binaryux5faccuracy} 51 | 52 | \begin{Shaded} 53 | \begin{Highlighting}[] 54 | \NormalTok{binary_accuracy(y_true, y_pred)} 55 | \end{Highlighting} 56 | \end{Shaded} 57 | 58 | \subsubsection{categorical\_accuracy}\label{categoricalux5faccuracy} 59 | 60 | \begin{Shaded} 61 | \begin{Highlighting}[] 62 | \NormalTok{categorical_accuracy(y_true, y_pred)} 63 | \end{Highlighting} 64 | \end{Shaded} 65 | 66 | 67 | 68 | \subsubsection{sparse\_categorical\_accuracy}\label{sparseux5fcategoricalux5faccuracy} 69 | 70 | \begin{Shaded} 71 | \begin{Highlighting}[] 72 | \NormalTok{sparse_categorical_accuracy(y_true, y_pred)} 73 | \end{Highlighting} 74 | \end{Shaded} 75 | 76 | 77 | 78 | \subsubsection{top\_k\_categorical\_accuracy}\label{topux5fkux5fcategoricalux5faccuracy} 79 | 80 | \begin{Shaded} 81 | \begin{Highlighting}[] 82 | \NormalTok{top_k_categorical_accuracy(y_true, y_pred, k}\OperatorTok{=}\DecValTok{5}\NormalTok{)} 83 | \end{Highlighting} 84 | \end{Shaded} 85 | 86 | 87 | 88 | \subsubsection{sparse\_top\_k\_categorical\_accuracy}\label{sparseux5ftopux5fkux5fcategoricalux5faccuracy} 89 | 90 | \begin{Shaded} 91 | \begin{Highlighting}[] 92 | \NormalTok{sparse_top_k_categorical_accuracy(y_true, y_pred, k}\OperatorTok{=}\DecValTok{5}\NormalTok{)} 93 | \end{Highlighting} 94 | \end{Shaded} 95 | 96 | 97 | 98 | \subsection{自定义评价函数}\label{custom-metrics} 99 | 100 | 自定义评价函数应该在编译的时候（compile）传递进去。该函数需要以 101 | \texttt{(y\_true,\ y\_pred)} 作为输入参数，并返回一个张量作为输出结果。 102 | 103 | \begin{Shaded} 104 | \begin{Highlighting}[] 105 | \ImportTok{import} \NormalTok{keras.backend }\ImportTok{as} \NormalTok{K} 106 | 107 | \KeywordTok{def} \NormalTok{mean_pred(y_true, y_pred):} 108 | \ControlFlowTok{return} \NormalTok{K.mean(y_pred)} 109 | 110 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(optimizer}\OperatorTok{=}\StringTok{'rmsprop'}\NormalTok{,} 111 | \NormalTok{loss}\OperatorTok{=}\StringTok{'binary_crossentropy'}\NormalTok{,} 112 | \NormalTok{metrics}\OperatorTok{=}\NormalTok{[}\StringTok{'accuracy'}\NormalTok{, mean_pred])} 113 | \end{Highlighting} 114 | \end{Shaded} 115 | \newpage 116 | -------------------------------------------------------------------------------- /chapter/8_optimizers.tex: -------------------------------------------------------------------------------- 1 | \section{优化器 Optimizers}\label{optimizers} 2 | \subsection{优化器的用法} 3 | 4 | 优化器(optimizer)是编译Keras模型的所需的两个参数之一： 5 | 6 | \begin{Shaded} 7 | \begin{Highlighting}[] 8 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{optimizers} 9 | 10 | \NormalTok{model }\OperatorTok{=} \NormalTok{Sequential()} 11 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, kernel_initializer}\OperatorTok{=}\StringTok{'uniform'}\NormalTok{, input_shape}\OperatorTok{=}\NormalTok{(}\DecValTok{10}\NormalTok{,)))} 12 | \NormalTok{model.add(Activation(}\StringTok{'tanh'}\NormalTok{))} 13 | \NormalTok{model.add(Activation(}\StringTok{'softmax'}\NormalTok{))} 14 | 15 | \NormalTok{sgd }\OperatorTok{=} \NormalTok{optimizers.SGD(lr}\OperatorTok{=}\FloatTok{0.01}\NormalTok{, decay}\OperatorTok{=}\FloatTok{1e-6}\NormalTok{, momentum}\OperatorTok{=}\FloatTok{0.9}\NormalTok{, nesterov}\OperatorTok{=}\VariableTok{True}\NormalTok{)} 16 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'mean_squared_error'}\NormalTok{, optimizer}\OperatorTok{=}\NormalTok{sgd)} 17 | \end{Highlighting} 18 | \end{Shaded} 19 | 20 | 你可以先实例化一个优化器对象，然后将它传入\texttt{model.compile()}，像上述示例中一样， 21 | 或者你可以通过名称来调用优化器。在后一种情况下，将使用优化器的默认参数。 22 | 23 | \begin{Shaded} 24 | \begin{Highlighting}[] 25 | \CommentTok{# 传入优化器名称: 默认参数将被采用} 26 | \NormalTok{model.}\BuiltInTok{compile}\NormalTok{(loss}\OperatorTok{=}\StringTok{'mean_squared_error'}\NormalTok{, optimizer}\OperatorTok{=}\StringTok{'sgd'}\NormalTok{)} 27 | \end{Highlighting} 28 | \end{Shaded} 29 | 30 | 31 | \subsection{Keras优化器的公共参数}\label{kerasux4f18ux5316ux5668ux7684ux516cux5171ux53c2ux6570} 32 | 33 | 参数\texttt{clipnorm}和\texttt{clipvalue}能在所有的优化器中使用，用于控制梯度裁剪（Gradient 34 | Clipping）： 35 | 36 | \begin{Shaded} 37 | \begin{Highlighting}[] 38 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{optimizers} 39 | 40 | \CommentTok{# 所有参数梯度将被裁剪，让其l2范数最大为1：g * 1 / max(1, l2_norm)} 41 | \NormalTok{sgd }\OperatorTok{=} \NormalTok{optimizers.SGD(lr}\OperatorTok{=}\FloatTok{0.01}\NormalTok{, clipnorm}\OperatorTok{=}\DecValTok{1}\NormalTok{.)} 42 | \end{Highlighting} 43 | \end{Shaded} 44 | 45 | \begin{Shaded} 46 | \begin{Highlighting}[] 47 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{optimizers} 48 | 49 | \CommentTok{# 所有参数d 梯度将被裁剪到数值范围内：} 50 | \CommentTok{# 最大值0.5} 51 | \CommentTok{# 最小值-0.5} 52 | \NormalTok{sgd }\OperatorTok{=} \NormalTok{optimizers.SGD(lr}\OperatorTok{=}\FloatTok{0.01}\NormalTok{, clipvalue}\OperatorTok{=}\FloatTok{0.5}\NormalTok{)} 53 | \end{Highlighting} 54 | \end{Shaded} 55 | 56 | 57 | 58 | \subsubsection{SGD {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L135}{{[}source{]}}}} 59 | 60 | \begin{Shaded} 61 | \begin{Highlighting}[] 62 | \NormalTok{keras.optimizers.SGD(lr}\OperatorTok{=}\FloatTok{0.01}\NormalTok{, momentum}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, decay}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, nesterov}\OperatorTok{=}\VariableTok{False}\NormalTok{)} 63 | \end{Highlighting} 64 | \end{Shaded} 65 | 66 | 随机梯度下降优化器 67 | 68 | 包含扩展功能的支持： - 动量（momentum）优化, - 69 | 学习率衰减（每次参数更新后） - Nestrov动量(NAG)优化 70 | 71 | \textbf{参数} 72 | 73 | \begin{itemize} 74 | \tightlist 75 | \item 76 | \textbf{lr}: float \textgreater{}= 0. 学习率 77 | \item 78 | \textbf{momentum}: float \textgreater{}= 0. 79 | 参数，用于加速SGD在相关方向上前进，并抑制震荡 80 | \item 81 | \textbf{decay}: float \textgreater{}= 0. 每次参数更新后学习率衰减值. 82 | \item 83 | \textbf{nesterov}: boolean. 是否使用Nesterov动量. 84 | \end{itemize} 85 | 86 | 87 | 88 | \subsubsection{RMSprop {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L198}{{[}source{]}}}} 89 | 90 | \begin{Shaded} 91 | \begin{Highlighting}[] 92 | \NormalTok{keras.optimizers.RMSprop(lr}\OperatorTok{=}\FloatTok{0.001}\NormalTok{, rho}\OperatorTok{=}\FloatTok{0.9}\NormalTok{, epsilon}\OperatorTok{=}\VariableTok{None}\NormalTok{, decay}\OperatorTok{=}\FloatTok{0.0}\NormalTok{)} 93 | \end{Highlighting} 94 | \end{Shaded} 95 | 96 | RMSProp优化器. 97 | 98 | 建议使用优化器的默认参数 （除了学习率lr，它可以被自由调节） 99 | 100 | 这个优化器通常是训练循环神经网络RNN的不错选择。 101 | 102 | \textbf{参数} 103 | 104 | \begin{itemize} 105 | \tightlist 106 | \item 107 | \textbf{lr}: float \textgreater{}= 0. 学习率. 108 | \item 109 | \textbf{rho}: float \textgreater{}= 0. 110 | RMSProp梯度平方的移动均值的衰减率. 111 | \item 112 | \textbf{epsilon}: float \textgreater{}= 0. 模糊因子. 若为 113 | \texttt{None}, 默认为 \texttt{K.epsilon()}. 114 | \item 115 | \textbf{decay}: float \textgreater{}= 0. 每次参数更新后学习率衰减值. 116 | \end{itemize} 117 | 118 | \textbf{引用} 119 | 120 | \begin{itemize} 121 | \tightlist 122 | \item 123 | \href{http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf}{rmsprop: 124 | Divide the gradient by a running average of its recent magnitude} 125 | \end{itemize} 126 | 127 | 128 | 129 | 130 | \subsubsection{Adagrad {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L265}{{[}source{]}}}} 131 | 132 | \begin{Shaded} 133 | \begin{Highlighting}[] 134 | \NormalTok{keras.optimizers.Adagrad(lr}\OperatorTok{=}\FloatTok{0.01}\NormalTok{, epsilon}\OperatorTok{=}\VariableTok{None}\NormalTok{, decay}\OperatorTok{=}\FloatTok{0.0}\NormalTok{)} 135 | \end{Highlighting} 136 | \end{Shaded} 137 | 138 | Adagrad优化器. 139 | 140 | 建议使用优化器的默认参数。 141 | 142 | \textbf{参数} 143 | 144 | \begin{itemize} 145 | \tightlist 146 | \item 147 | \textbf{lr}: float \textgreater{}= 0. 学习率. 148 | \item 149 | \textbf{epsilon}: float \textgreater{}= 0. 若为 \texttt{None}, 默认为 150 | \texttt{K.epsilon()}. 151 | \item 152 | \textbf{decay}: float \textgreater{}= 0. 每次参数更新后学习率衰减值. 153 | \end{itemize} 154 | 155 | \textbf{引用} 156 | 157 | \begin{itemize} 158 | \tightlist 159 | \item 160 | \href{http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf}{Adaptive 161 | Subgradient Methods for Online Learning and Stochastic Optimization} 162 | \end{itemize} 163 | 164 | 165 | 166 | 167 | \subsubsection{Adadelta {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L324}{{[}source{]}}}} 168 | 169 | \begin{Shaded} 170 | \begin{Highlighting}[] 171 | \NormalTok{keras.optimizers.Adadelta(lr}\OperatorTok{=}\FloatTok{1.0}\NormalTok{, rho}\OperatorTok{=}\FloatTok{0.95}\NormalTok{, epsilon}\OperatorTok{=}\VariableTok{None}\NormalTok{, decay}\OperatorTok{=}\FloatTok{0.0}\NormalTok{)} 172 | \end{Highlighting} 173 | \end{Shaded} 174 | 175 | Adagrad优化器. 176 | 177 | 建议使用优化器的默认参数。 178 | 179 | \textbf{参数} 180 | 181 | \begin{itemize} 182 | \tightlist 183 | \item 184 | \textbf{lr}: float \textgreater{}= 0. 学习率，建议保留默认值. 185 | \item 186 | \textbf{rho}: float \textgreater{}= 0. 187 | Adadelta梯度平方移动均值的衰减率 188 | \item 189 | \textbf{epsilon}: float \textgreater{}= 0. 模糊因子. 若为 190 | \texttt{None}, 默认为 \texttt{K.epsilon()}. 191 | \item 192 | \textbf{decay}: float \textgreater{}= 0. 每次参数更新后学习率衰减值. 193 | \end{itemize} 194 | 195 | \textbf{引用} 196 | 197 | \begin{itemize} 198 | \tightlist 199 | \item 200 | \href{http://arxiv.org/abs/1212.5701}{Adadelta - an adaptive learning 201 | rate method} 202 | \end{itemize} 203 | 204 | 205 | 206 | 207 | \subsubsection{Adam {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L397}{{[}source{]}}}} 208 | 209 | \begin{Shaded} 210 | \begin{Highlighting}[] 211 | \NormalTok{keras.optimizers.Adam(lr}\OperatorTok{=}\FloatTok{0.001}\NormalTok{, beta_1}\OperatorTok{=}\FloatTok{0.9}\NormalTok{, beta_2}\OperatorTok{=}\FloatTok{0.999}\NormalTok{, epsilon}\OperatorTok{=}\VariableTok{None}, \\ 212 | \hspace{4cm}\NormalTok{decay}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, amsgrad}\OperatorTok{=}\VariableTok{False}\NormalTok{)} 213 | \end{Highlighting} 214 | \end{Shaded} 215 | 216 | Adam优化器. 217 | 218 | 默认参数遵循原论文中提供的值。 219 | 220 | \textbf{参数} 221 | 222 | \begin{itemize} 223 | \tightlist 224 | \item 225 | \textbf{lr}: float \textgreater{}= 0. 学习率. 226 | \item 227 | \textbf{beta\_1}: float, 0 \textless{} beta \textless{} 1. 通常接近于 228 | 1. 229 | \item 230 | \textbf{beta\_2}: float, 0 \textless{} beta \textless{} 1. 通常接近于 231 | 1. 232 | \item 233 | \textbf{epsilon}: float \textgreater{}= 0. 模糊因子. 若为 234 | \texttt{None}, 默认为 \texttt{K.epsilon()}. 235 | \item 236 | \textbf{decay}: float \textgreater{}= 0. 每次参数更新后学习率衰减值. 237 | \item 238 | \textbf{amsgrad}: boolean. 是否应用此算法的AMSGrad变种，来自论文"On 239 | the Convergence of Adam and Beyond". 240 | \end{itemize} 241 | 242 | \textbf{引用} 243 | 244 | \begin{itemize} 245 | \tightlist 246 | \item 247 | \href{http://arxiv.org/abs/1412.6980v8}{Adam - A Method for Stochastic 248 | Optimization} 249 | \item 250 | \href{https://openreview.net/forum?id=ryQu7f-RZ}{On the Convergence of 251 | Adam and Beyond} 252 | \end{itemize} 253 | 254 | 255 | 256 | 257 | \subsubsection{Adamax {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L486}{{[}source{]}}}} 258 | 259 | \begin{Shaded} 260 | \begin{Highlighting}[] 261 | \NormalTok{keras.optimizers.Adamax(lr}\OperatorTok{=}\FloatTok{0.002}\NormalTok{, beta_1}\OperatorTok{=}\FloatTok{0.9}\NormalTok{, beta_2}\OperatorTok{=}\FloatTok{0.999}\NormalTok{, epsilon}\OperatorTok{=}\VariableTok{None}\NormalTok{, decay}\OperatorTok{=}\FloatTok{0.0}\NormalTok{)} 262 | \end{Highlighting} 263 | \end{Shaded} 264 | 265 | Adamax优化器，来自Adam论文的第七小节. 266 | 267 | 它是Adam算法基于无穷范数（infinity norm）的变种。 268 | 默认参数遵循论文中提供的值。 269 | 270 | \textbf{参数} 271 | 272 | \begin{itemize} 273 | \tightlist 274 | \item 275 | \textbf{lr}: float \textgreater{}= 0. 学习率. 276 | \item 277 | \textbf{beta\_1/beta\_2}: floats, 0 \textless{} beta \textless{} 1. 278 | 通常接近于 1. 279 | \item 280 | \textbf{epsilon}: float \textgreater{}= 0. 模糊因子. 若为 281 | \texttt{None}, 默认为 \texttt{K.epsilon()}. 282 | \item 283 | \textbf{decay}: float \textgreater{}= 0. 每次参数更新后学习率衰减值. 284 | \end{itemize} 285 | 286 | \textbf{引用} 287 | 288 | \begin{itemize} 289 | \tightlist 290 | \item 291 | \href{http://arxiv.org/abs/1412.6980v8}{Adam - A Method for Stochastic 292 | Optimization} 293 | \end{itemize} 294 | 295 | 296 | 297 | 298 | \subsubsection{Nadam {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L563}{{[}source{]}}}} 299 | 300 | \begin{Shaded} 301 | \begin{Highlighting}[] 302 | \NormalTok{keras.optimizers.Nadam(lr}\OperatorTok{=}\FloatTok{0.002}\NormalTok{, beta_1}\OperatorTok{=}\FloatTok{0.9}\NormalTok{, beta_2}\OperatorTok{=}\FloatTok{0.999}\NormalTok{, epsilon}\OperatorTok{=}\VariableTok{None}, \\ 303 | \hspace{4cm}\NormalTok{schedule_decay}\OperatorTok{=}\FloatTok{0.004}\NormalTok{)} 304 | \end{Highlighting} 305 | \end{Shaded} 306 | 307 | Nesterov版本Adam优化器. 308 | 309 | 正像Adam本质上是RMSProp与动量momentum的结合， Nadam是采用Nesterov 310 | momentum版本的Adam优化器。 311 | 312 | 默认参数遵循论文中提供的值。 建议使用优化器的默认参数。 313 | 314 | \textbf{参数} 315 | 316 | \begin{itemize} 317 | \tightlist 318 | \item 319 | \textbf{lr}: float \textgreater{}= 0. 学习率. 320 | \item 321 | \textbf{beta\_1/beta\_2}: floats, 0 \textless{} beta \textless{} 1. 322 | 通常接近于 1. 323 | \item 324 | \textbf{epsilon}: float \textgreater{}= 0. 模糊因子. 若为 325 | \texttt{None}, 默认为 \texttt{K.epsilon()}. 326 | \end{itemize} 327 | 328 | \textbf{引用} 329 | 330 | \begin{itemize} 331 | \tightlist 332 | \item 333 | \href{http://cs229.stanford.edu/proj2015/054_report.pdf}{Nadam report} 334 | \item 335 | \href{http://www.cs.toronto.edu/~fritz/absps/momentum.pdf}{On the 336 | importance of initialization and momentum in deep learning} 337 | \end{itemize} 338 | 339 | 340 | 341 | \subsubsection{TFOptimizer {\href{https://github.com/keras-team/keras/blob/master/keras/optimizers.py\#L649}{{[}source{]}}}} 342 | 343 | \begin{Shaded} 344 | \begin{Highlighting}[] 345 | \NormalTok{keras.optimizers.TFOptimizer(optimizer)} 346 | \end{Highlighting} 347 | \end{Shaded} 348 | 349 | 原生Tensorlfow优化器的包装类（wrapper class）。 350 | \newpage 351 | -------------------------------------------------------------------------------- /chapter/9_activations.tex: -------------------------------------------------------------------------------- 1 | \section{激活函数 Activations}\label{activations} 2 | \subsection{激活函数的用法} 3 | 4 | 激活函数可以通过设置单独的激活层实现，也可以在构造层对象时通过传递\texttt{activation}参数实现 5 | 6 | \begin{Shaded} 7 | \begin{Highlighting}[] 8 | \ImportTok{from} \NormalTok{keras.layers }\ImportTok{import} \NormalTok{Activation, Dense} 9 | 10 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{))} 11 | \NormalTok{model.add(Activation(}\StringTok{'tanh'}\NormalTok{))} 12 | \end{Highlighting} 13 | \end{Shaded} 14 | 15 | 等价于 16 | 17 | \begin{Shaded} 18 | \begin{Highlighting}[] 19 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, activation}\OperatorTok{=}\StringTok{'tanh'}\NormalTok{))} 20 | \end{Highlighting} 21 | \end{Shaded} 22 | 23 | 你也可以通过传递一个逐元素运算的Theano/TensorFlow/CNTK函数来作为激活函数： 24 | 25 | \begin{Shaded} 26 | \begin{Highlighting}[] 27 | \ImportTok{from} \NormalTok{keras }\ImportTok{import} \NormalTok{backend }\ImportTok{as} \NormalTok{K} 28 | 29 | \NormalTok{model.add(Dense(}\DecValTok{64}\NormalTok{, activation}\OperatorTok{=}\NormalTok{K.tanh))} 30 | \NormalTok{model.add(Activation(K.tanh))} 31 | \end{Highlighting} 32 | \end{Shaded} 33 | 34 | \subsection{预定义激活函数}\label{ux9884ux5b9aux4e49ux6fc0ux6d3bux51fdux6570} 35 | 36 | \subsubsection{softmax}\label{softmax} 37 | 38 | \begin{Shaded} 39 | \begin{Highlighting}[] 40 | \NormalTok{softmax(x, axis}\OperatorTok{=-}\DecValTok{1}\NormalTok{)} 41 | \end{Highlighting} 42 | \end{Shaded} 43 | 44 | Softmax 激活函数. 45 | 46 | \textbf{Arguments} 47 | 48 | x : 张量. - \textbf{axis}: 整数, 代表softmax所作用的维度 49 | 50 | \textbf{Returns} 51 | 52 | softmax变换后的张量. 53 | 54 | \textbf{Raises} 55 | 56 | \begin{itemize} 57 | \tightlist 58 | \item 59 | \textbf{ValueError}: In case \texttt{dim(x)\ ==\ 1}. 60 | \end{itemize} 61 | 62 | 63 | 64 | \subsubsection{elu}\label{elu} 65 | 66 | \begin{Shaded} 67 | \begin{Highlighting}[] 68 | \NormalTok{elu(x, alpha}\OperatorTok{=}\FloatTok{1.0}\NormalTok{)} 69 | \end{Highlighting} 70 | \end{Shaded} 71 | 72 | 73 | 74 | \subsubsection{selu}\label{selu} 75 | 76 | \begin{Shaded} 77 | \begin{Highlighting}[] 78 | \NormalTok{selu(x)} 79 | \end{Highlighting} 80 | \end{Shaded} 81 | 82 | 可伸缩的指数线性单元 (Klambauer et al., 2017)。 83 | 84 | \textbf{Arguments} 85 | 86 | \begin{itemize} 87 | \tightlist 88 | \item 89 | \textbf{x}: 一个用来用于计算激活函数的张量或变量。 90 | \end{itemize} 91 | 92 | \textbf{Returns} 93 | 94 | 与\texttt{x}具有相同类型及形状的张量。 95 | 96 | \textbf{Note} 97 | 98 | \begin{itemize} 99 | \tightlist 100 | \item 101 | 与 "lecun\_normal" 初始化方法一起使用。 102 | \item 103 | 与 dropout 的变种 "AlphaDropout" 一起使用。 104 | \end{itemize} 105 | 106 | \textbf{References} 107 | 108 | \begin{itemize} 109 | \tightlist 110 | \item 111 | \href{https://arxiv.org/abs/1706.02515}{Self-Normalizing Neural 112 | Networks} 113 | \end{itemize} 114 | 115 | 116 | 117 | \subsubsection{softplus}\label{softplus} 118 | 119 | \begin{Shaded} 120 | \begin{Highlighting}[] 121 | \NormalTok{softplus(x)} 122 | \end{Highlighting} 123 | \end{Shaded} 124 | 125 | 126 | 127 | \subsubsection{softsign}\label{softsign} 128 | 129 | \begin{Shaded} 130 | \begin{Highlighting}[] 131 | \NormalTok{softsign(x)} 132 | \end{Highlighting} 133 | \end{Shaded} 134 | 135 | 136 | 137 | \subsubsection{relu}\label{relu} 138 | 139 | \begin{Shaded} 140 | \begin{Highlighting}[] 141 | \NormalTok{relu(x, alpha}\OperatorTok{=}\FloatTok{0.0}\NormalTok{, max_value}\OperatorTok{=}\VariableTok{None}\NormalTok{)} 142 | \end{Highlighting} 143 | \end{Shaded} 144 | 145 | 146 | 147 | \subsubsection{tanh}\label{tanh} 148 | 149 | \begin{Shaded} 150 | \begin{Highlighting}[] 151 | \NormalTok{tanh(x)} 152 | \end{Highlighting} 153 | \end{Shaded} 154 | 155 | 156 | 157 | \subsubsection{sigmoid}\label{sigmoid} 158 | 159 | \begin{Shaded} 160 | \begin{Highlighting}[] 161 | \NormalTok{sigmoid(x)} 162 | \end{Highlighting} 163 | \end{Shaded} 164 | 165 | 166 | 167 | \subsubsection{hard\_sigmoid}\label{hardux5fsigmoid} 168 | 169 | \begin{Shaded} 170 | \begin{Highlighting}[] 171 | \NormalTok{hard_sigmoid(x)} 172 | \end{Highlighting} 173 | \end{Shaded} 174 | 175 | 176 | 177 | \subsubsection{linear}\label{linear} 178 | 179 | \begin{Shaded} 180 | \begin{Highlighting}[] 181 | \NormalTok{linear(x)} 182 | \end{Highlighting} 183 | \end{Shaded} 184 | 185 | \subsection{高级激活函数}\label{ux9ad8ux7ea7ux6fc0ux6d3bux51fdux6570} 186 | 187 | 对于Theano/TensorFlow/CNTK不能表达的复杂激活函数，如含有可学习参数的激活函数，可通过\hyperref[advanced-activations]{高级激活函数}实现，如PReLU，LeakyReLU等 188 | \newpage -------------------------------------------------------------------------------- /figure/collect_qrcode.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wanzhenchn/keras-docs-zh/8bef133aa5a9ea537732d5cb09482f2f3c6bcada/figure/collect_qrcode.png -------------------------------------------------------------------------------- /figure/framework_rank.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wanzhenchn/keras-docs-zh/8bef133aa5a9ea537732d5cb09482f2f3c6bcada/figure/framework_rank.png -------------------------------------------------------------------------------- /figure/qrcode_for_BreakIntoAI.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wanzhenchn/keras-docs-zh/8bef133aa5a9ea537732d5cb09482f2f3c6bcada/figure/qrcode_for_BreakIntoAI.jpg -------------------------------------------------------------------------------- /keras-docs-zh.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wanzhenchn/keras-docs-zh/8bef133aa5a9ea537732d5cb09482f2f3c6bcada/keras-docs-zh.pdf -------------------------------------------------------------------------------- /keras-docs-zh.sty: -------------------------------------------------------------------------------- 1 | % Created by WAN Zhen, wanzhen@cqu.edu.cn 2 | % Welcome to contribute! 3 | 4 | \usepackage{graphicx} 5 | \usepackage{titling} 6 | 7 | % set up \maketitle to accept a new item 8 | \pretitle{\begin{center}\placetitlepicture\large\vspace{1.5cm}} 9 | \posttitle{\par\end{center}} 10 | 11 | % commands for including the picture 12 | \newcommand{\titlepicture}[2][]{% 13 | \renewcommand\placetitlepicture{% 14 | \includegraphics[#1]{#2}\par\medskip 15 | }% 16 | } 17 | \newcommand{\placetitlepicture}{} % initialization 18 | 19 | \thanksmarkseries{fnsymbol} 20 | 21 | \usepackage{textcomp} 22 | \usepackage{fontawesome} 23 | \newfontfamily{\FA}{[FontAwesome.otf]} % solve xdvipdfmx pdf_ref_obj() error 24 | 25 | % The hyperref package gives us a pdf with properly built 26 | % internal navigation ('pdf bookmarks' for the table of contents, 27 | % internal cross-reference links, web links for URLs, etc.) 28 | \usepackage{hyperref} 29 | \hypersetup{ % Setup hyperref package 30 | pdftitle = {Keras: 基于 Python 的深度学习库}, 31 | pdfauthor = {万震(wanzhen@cqu.edu.cn)}, 32 | bookmarksnumbered=true, 33 | bookmarksopen=true, 34 | bookmarksopenlevel=3, 35 | breaklinks=true, % so long urls are correctly broken across lines 36 | colorlinks=true, 37 | urlcolor=urlcolor, 38 | linkcolor=linkcolor, 39 | citecolor=citecolor, 40 | } 41 | 42 | \usepackage[T1]{fontenc} 43 | 44 | \usepackage{titlesec} 45 | \setcounter{secnumdepth}{4} % how many sectioning levels to assign numbers to 46 | \setcounter{tocdepth}{4} % how many sectioning levels to show in ToC 47 | \titleformat{\paragraph} 48 | {\normalfont\normalsize\bfseries}{\theparagraph}{1em}{} 49 | \titlespacing*{\paragraph} 50 | {0pt}{3.25ex plus 1ex minus .2ex}{1.5ex plus .2ex} 51 | \newcommand{\subsubsubsection}{\paragraph} %define newcommand \subsubsubsection 52 | 53 | % watermark 54 | \usepackage{tikz} 55 | \usepackage{xcolor} % Allow colors to be defined 56 | \usepackage{eso-pic} 57 | 58 | \newcommand{\watermark}[3]{\AddToShipoutPictureBG{ 59 | \parbox[b][\paperheight]{\paperwidth}{ 60 | \vfill% 61 | \centering% 62 | \tikz[remember picture, overlay]% 63 | \node [rotate = #1, scale = #2] at (current page.center)% 64 | {\textcolor{gray!80!cyan!30}{#3}}; 65 | \vfill}}} 66 | 67 | 68 | % Nicer default font (+ math font) than Computer Modern for most use cases 69 | \usepackage{mathpazo} 70 | 71 | % Basic figure setup, for now with no caption control since it's done 72 | % automatically by Pandoc (which extracts ![](path) syntax from Markdown). 73 | 74 | % We will generate all images so they have a width \maxwidth. This means 75 | % that they will get their normal width if they fit onto the page, but 76 | % are scaled down if they would overflow the margins. 77 | %\makeatletter 78 | %\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth 79 | %\else\Gin@nat@width\fi} 80 | %\makeatother 81 | %\let\Oldincludegraphics\includegraphics 82 | %% Set max figure width to be 80% of text width, for now hardcoded. 83 | %\renewcommand{\includegraphics}[1]{\Oldincludegraphics[width=.5\maxwidth]{#1}} 84 | % Ensure that by default, figures have no caption (until we provide a 85 | % proper Figure object with a Caption API and a way to capture that 86 | % in the conversion process - todo). 87 | \usepackage{caption} 88 | \DeclareCaptionLabelFormat{nolabel}{} 89 | \captionsetup{labelformat=nolabel} 90 | 91 | \usepackage{adjustbox} % Used to constrain images to a maximum size 92 | \usepackage{enumerate} % Needed for markdown enumerations to work 93 | \usepackage{geometry} % Used to adjust the document margins 94 | % Slightly bigger margins than the latex defaults 95 | \geometry{verbose,tmargin=1in,bmargin=1in,lmargin=1in,rmargin=1in} 96 | 97 | \usepackage{amsmath} % Equations 98 | \usepackage{amssymb} % Equations 99 | \usepackage{textcomp} % defines textquotesingle 100 | % Hack from http://tex.stackexchange.com/a/47451/13684: 101 | \AtBeginDocument{% 102 | \def\PYZsq{\textquotesingle}% Upright quotes in Pygmentized code 103 | } 104 | \usepackage{upquote} % Upright quotes for verbatim code 105 | \usepackage{eurosym} % defines \euro 106 | \usepackage[mathletters]{ucs} % Extended unicode (utf-8) support 107 | \usepackage[utf8x]{inputenc} % Allow utf-8 characters in the tex document 108 | \usepackage{fancyvrb} % verbatim replacement that allows latex 109 | \usepackage{grffile} % extends the file name processing of package graphics 110 | % to support a larger range 111 | 112 | \usepackage{longtable} % longtable support required by pandoc >1.10 113 | \usepackage{booktabs} % table support for pandoc > 1.12.2 114 | \usepackage[inline]{enumitem} % IRkernel/repr support (it uses the enumerate* environment) 115 | \usepackage[normalem]{ulem} % ulem is needed to support strikethroughs (\sout) 116 | % normalem makes italics be italics, not underlines 117 | 118 | \usepackage{tikzsymbols} 119 | \usepackage{graphicx} 120 | \usepackage{subfig} 121 | 122 | 123 | % Colors for the hyperref package 124 | \definecolor{urlcolor}{rgb}{0,.145,.698} 125 | \definecolor{linkcolor}{rgb}{.71,0.21,0.01} 126 | \definecolor{citecolor}{rgb}{.12,.54,.11} 127 | 128 | % ANSI colors 129 | \definecolor{ansi-black}{HTML}{3E424D} 130 | \definecolor{ansi-black-intense}{HTML}{282C36} 131 | \definecolor{ansi-red}{HTML}{E75C58} 132 | \definecolor{ansi-red-intense}{HTML}{B22B31} 133 | \definecolor{ansi-green}{HTML}{00A250} 134 | \definecolor{ansi-green-intense}{HTML}{007427} 135 | \definecolor{ansi-yellow}{HTML}{DDB62B} 136 | \definecolor{ansi-yellow-intense}{HTML}{B27D12} 137 | \definecolor{ansi-blue}{HTML}{208FFB} 138 | \definecolor{ansi-blue-intense}{HTML}{0065CA} 139 | \definecolor{ansi-magenta}{HTML}{D160C4} 140 | \definecolor{ansi-magenta-intense}{HTML}{A03196} 141 | \definecolor{ansi-cyan}{HTML}{60C6C8} 142 | \definecolor{ansi-cyan-intense}{HTML}{258F8F} 143 | \definecolor{ansi-white}{HTML}{C5C1B4} 144 | \definecolor{ansi-white-intense}{HTML}{A1A6B2} 145 | 146 | % commands and environments needed by pandoc snippets 147 | % extracted from the output of `pandoc -s` 148 | \providecommand{\tightlist}{% 149 | \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}} 150 | \DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}} 151 | % Add ',fontsize=\small' for more characters per line 152 | \newenvironment{Shaded}{}{} 153 | \newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{{#1}}}} 154 | \newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.56,0.13,0.00}{{#1}}} 155 | \newcommand{\DecValTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}} 156 | \newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}} 157 | \newcommand{\FloatTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}} 158 | \newcommand{\CharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}} 159 | \newcommand{\StringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}} 160 | \newcommand{\CommentTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textit{{#1}}}} 161 | \newcommand{\OtherTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{{#1}}} 162 | \newcommand{\AlertTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}} 163 | \newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.02,0.16,0.49}{{#1}}} 164 | \newcommand{\RegionMarkerTok}[1]{{#1}} 165 | \newcommand{\ErrorTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}} 166 | \newcommand{\NormalTok}[1]{{#1}} 167 | 168 | % Additional commands for more recent versions of Pandoc 169 | \newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.53,0.00,0.00}{{#1}}} 170 | \newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}} 171 | \newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}} 172 | \newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.73,0.40,0.53}{{#1}}} 173 | \newcommand{\ImportTok}[1]{{#1}} 174 | \newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.73,0.13,0.13}{\textit{{#1}}}} 175 | \newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}} 176 | \newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}} 177 | \newcommand{\VariableTok}[1]{\textcolor[rgb]{0.10,0.09,0.49}{{#1}}} 178 | \newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{{#1}}}} 179 | \newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.40,0.40,0.40}{{#1}}} 180 | \newcommand{\BuiltInTok}[1]{{#1}} 181 | \newcommand{\ExtensionTok}[1]{{#1}} 182 | \newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.74,0.48,0.00}{{#1}}} 183 | \newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.49,0.56,0.16}{{#1}}} 184 | \newcommand{\InformationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}} 185 | \newcommand{\WarningTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}} 186 | 187 | 188 | % Define a nice break command that doesn't care if a line doesn't already 189 | % exist. 190 | \def\br{\hspace*{\fill} \\* } 191 | % Math Jax compatability definitions 192 | \def\gt{>} 193 | \def\lt{<} 194 | 195 | 196 | 197 | 198 | % Pygments definitions 199 | 200 | \makeatletter 201 | \def\PY@reset{\let\PY@it=\relax \let\PY@bf=\relax% 202 | \let\PY@ul=\relax \let\PY@tc=\relax% 203 | \let\PY@bc=\relax \let\PY@ff=\relax} 204 | \def\PY@tok#1{\csname PY@tok@#1\endcsname} 205 | \def\PY@toks#1+{\ifx\relax#1\empty\else% 206 | \PY@tok{#1}\expandafter\PY@toks\fi} 207 | \def\PY@do#1{\PY@bc{\PY@tc{\PY@ul{% 208 | \PY@it{\PY@bf{\PY@ff{#1}}}}}}} 209 | \def\PY#1#2{\PY@reset\PY@toks#1+\relax+\PY@do{#2}} 210 | 211 | \expandafter\def\csname PY@tok@cpf\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}} 212 | \expandafter\def\csname PY@tok@gp\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}} 213 | \expandafter\def\csname PY@tok@kn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 214 | \expandafter\def\csname PY@tok@s\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 215 | \expandafter\def\csname PY@tok@sc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 216 | \expandafter\def\csname PY@tok@nb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 217 | \expandafter\def\csname PY@tok@vi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}} 218 | \expandafter\def\csname PY@tok@w\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.73,0.73}{##1}}} 219 | \expandafter\def\csname PY@tok@gh\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}} 220 | \expandafter\def\csname PY@tok@il\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 221 | \expandafter\def\csname PY@tok@fm\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}} 222 | \expandafter\def\csname PY@tok@gu\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.50,0.00,0.50}{##1}}} 223 | \expandafter\def\csname PY@tok@nv\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}} 224 | \expandafter\def\csname PY@tok@na\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.49,0.56,0.16}{##1}}} 225 | \expandafter\def\csname PY@tok@ss\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}} 226 | \expandafter\def\csname PY@tok@se\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.13}{##1}}} 227 | \expandafter\def\csname PY@tok@ch\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}} 228 | \expandafter\def\csname PY@tok@ni\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.60,0.60,0.60}{##1}}} 229 | \expandafter\def\csname PY@tok@m\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 230 | \expandafter\def\csname PY@tok@ge\endcsname{\let\PY@it=\textit} 231 | \expandafter\def\csname PY@tok@gr\endcsname{\def\PY@tc##1{\textcolor[rgb]{1.00,0.00,0.00}{##1}}} 232 | \expandafter\def\csname PY@tok@sa\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 233 | \expandafter\def\csname PY@tok@nt\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 234 | \expandafter\def\csname PY@tok@sb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 235 | \expandafter\def\csname PY@tok@gt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.27,0.87}{##1}}} 236 | \expandafter\def\csname PY@tok@s2\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 237 | \expandafter\def\csname PY@tok@sd\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 238 | \expandafter\def\csname PY@tok@vg\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}} 239 | \expandafter\def\csname PY@tok@nn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}} 240 | \expandafter\def\csname PY@tok@k\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 241 | \expandafter\def\csname PY@tok@nc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}} 242 | \expandafter\def\csname PY@tok@si\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}} 243 | \expandafter\def\csname PY@tok@mf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 244 | \expandafter\def\csname PY@tok@kc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 245 | \expandafter\def\csname PY@tok@mb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 246 | \expandafter\def\csname PY@tok@bp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 247 | \expandafter\def\csname PY@tok@o\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 248 | \expandafter\def\csname PY@tok@c\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}} 249 | \expandafter\def\csname PY@tok@nl\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.63,0.00}{##1}}} 250 | \expandafter\def\csname PY@tok@vm\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}} 251 | \expandafter\def\csname PY@tok@ne\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.82,0.25,0.23}{##1}}} 252 | \expandafter\def\csname PY@tok@go\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}} 253 | \expandafter\def\csname PY@tok@nf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}} 254 | \expandafter\def\csname PY@tok@mi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 255 | \expandafter\def\csname PY@tok@cp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.74,0.48,0.00}{##1}}} 256 | \expandafter\def\csname PY@tok@sr\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}} 257 | \expandafter\def\csname PY@tok@no\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.00,0.00}{##1}}} 258 | \expandafter\def\csname PY@tok@mh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 259 | \expandafter\def\csname PY@tok@cm\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}} 260 | \expandafter\def\csname PY@tok@kd\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 261 | \expandafter\def\csname PY@tok@kp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 262 | \expandafter\def\csname PY@tok@vc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}} 263 | \expandafter\def\csname PY@tok@sx\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 264 | \expandafter\def\csname PY@tok@sh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 265 | \expandafter\def\csname PY@tok@mo\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}} 266 | \expandafter\def\csname PY@tok@kr\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}} 267 | \expandafter\def\csname PY@tok@gs\endcsname{\let\PY@bf=\textbf} 268 | \expandafter\def\csname PY@tok@c1\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}} 269 | \expandafter\def\csname PY@tok@ow\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}} 270 | \expandafter\def\csname PY@tok@cs\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}} 271 | \expandafter\def\csname PY@tok@gi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.63,0.00}{##1}}} 272 | \expandafter\def\csname PY@tok@dl\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 273 | \expandafter\def\csname PY@tok@nd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}} 274 | \expandafter\def\csname PY@tok@kt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.69,0.00,0.25}{##1}}} 275 | \expandafter\def\csname PY@tok@err\endcsname{\def\PY@bc##1{\setlength{\fboxsep}{0pt}\fcolorbox[rgb]{1.00,0.00,0.00}{1,1,1}{\strut ##1}}} 276 | \expandafter\def\csname PY@tok@gd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.00,0.00}{##1}}} 277 | \expandafter\def\csname PY@tok@s1\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}} 278 | 279 | \def\PYZbs{\char`\\} 280 | \def\PYZus{\char`\_} 281 | \def\PYZob{\char`\{} 282 | \def\PYZcb{\char`\}} 283 | \def\PYZca{\char`\^} 284 | \def\PYZam{\char`\&} 285 | \def\PYZlt{\char`\<} 286 | \def\PYZgt{\char`\>} 287 | \def\PYZsh{\char`\#} 288 | \def\PYZpc{\char`\%} 289 | \def\PYZdl{\char`\$} 290 | \def\PYZhy{\char`\-} 291 | \def\PYZsq{\char`\'} 292 | \def\PYZdq{\char`\"} 293 | \def\PYZti{\char`\~} 294 | % for compatibility with earlier versions 295 | \def\PYZat{@} 296 | \def\PYZlb{[} 297 | \def\PYZrb{]} 298 | \makeatother 299 | 300 | 301 | % Exact colors from NB 302 | \definecolor{incolor}{rgb}{0.0, 0.0, 0.5} 303 | \definecolor{outcolor}{rgb}{0.545, 0.0, 0.0} 304 | 305 | 306 | % Prevent overflowing lines due to hard-to-break entities 307 | \sloppy 308 | -------------------------------------------------------------------------------- /keras-docs-zh.tex: -------------------------------------------------------------------------------- 1 | % !TEX program = xelatex 2 | % Created by WAN Zhen, wanzhen@cqu.edu.cn 3 | % Welcome to contribute! 4 | 5 | 6 | \documentclass[11pt,a4paper,titlepage]{ctexart} 7 | 8 | \usepackage{keras-docs-zh} 9 | 10 | \begin{document} 11 | 12 | \pdfbookmark[0]{Keras: 基于 Python的深度学习库}{title} 13 | 14 | \titlepicture[width=.5\textwidth]{logo/keras-logo.png} 15 | \title{\huge \href{https://github.com/Godblesswz/keras-docs-zh}{Keras: 基于 Python 的深度学习库 \\ Keras: The Python Deep Learning library}\thanks{Copyright \textcopyright\ 2018 by \href{https://github.com/keras-team}{Keras-Team}}\vspace{0.7cm}} 16 | \author{\Large Author: \href{https://github.com/keras-team}{Keras-Team}\vspace{0.2cm}\\ 17 | Contributor: \Large\kaishu{\href{https://github.com/wanzhenchn}{万\ 震 (WAN Zhen)}} \vspace{0.2cm}\\ 18 | {\color{blue}\faGithub}\hspace{0.1cm} {\href{https://github.com/wanzhenchn}{wanzhenchn}}\\ 19 | {\color{blue}\faEnvelopeO}\hspace{0.1cm}{{wanzhen@cqu.edu.cn}} 20 | \vspace{0.6cm}} 21 | \date{\today} 22 | 23 | \maketitle 24 | %\clearpage\maketitle 25 | %\thispagestyle{empty} 26 | 27 | %%==========preface============= 28 | 29 | \input{preface/preface} 30 | 31 | 32 | %%==========content============= 33 | \pdfbookmark[1]{\contentsname}{toc} 34 | 35 | %目录单栏排版 36 | \begingroup %对目录部分单独处理 37 | \pagenumbering{Roman} %gobble关闭页码计数 38 | %\pagestyle{empty} %清除页眉页脚 39 | \tableofcontents %生成目录 40 | \endgroup 41 | \clearpage 42 | \pagenumbering{arabic}%打开页码计数, roman、Roman 43 | 44 | 45 | %%==========main body============= 46 | 47 | %\watermark{60}{8}{WAN Zhen} % watermar 48 | 49 | \input{chapter/1-1_intro} 50 | \input{chapter/1-2_why_use_keras} 51 | \input{chapter/2-1_sequential-model-guide} 52 | \input{chapter/2-2_functional-api-guide} 53 | \input{chapter/2-3_faq} 54 | \input{chapter/3-1_about-keras-models} 55 | \input{chapter/3-2_Sequential} 56 | \input{chapter/3-3_model} 57 | \input{chapter/4-1_about-keras-layers} 58 | \input{chapter/4-2_core} 59 | \input{chapter/4-3_convolutional} 60 | \input{chapter/4-4_pooling} 61 | \input{chapter/4-5_locally-connected} 62 | \input{chapter/4-6_recurrent} 63 | \input{chapter/4-7_embedding} 64 | \input{chapter/4-8_merge} 65 | \input{chapter/4-9_advanced-activations} 66 | \input{chapter/4-10_normalization} 67 | \input{chapter/4-11_noise} 68 | \input{chapter/4-12_wrappers} 69 | \input{chapter/4-13_writing-your-own-keras-layers} 70 | \input{chapter/5-1_preprocessing-sequence} 71 | \input{chapter/5-2_preprocessing-text} 72 | \input{chapter/5-3_preprocessing-image} 73 | \input{chapter/6_losses} 74 | \input{chapter/7_metrics} 75 | \input{chapter/8_optimizers} 76 | \input{chapter/9_activations} 77 | \input{chapter/10_callbacks} 78 | \input{chapter/11_datasets} 79 | \input{chapter/12_applications} 80 | \input{chapter/13_backend} 81 | \input{chapter/14_initializers} 82 | \input{chapter/15_regularizers} 83 | \input{chapter/16_constraints} 84 | \input{chapter/17_visualization} 85 | \input{chapter/18_scikit-learn-api} 86 | \input{chapter/19_utils} 87 | \input{chapter/20_contributing} 88 | 89 | \input{preface/support} 90 | \end{document} 91 | -------------------------------------------------------------------------------- /logo/keras-logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wanzhenchn/keras-docs-zh/8bef133aa5a9ea537732d5cb09482f2f3c6bcada/logo/keras-logo.png -------------------------------------------------------------------------------- /preface/preface.tex: -------------------------------------------------------------------------------- 1 | \pdfbookmark[1]{前言}{abstract}% "0" = section level 2 | \renewcommand{\abstractname}{\Large 前\ 言} 3 | \begin{abstract} 4 | \vspace{2cm} 5 | 6 | 整理 \href{https://keras.io/zh/}{Keras: 基于 Python 的深度学习库} PDF 版的主要原因在于学习 \href{https://keras.io/zh/}{Keras} 深度学习库时方便\textbf{本地查阅}，下载最新PDF版本请访问: \url{https://github.com/wanzhenchn/keras-docs-zh}。 7 | 8 | 感谢 \href{https://github.com/keras-team/keras-docs-zh}{keras-team} 所做的中文翻译工作，本文档制作基于此处。 9 | 10 | \textbf{严正声明：本文档可免费用于学习和科学研究，可自由传播，但切勿擅自用于商业用途，由此引发一切后果贡献者概不负责}。\\ 11 | 12 | The main reason of organizing PDF version based the \href{https://github.com/keras-team/keras-docs-zh}{Chinese Keras Markdown} is that it is easy to \textbf{read locally} when learning the Keras Deep Learning Library. For the latest PDF version, please visit \url{https://github.com/wanzhenchn/keras-docs-zh}. 13 | 14 | Thanks for the Chinese translation work done by \href{https://github.com/keras-team}{keras-team}, this document is produced based on it. 15 | 16 | \textbf{Statement: This document can be freely used for learning and scientific research and is freely disseminated, but it must not be used for commercial purposes. Otherwise, the contributor is not responsible for the consequences.} 17 | 18 | \end{abstract} 19 | -------------------------------------------------------------------------------- /preface/support.tex: -------------------------------------------------------------------------------- 1 | \newpage 2 | 3 | {\color{red}\faHeart}\hspace{0.1cm} 更多科研资源，请扫码关注微信公众号： 4 | \begin{figure}[h] 5 | \centering 6 | \subfloat{{\includegraphics[width=0.4\textwidth]{figure/qrcode_for_BreakIntoAI} }} 7 | \end{figure} 8 | 9 | \vspace{0.5cm} 10 | 11 | {\color{red}\faHeart}\hspace{0.1cm} 如诸君认为本文档对您的使用和研究略有帮助，不妨扫码请笔者喝杯咖啡，以鼓励作者进一步完善文档内容，提高文档质量。\dSmiley 12 | 13 | \begin{figure}[h] 14 | \begin{center} 15 | \includegraphics[width=0.4\textwidth]{figure/collect_qrcode} 16 | \end{center} 17 | \end{figure} 18 | 19 | \thispagestyle{empty} --------------------------------------------------------------------------------