├── .gitignore ├── Makefile ├── README.md ├── bootstrap.sh ├── cjkfonts.sty ├── contents ├── acknowledgements.tex ├── applications.tex ├── autoencoders.tex ├── beamermindmap.nav ├── beamermindmap.snm ├── beamermindmap.tex ├── convnets.tex ├── generative_models.tex ├── glossaries.tex ├── graphical_models.tex ├── guidelines.tex ├── inference.tex ├── intro.tex ├── linear_algebra.tex ├── linear_factors.tex ├── ml.tex ├── mlp.tex ├── monte_carlo.tex ├── notation.tex ├── numerical.tex ├── optimization.tex ├── part_basics.tex ├── part_practical.tex ├── part_research.tex ├── partition.tex ├── prob.tex ├── regularization.tex ├── representation.tex ├── rnn.tex └── title.tex ├── dlbook-complete.bib ├── dlbook.tex └── figures ├── approximate_minimization.pdf ├── computational_graphs.pdf ├── critical_points.pdf ├── curvature_in_hessian.pdf ├── different_ai_disciplines.pdf ├── different_representations.pdf ├── eigen_effect.pdf ├── figure-18.1.jpg ├── figure18-1.png ├── gradient_descent.pdf ├── identity_matrix.pdf ├── illustration_of_a_deep_learning_model.pdf ├── saddle_point.pdf ├── second_derivative.pdf ├── transpose_of_matrix.pdf └── venn_diagram.pdf /.gitignore: -------------------------------------------------------------------------------- 1 | .texpadtmp 2 | auto 3 | /fonts/ 4 | /*.pdf 5 | 6 | *.log 7 | *.aux 8 | *.out 9 | *.toc 10 | *.lb 11 | *.idx 12 | *.ind 13 | *.ilg 14 | *.xdy 15 | *.gls 16 | *.glg 17 | *.glo 18 | 19 | *.DS_Store 20 | *.run.xml 21 | *.blg 22 | *.bcf 23 | *.bbl 24 | *-blx.bib 25 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # Makefile 2 | # 3 | 4 | TEX = xelatex 5 | MKIDX = makeindex 6 | MKBIB = bibtex 7 | MKGLS = makeglossaries 8 | RM = rm -rf 9 | MAKE = make 10 | TARGET = dlbook.pdf 11 | SOURCES := $(wildcard *.tex) 12 | FIGURESDEPS := $(wildcard figures/*.eps) 13 | FIGURESDEPS := $(wildcard figures/*.pdf) 14 | FIGURESDEPS += $(wildcard figures/*.png) 15 | FIGURESDEPS += $(wildcard figures/*.jpg) 16 | CONTENTS := $(wildcard contents/*.tex) 17 | 18 | .PHONY: all 19 | 20 | all: $(TARGET) 21 | 22 | $(TARGET): $(SOURCES) $(FIGURESDEPS) $(CONTENTS) dlbook-complete.bib 23 | $(TEX) $(basename $@) 24 | $(MKBIB) $(basename $@) 25 | $(MKIDX) $(basename $@) 26 | $(MKGLS) $(basename $@) 27 | $(TEX) $(basename $@) # compile twice to make sure the toc is generated 28 | $(TEX) $(basename $@) # compile 3 times to make sure index/bibliography/glossary files are generated 29 | 30 | clean: 31 | # $(MAKE) -C graphics clean 32 | $(RM) *.pdf 33 | $(RM) *.aux 34 | $(RM) *.log 35 | $(RM) *.out 36 | $(RM) *.toc 37 | $(RM) *.idx 38 | $(RM) *.ilg 39 | $(RM) *.ind 40 | $(RM) *.glg 41 | $(RM) *.glo 42 | $(RM) *.gls 43 | $(RM) *.xdy 44 | $(RM) *.bbl 45 | $(RM) *.blg 46 | $(RM) *.run.xml 47 | $(RM) *-blx.bib 48 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Deep Learning Book 2 | ================== 3 | 4 | **This is a skeleton for Deep Learning Book Chinese Version.** 5 | 6 | ## Compile the LaTeX Source Code 7 | 8 | To compile the source code to a PDF file, please make sure you have a latest TeX 9 | system installed. You can download and install a TeX distribution for your 10 | platform from http://tug.org. 11 | 12 | It's recommended to install: 13 | 14 | - [Tex Live](http://tug.org/texlive/) 2015 or later for Linux 15 | - [MacTex](http://tug.org/mactex/) 2015 or later for Mac OS X 16 | 17 | ### Check out source code 18 | 19 | Use git to clone this repository and the code samples as a sub module: 20 | 21 | ```shell 22 | $ git clone https://github.com/tigerneil/dlbook-zh-cn.git 23 | ``` 24 | 25 | ### Prepare Fonts 26 | 27 | Run the `bootstrap.sh` in the working copy to download required fonts: 28 | 29 | ``` shell 30 | $ ./bootstrap.sh 31 | ``` 32 | 33 | This is a simple shell script to download the following free fonts into `fonts/` folder: 34 | 35 | - [Google Noto Sans CJK SC](https://noto-website-2.storage.googleapis.com/pkgs/NotoSansCJKsc-hinted.zip) 36 | - [Google Roboto](https://github.com/google/roboto/releases/download/v2.134/roboto-unhinted.zip) 37 | - [Adobe Source Serif Pro](https://github.com/adobe-fonts/source-serif-pro/archive/1.017R.zip) 38 | - [Adobe Source Code Pro](https://github.com/adobe-fonts/source-code-pro/archive/2.030R-ro/1.050R-it.zip) 39 | 40 | You can also manually download and unarchive to `fonts/`, and make sure it contains: 41 | 42 | ```shell 43 | fonts/ 44 | ├── NotoSansCJKsc-Black.otf 45 | ├── NotoSansCJKsc-Bold.otf 46 | ├── NotoSansCJKsc-DemiLight.otf 47 | ├── NotoSansCJKsc-Light.otf 48 | ├── NotoSansCJKsc-Medium.otf 49 | ├── NotoSansCJKsc-Regular.otf 50 | ├── NotoSansCJKsc-Thin.otf 51 | ├── NotoSansMonoCJKsc-Bold.otf 52 | ├── NotoSansMonoCJKsc-Regular.otf 53 | ├── Roboto-Black.ttf 54 | ├── Roboto-BlackItalic.ttf 55 | ├── Roboto-Bold.ttf 56 | ├── Roboto-BoldItalic.ttf 57 | ├── Roboto-Italic.ttf 58 | ├── Roboto-Light.ttf 59 | ├── Roboto-LightItalic.ttf 60 | ├── Roboto-Medium.ttf 61 | ├── Roboto-MediumItalic.ttf 62 | ├── Roboto-Regular.ttf 63 | ├── Roboto-Thin.ttf 64 | ├── Roboto-ThinItalic.ttf 65 | ├── RobotoCondensed-Bold.ttf 66 | ├── RobotoCondensed-BoldItalic.ttf 67 | ├── RobotoCondensed-Italic.ttf 68 | ├── RobotoCondensed-Light.ttf 69 | ├── RobotoCondensed-LightItalic.ttf 70 | ├── RobotoCondensed-Regular.ttf 71 | ├── SourceCodePro-Black.otf 72 | ├── SourceCodePro-BlackIt.otf 73 | ├── SourceCodePro-Bold.otf 74 | ├── SourceCodePro-BoldIt.otf 75 | ├── SourceCodePro-ExtraLight.otf 76 | ├── SourceCodePro-ExtraLightIt.otf 77 | ├── SourceCodePro-It.otf 78 | ├── SourceCodePro-Light.otf 79 | ├── SourceCodePro-LightIt.otf 80 | ├── SourceCodePro-Medium.otf 81 | ├── SourceCodePro-MediumIt.otf 82 | ├── SourceCodePro-Regular.otf 83 | ├── SourceCodePro-Semibold.otf 84 | ├── SourceCodePro-SemiboldIt.otf 85 | ├── SourceSerifPro-Black.otf 86 | ├── SourceSerifPro-Bold.otf 87 | ├── SourceSerifPro-ExtraLight.otf 88 | ├── SourceSerifPro-Light.otf 89 | ├── SourceSerifPro-Regular.otf 90 | └── SourceSerifPro-Semibold.otf 91 | 92 | 0 directories, 47 files 93 | ``` 94 | 95 | ### Generate PDF 96 | 97 | Run 98 | 99 | ``` shell 100 | $ make 101 | ``` 102 | 103 | to typeset and generate the PDF document. Or use your favorite GUI TeX 104 | application, but choose `XeLaTeX` as the typeset engine to support the chinese 105 | fonts. 106 | -------------------------------------------------------------------------------- /bootstrap.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | NOTO_SANS_CJKSC_URL="https://noto-website-2.storage.googleapis.com/pkgs/NotoSansCJKsc-hinted.zip" 4 | ROBOTO_URL="https://github.com/google/roboto/releases/download/v2.134/roboto-unhinted.zip" 5 | SOURCE_SERIF_PRO_URL="https://github.com/adobe-fonts/source-serif-pro/archive/1.017R.zip" 6 | SOURCE_CODE_PRO_URL="https://github.com/adobe-fonts/source-code-pro/archive/2.030R-ro/1.050R-it.zip" 7 | 8 | SYSTEM=`uname -s` 9 | 10 | if [ "x$SYSTEM" = "xDarwin" ]; then 11 | SCRIPTPATH=$(cd `dirname "${BASH_SOURCE[0]}"` && pwd) 12 | else 13 | SCRIPTPATH=$(dirname $(readlink -f "$0")) 14 | fi 15 | 16 | TMPDIR=`mktemp -d` 17 | FONTDIR="${SCRIPTPATH}/fonts" 18 | 19 | mkdir -p $FONTDIR || exit 1 20 | 21 | trap "{ cd -; rm -rf $TMPDIR; exit 255; }" INT 22 | 23 | cd $TMPDIR # switch to temp dir 24 | echo "Change to ${TMPDIR}" 25 | 26 | # Get NotoSans 27 | filename=$(basename ${NOTO_SANS_CJKSC_URL}) 28 | wget ${NOTO_SANS_CJKSC_URL} 29 | unzip $filename 30 | cp -f *.otf ${FONTDIR} 31 | 32 | # Get Roboto 33 | filename=$(basename ${ROBOTO_URL}) 34 | folder=${filename%.zip} 35 | wget ${ROBOTO_URL} 36 | unzip $filename 37 | cp -f ${folder}/*.ttf ${FONTDIR} 38 | 39 | # Get Source Serif Pro 40 | filename=$(basename ${SOURCE_SERIF_PRO_URL}) 41 | folder="source-serif-pro-${filename%.zip}" 42 | wget ${SOURCE_SERIF_PRO_URL} 43 | unzip $filename 44 | cp -f ${folder}/OTF/*.otf ${FONTDIR} 45 | 46 | # Get Source Code Pro 47 | filename=$(basename ${SOURCE_CODE_PRO_URL}) 48 | folder="source-code-pro-2.030R-ro-${filename%.zip}" 49 | wget ${SOURCE_CODE_PRO_URL} 50 | unzip $filename 51 | cp -f ${folder}/OTF/*.otf ${FONTDIR} 52 | 53 | cd - # back to current folder 54 | rm -rf $TMPDIR 55 | 56 | exit 0 57 | -------------------------------------------------------------------------------- /cjkfonts.sty: -------------------------------------------------------------------------------- 1 | % cjkfonts.sty 2 | % 3 | % A XeLaTeX package for typesetting CJK documents. 4 | % 5 | % Author: Freeman Zhang 6 | % Version: 0.1 7 | % Homepage: https://github.com/zhanggyb/cjkfonts 8 | % 9 | % Options: 10 | % path: The path where can find cjkfonts font files. 11 | % mdseries: choose one of Thin, Light, DemiLight, Regular, Medium, Bold, Black for text with medium weight. 12 | % bfseries: choose one of Thin, Light, DemiLight, Regular, Medium, Bold, Black for text with bold face. 13 | % default: boolean option, cjkfonts is set as the default font family and as the sans serif family for CJK text. 14 | 15 | % Identification 16 | % ============== 17 | 18 | \NeedsTeXFormat{LaTeX2e} 19 | \ProvidesPackage{cjkfonts}[2015/12/12 A simple XeLaTeX package to set CJK fonts] 20 | 21 | 22 | % Required Packages 23 | % ================= 24 | 25 | \RequirePackage{ifthen} 26 | \RequirePackage{xeCJK} 27 | 28 | % Set key-value options 29 | \RequirePackage{kvoptions} 30 | \DeclareStringOption[fonts/]{path}[fonts/] 31 | \DeclareStringOption[Regular]{mdseries}[Regular] 32 | \DeclareStringOption[Bold]{bfseries}[Bold] 33 | \DeclareBoolOption[false]{default} 34 | \ProcessKeyvalOptions* 35 | 36 | 37 | %% Configuration for fonts 38 | %% ======================= 39 | 40 | \newCJKfontfamily[NotoSansSC]\NotoSansSC[ 41 | Extension=.otf, 42 | Path=\cjkfonts@path/, 43 | UprightFont=NotoSansCJKsc-\cjkfonts@mdseries, 44 | BoldFont=NotoSansCJKsc-\cjkfonts@bfseries, 45 | ItalicFont=NotoSansCJKsc-\cjkfonts@mdseries, 46 | BoldItalicFont=NotoSansCJKsc-\cjkfonts@bfseries, 47 | ItalicFeatures=FakeSlant, 48 | BoldItalicFeatures=FakeSlant]{NotoSansSC} 49 | 50 | \newCJKfontfamily[NotoSansMonoSC]\NotoSansMonoSC[ 51 | Extension=.otf, 52 | Path=\cjkfonts@path/, 53 | UprightFont=NotoSansMonoCJKsc-Regular, 54 | BoldFont=NotoSansMonoCJKsc-Bold, 55 | ItalicFont=NotoSansMonoCJKsc-Regular, 56 | BoldItalicFont=NotoSansMonoCJKsc-Bold, 57 | ItalicFeatures=FakeSlant, 58 | BoldItalicFeatures=FakeSlant]{NotoSansMonoSC} 59 | 60 | \newCJKfontfamily[NotoSansSCThin]\NotoSansSCThin[ 61 | Extension=.otf, 62 | Path=\cjkfonts@path/, 63 | UprightFont=NotoSansCJKsc-Thin, 64 | AutoFakeSlant=true]{NotoSansSC} 65 | 66 | \newCJKfontfamily[NotoSansSCLight]\NotoSansSCLight[ 67 | Extension=.otf, 68 | Path=\cjkfonts@path/, 69 | UprightFont=NotoSansCJKsc-Light, 70 | AutoFakeSlant=true]{NotoSansSC} 71 | 72 | \newCJKfontfamily[NotoSansSCDemiLight]\NotoSansSCDemiLight[ 73 | Extension=.otf, 74 | Path=\cjkfonts@path/, 75 | UprightFont=NotoSansCJKsc-DemiLight, 76 | AutoFakeSlant=true]{NotoSansSC} 77 | 78 | \newCJKfontfamily[NotoSansSCRegular]\NotoSansSCRegular[ 79 | Extension=.otf, 80 | Path=\cjkfonts@path/, 81 | UprightFont=NotoSansCJKsc-Regular, 82 | AutoFakeSlant=true]{NotoSansSC} 83 | 84 | \newCJKfontfamily[NotoSansSCMedium]\NotoSansSCMedium[ 85 | Extension=.otf, 86 | Path=\cjkfonts@path/, 87 | UprightFont=NotoSansCJKsc-Medium, 88 | AutoFakeSlant=true]{NotoSansSC} 89 | 90 | \newCJKfontfamily[NotoSansSCBold]\NotoSansSCBold[ 91 | Extension=.otf, 92 | Path=\cjkfonts@path/, 93 | UprightFont=NotoSansCJKsc-Bold, 94 | AutoFakeSlant=true]{NotoSansSC} 95 | 96 | \newCJKfontfamily[NotoSansSCBlack]\NotoSansSCBlack[ 97 | Extension=.otf, 98 | Path=\cjkfonts@path/, 99 | UprightFont=NotoSansCJKsc-Black, 100 | AutoFakeSlant=true]{NotoSansSC} 101 | 102 | \newCJKfontfamily[NotoSansMonoSCRegular]\NotoSansMonoSCRegular[ 103 | Extension=.otf, 104 | Path=\cjkfonts@path/, 105 | UprightFont=NotoSansMonoCJKsc-Regular, 106 | AutoFakeSlant=true]{NotoSansMonoSCRegular} 107 | 108 | \newCJKfontfamily[NotoSansMonoSCBold]\NotoSansMonoSCBold[ 109 | Extension=.otf, 110 | Path=\cjkfonts@path/, 111 | UprightFont=NotoSansMonoCJKsc-Bold, 112 | AutoFakeSlant=true]{NotoSansMonoSCBold} 113 | 114 | \ifthenelse{\boolean{cjkfonts@default}}{ 115 | 116 | \setCJKmainfont[Extension=.otf, 117 | Path=\cjkfonts@path/, 118 | UprightFont=NotoSansCJKsc-\cjkfonts@mdseries, 119 | BoldFont=NotoSansCJKsc-\cjkfonts@bfseries, 120 | ItalicFont=NotoSansCJKsc-\cjkfonts@mdseries, 121 | BoldItalicFont=NotoSansCJKsc-\cjkfonts@bfseries, 122 | ItalicFeatures=FakeSlant, 123 | BoldItalicFeatures=FakeSlant]{NotoSansSC} 124 | 125 | \setCJKsansfont[ 126 | Extension=.otf, 127 | Path=\cjkfonts@path/, 128 | UprightFont=NotoSansCJKsc-\cjkfonts@mdseries, 129 | BoldFont=NotoSansCJKsc-\cjkfonts@bfseries, 130 | ItalicFont=NotoSansCJKsc-\cjkfonts@mdseries, 131 | BoldItalicFont=NotoSansCJKsc-\cjkfonts@bfseries, 132 | ItalicFeatures=FakeSlant, 133 | BoldItalicFeatures=FakeSlant]{NotoSansSC} 134 | 135 | \setCJKmonofont[ 136 | Extension=.otf, 137 | Path=\cjkfonts@path/, 138 | UprightFont=NotoSansMonoCJKsc-Regular, 139 | BoldFont=NotoSansMonoCJKsc-Bold, 140 | ItalicFont=NotoSansMonoCJKsc-Regular, 141 | BoldItalicFont=NotoSansMonoCJKsc-Bold, 142 | ItalicFeatures=FakeSlant, 143 | BoldItalicFeatures=FakeSlant]{NotoSansMonoSC} 144 | 145 | }{} 146 | 147 | 148 | %% This must be the last command 149 | \endinput 150 | -------------------------------------------------------------------------------- /contents/acknowledgements.tex: -------------------------------------------------------------------------------- 1 | \chapter{致谢} 2 | \label{ch:Acknowledgements} 3 | 4 | 没有许多人的贡献，本书是不可能完成的。 5 | -------------------------------------------------------------------------------- /contents/applications.tex: -------------------------------------------------------------------------------- 1 | \chapter{应用} 2 | \label{ch:applications} 3 | 4 | 在这一章，我们描述如何使用\gls*{dl}来解决在计算机视觉、语音识别、自然语言处理和其 5 | 它商业性领域的应用。首先，我们讨论最重要的人工智能应用所需的大规模神经网络实现。 6 | 接下来，我们回顾几个\gls*{dl}已经被用于解决问题的特殊应用领域。虽然\gls*{dl}的一 7 | 个目标是设计能够解决各种各样任务的算法，到目前为止还需要一定程度的专业化。例如， 8 | 视觉任务每个样本需要处理大量输入特征（像素）。语言任务每个输入特征需要对大量可能 9 | 值（词汇表中的单词）建模。 10 | 11 | \section{大规模深度学习} 12 | \label{sec:large_scale_deep_learning} 13 | 14 | \gls*{dl}是基于联结主义的哲学：虽然单个的生物神经元或者机器学习模型中的单个特征并 15 | % See https://en.wikipedia.org/wiki/Connectionism 16 | 不智能，大量神经元或者特征的共同作用可以表现出智能行为。强调这一事实非常重要，神 17 | 经元的数量必须是\textbf{大量的}。主导改进神经网络准确性和任务复杂度~——~那些从 80 18 | 年代至今解决的任务~——~的一个关键因素，是我们使用的网络规模上引人注目的增长。正如 19 | 我们在~\ref{subsec:increasing_model_sizes} 节中看到的，网络规模在过去三十年间以指 20 | 数方式增长，然而人工神经网络仅仅和昆虫的神经系统一样大。 21 | 22 | 因为神经网络的规模是非常重要的，\gls*{dl}需要高性能的硬件和软件基础。 23 | 24 | \subsection{快速的 CPU 实现} 25 | \label{subsec:fast_cpu_implementations} 26 | 27 | 传统上，神经网络利用一台机器的 CPU 训练。今天，这种方法被认为是不够的。我们现在主 28 | 要使用 GPU 运算或者多机联网的 CPU。在移到这些昂贵的装置前，研究人员努力证明 CPU 29 | 无法完成神经网络需要的很高的计算工作量。 30 | 31 | 如何执行高效数值计算的 CPU 代码的描述超出了这本书的范围，但我们在这里强调，仔细为 32 | 特定的 CPU 家族的实现可以产生较大的改进。例如，在 2011 年，最好的 CPU 在使用定点 33 | 运算时，运行神经网络的工作量要快于使用浮点运算。通过创造一个仔细调试的定点实 34 | 现，\citet{Vanhoucke-et-al-2011} 取得了超过一个强大的浮点系统的三倍提速。每个新 35 | 的 CPU 型号有不同的性能特点，所以有时浮点实现也能够更快。重要的原则是，对数值计算 36 | 程序的仔细的专门处理，可以获得很大的回报。其他策略，除了选择是否使用定点或浮点， 37 | 还包括优化数据结构，以避免高速缓存块未命中（cache misses）和使用矢量指令。许多机 38 | 器学习的研究人员忽视了这些实现细节，但当具体实现的性能限制模型的大小时，模型的准 39 | 确性受到影响。 40 | 41 | \subsection{GPU 实现} 42 | \label{subsec:gpu_implementations} 43 | 44 | 大部分现代神经网络的实现基于图形处理单元。图形处理单元（GPU）是最初为图形应用开发 45 | 的专门的硬件组件。视频游戏系统的消费者市场刺激了图形处理硬件的发展。好的视频游戏 46 | 系统所需的性能特性结果发现对神经网络同样有益。 47 | 48 | 视频游戏渲染需要并行快速地执行很多操作。角色和环境模型以三维的顶点坐标列表的形式 49 | 指定。图形卡必须执行许多顶点的矩阵乘除，同时并行地将这些三维坐标转换到二维的屏幕 50 | 坐标。图形卡必须在每个像素执行许多计算，同时并行地确定每个像素的颜色。在这两种情 51 | 况下，计算都相当简单，和一个 CPU 通常遇到的计算工作量相比，并不涉及大量的分支。例 52 | 如，在相同的刚性物体中的每个顶点会被相同的矩阵相乘；没有必要每个顶点用 {\serif 53 | if} 声明求值来确定乘以哪个矩阵。这些计算彼此间也完全无关，这样可以很容易并行化。 54 | 这些计算也涉及处理大量的内存缓存，包括描述每个渲染物体纹理（颜色图案）的位图。结 55 | 合在一起，这导致图形卡被设计成具有高度的并行性和高内存带宽，其代价是相对于传 56 | 统CPU 有一个更低的时钟速度和更少的分支能力。 57 | 58 | 神经网络算法需要和上面描述的实时图形算法相同的性能特性。神经网络通常涉及数量庞大 59 | 的参数、激活值和梯度值的缓存，其中每个都必须在每一步的训练中被完整更新。这些缓存 60 | 大到足够超出传统的桌面计算机的高速缓冲区（cache）而崩溃。GPU，由于它们的高内存带 61 | 宽，提供了一个超过 CPU 的不可抗拒的优势。神经网络训练算法通常不涉及很多分支或者复 62 | 杂控制，所以它们适用于 GPU 硬件。既然神经网络能被分成多个单独的“神经元”，这些“神 63 | 经元”在相同层中能彼此独立地被处理，神经网络很容易从 GPU 计算的并行性获益。 64 | 65 | GPU 硬件最初是如此特殊，它只能用于图形任务。随着时间的过去，GPU 硬件变得更灵活了， 66 | 允许定制子程序用于变换定点坐标或者分配颜色给像素。原则上，没有要求这些像素值要实 67 | 际基于渲染任务。这些 GPU 能通过将计算所得的输出写入到像素值的缓存而被用于特殊的计 68 | 算。\citet{Steinkrau2005} 在一块 GPU 上实现了一个两层的全连接神经网络并宣告了一个 69 | 超过他们基于 CPU 基线的三倍提速。此后不久，\citet{chellapilla:inria-00112631}演示 70 | 了同样的技术能被用于加速有监督的卷积网络。 71 | 72 | 用于神经网络训练的图形卡在\textbf{通用 GPU}发明后得到爆炸性的普及。这些 GP-GPU 能 73 | 够执行任意代码，不仅仅是渲染子程序。NVIDIA 的 CUDA 可编程语言提供了一种类 C 语言 74 | 的方式编写任意代码。有了它们相对方便的编程模型、大规模并行结构和高内存带宽，现 75 | 在GP-GPU 提供了一个用于神经网络编程的理想平台。这一平台在面世之后迅速被深度学习研 76 | 究人员采用 \citep{RainaICML09,Ciresan-2010}。 77 | 78 | 为 GP-GPU 编写有效的代码仍然是一项困难的任务，最好留给专家。在 GPU 上获取好的性能 79 | 需要的技术和在 CPU 上使用的非常不同。例如，好的基于 CPU 的代码通常被设计为尽可能 80 | 从高速缓冲区（cache）读取信息。在 GPU 上，大部分可写的内存位置并没有被高速缓冲， 81 | 所以它其实可以更快来两次计算相同值，而不是一次计算然后从内存读回。GPU 代码本质上 82 | 也是多线程的，不同的线程必须相互间周密协调。例如，如果内存操作可以\textbf{被合 83 | 并}（\textit{coalesced}），它们可以被更快执行。合并的读写发生在几个线程的每一个 84 | 能同时读或写一个它们需要值的时候，作为单次内存处理的一部分。不同的 GPU 模型能够合 85 | 并不同类型的读写模式。通常，在 $n$ 个线程中，线程 $i$ 获取内存的 $i + j$ 字节 86 | 时~——~其中 $j$ 是 $2$ 的某个倍数~——~，内存操作很容易合并。确切的规格随着 GPU 型号 87 | 差异而不同。另一个普遍的对 GPU 的考虑是确保一组中的每一个线程同时执行相同的指令。 88 | 这意味着在 GPU 上分支会很困难。线程被分进小的组，称为\emph{\gls{warps}}。一 89 | 个\gls*{warps}中的每个线程在每个周期中执行相同的指令，所以如果在同一 90 | 个\gls*{warps}中的不同线程需要执行不同的代码路径，这些不同的代码路径必须按次序遍 91 | 历，而不是以平行方式。 92 | 93 | 由于编写高性能 GPU 代码的困难性，研究人员应该构造他们的工作流程来避免为了测试新的 94 | 模型或算法必须编写新的 GPU 代码。通常，可以通过构建一个高性能运算~——~例如卷积和矩 95 | 阵乘法~——~的软件库，然后以调用这些运算库的形式指定模型。例如，机器学习 96 | 库 Pylearn2 \citep{Goodfellow+al-ICML2013-small} 以调用 Theano 97 | \citep{bergstra+al:2010-scipy-short,Bastien-2012} 和 cuda-convnet 98 | \citep{Krizhevsky2010tr} 的形式指定所有它的机器学习算法，它们提供了这些高性能运算。 99 | 这种分解方法也可以缓解多种硬件支持。例如，同样的 Theano 程序可以运行 100 | 在 CPU 或 GPU上，不需要改变任何自身对 Theano 的调用。其它库，例如 TensorFlow 101 | \citep{tensorflow} 和 Torch \citep{Collobert-AISTATS2011} 提供了类似的特性。 102 | 103 | \subsection{大规模分布式实现} 104 | \label{subsec:large_scale_distributed_implementations} 105 | 106 | 在许多情况下，在一台机器上可用的计算资源是不够的。因此，我们想要在多台机器间分配 107 | 训练和推断结果的工作负担。 108 | 109 | 分配推断结果的工作简单，因为每个我们想要处理的能被单独的机器运行。这称 110 | 为\textbf{数据并行}。 111 | 112 | 也可能取得\textbf{模型并行}，其中多台机器在单个数据点上一起工作，每台机器运行模型 113 | 的不同部分。这对于推断结果和训练都很灵活。 114 | 115 | 训练期间的数据并行处理有点难。我们可以增加用于单个 \gls*{SGD} 步骤的小批量数据的 116 | 规模，但是通常我们在性能优化方面得到更少的线性回报。允许多台机器并行地计算多个梯 117 | 度下降步骤会更好。不幸的是，梯度下降的标准定义是一个完全按次序的算法：在步骤 $t$ 118 | 的梯度是一个参数由步骤 $t-1$ 产生的函数。 119 | 120 | 这可以通过使用\textbf{异步随机梯度下降}\citep{NIPS2011_4390}来解决。在这种方法中， 121 | % FIXME: cannot find (Bengio et al., 2001) 122 | 几个处理器核心共享表示参数的内存。每个核心在不锁定的情况下读取参数，计算一个梯度， 123 | 然后在不锁定的情况下递增这些参数。这减少了每个梯度下降步骤得出改进的平均量，因为 124 | 一些核心复写了彼此的进度，但是那些步骤产生的增加的速率使得学习进程整体上更 125 | 快。\citet{NIPS2012_4687}首创了这用于梯度下降的无锁方法的多机实现，其中参数由一台 126 | 参数服务器管理，而不是存储在共享内存中。分布式异步梯度下降仍然是训练大规模深度网 127 | 络的主要策略，并且被大多数行业内主要的深度学习群体使用\citep{186212, 128 | DBLP:journals/corr/WuYSDS15}。大学院校的深度学习研究人员通常不能负担得起同样规 129 | 模的分布式学习系统，但是一些研究人员已经专注于如何用在大学环境中可取得的相对低成 130 | 本的硬件构建分布式网络\citep{coates2013deep}。 131 | 132 | \subsection{模型压缩} 133 | \label{subsec:model_compression} 134 | 135 | 在许多商业应用中，在一个机器学习模型中花费低的时间和内存开销用于运行推断，要比花 136 | 费低的时间和内存开销用于训练，要重要得多。对于那些不需要个性化的应用，训练一个模 137 | 型一次，然后将它部署由数十亿用户使用，这是可能的。在许多情况下，最终用户比开发者 138 | 有更多的资源约束。例如，一种情况可能是用一个强大的计算机集群训练一个语音识别网络， 139 | 然后把它部署到移动电话。 140 | 141 | 一个减少推断开销的关键策略是\textbf{模型压缩}\citep{Ungar:2006:1150402}。模型压 142 | 缩的基本思想是用一个更小的模型~——~它需要更少的内存和运行时间来存储和求值~——~代替 143 | 原始的代价昂贵的模型。 144 | 145 | 模型压缩适用于当原始模型的规模主要由因为避免\gls*{overfitting}的需要而驱动。在大 146 | 多数情况下，具有最低的\gls*{generalization_error}的模型由几个独立地训练过的模型组 147 | 合而成。计算所有 $n$ 个组合中成员的值代价昂贵。有时候，甚至单个的模型，如果规模很 148 | 大，泛化得更好（例如，如果使用\gls*{dropout}来规范化）。 149 | 150 | 这些大的模型学习某个函数 151 | $f(\pmb{x})$，但是这样做使用比必要的任务更多的参数。它们的规模是必要的，仅仅因为 152 | 数量有限的训练样本。一旦我们拟合了这个函数$f(\pmb{x})$，我们能简单地通过在随机取 153 | 样的点 $\pmb{x}$ 上应用 154 | $f$，来生成一个包含无限多样本的训练集。为了最有效地利用新的、小模型的能力，最好从 155 | 一个类似于实际测试输入~——~这些输入会在后面提供给模型~——~的分布中取样新 156 | 的 $\pmb{x}$ 点。这可以通过使训练样本出错，或者从一个在原始训练集训练的、可生成的 157 | 模型绘制点来完成。 158 | 159 | 另外，可以只在原始训练点上训练较小的模型，但训练它复制模型的其它特征，如它后面的 160 | 在错误分类上的分布。 161 | 162 | \subsection{动态结构} 163 | \label{subsec:dynamic_structure} 164 | 165 | 通常，加速数据处理系统的一个策略是构建在图中有\textbf{动态结构}~——~这里的图描述需 166 | 要处理一个输入的计算~——~的系统。数据处理系统能够动态地确定许多神经网络的哪个子集 167 | 应该在给定的输入上运行。单独的神经网络也可以在内部通过确定特征（隐藏单元）的哪个 168 | 子集计算来自输入的给定信息来表现出动态结构。这种神经网络内动态结构的形式有时候被 169 | 称为\textbf{条件计算}(Bengio, 2013; Bengio et al., 2013b)。既然许多架构中的组件可 170 | 以只和少量的可能输入相关，通过计算这些仅仅需要时计算的特征，系统能运行得更快。 171 | 172 | 动态结构是一种基本的计算机科学原理，广泛应用于整个软件工程学科。应用于神经网络的 173 | 动态结构的最简单的版本，是在确定某组神经网络（或其他机器学习模型）的哪个子集应该 174 | 应用于一个特定的输入的基础上。 175 | 176 | 在分类器中加速推断的一个历史悠久的策略，是使用一个分类器的\textbf{级联}。当目标是 177 | 检测是否存在一个特殊对象（或事件）时，可以使用级联策略。要确定该对象是存在的，我 178 | 们必须使用一个具有高容量的复杂精巧的分类器，运行它代价昂贵。然而，因为对象是特殊 179 | 的，我们通常能使用少得多的计算来舍弃不包含对象的输入。在这些情况下，我们可以训练 180 | 一系列的分类器。序列中的第一层分类器有低的容量，并被训练为具有高召回率。换句话说， 181 | 它们被训练为确保我们没有错误地舍弃对象存在时的输入。最后的分类器被训练为具有高精 182 | 度。在测试时，我们通过按序列地运行推断，一旦任何级联中的元素舍弃任何样本就立即抛 183 | 弃它。总体而言，这使我们有很高的信心能够验证的对象的存在，使用一个高容量的模型， 184 | 但不强迫我们为每一个样本付出充分推断的代价。级联有 2 种不同的方式可以实现高容量。 185 | 一种方法是使级联的后面成员各自具有很高的容量。在这种情况下，整个系统作为一个整体， 186 | 显然具有很高的容量，因为它的一些单独成员是这样。也可能制定这样一个级联，其中每个 187 | 单独的模型有低容量，但是整个系统因为是由许多小的模型组成而有高容量。Viola and 188 | Jones (2001) 使用了一个\gls{bdt}的级联实现一个适用于手持数字相机的快速和鲁棒的人 189 | 脸探测器。他们的分类器用本质上是个滑动窗口~——~其中许多窗口被检测，如果它们不包含 190 | 人脸则被舍弃~——~的方法来确定一个人脸的位置。级联的另一个版本使用初期的模型来实现 191 | 一种硬性的引人注意的机制：级联的初期成员确定一个物体的位置，而级联后期的成员在给 192 | 定的物体位置执行更进一步的处理。例如，谷歌使用一个两步的级联从街景影响中转录地址 193 | 编号，第一步使用一个机器学习模型确定地址编号的位置，然后用另一个转录 194 | 它(Goodfellow et al., 2014d)。 195 | 196 | 决策树本身就是一个动态结构的例子，因为树中的每个节点决定了它的哪些子数应该对每个 197 | 输入求值。实现深度学习和动态结构的结合，一个简单的方法是训练这样一个决策树，其中 198 | 每个节点使用一个神经网络来作出分解的判决\citep{guo1992classification}，虽然这通常 199 | 没有随着加速推断计算的首要目标完成。 200 | 201 | 本着同样的精神，可以使用一个称为\textbf{门限}的神经网络来从几个\textbf{专家网 202 | 络}中的选择哪一个会被用于对给定的当前输入计算输出。 203 | 204 | \subsection{深度网络的专用硬件实现} 205 | \label{subsec:specialized_hardware_implementations_of_deep_networks} 206 | 207 | \section{计算机视觉} 208 | \label{sec:computer_vision} 209 | 210 | 计算机视觉历来是深度学习应用最为活跃的一个应用领域，因为视觉是一个对于人类和许多 211 | 动物天生的，但对计算机则是挑战性的任务\citep{ballard1983parallel}。许多对深度学习 212 | 算法的进行基准测量的最流行的任务，是以物体识别或者光学字符识别的形式。 213 | 214 | 计算机视觉是一个非常广泛的领域，涵盖了各种各样的处理图像的方式，和令人惊奇的多种 215 | 多样的应用。计算机视觉的应用范围从再现人的视觉能力、如识别人脸，到创造全新的视觉 216 | 能力的类别。作为后者的一个例子，最近的计算机视觉应用程序可以从感应自视频中可见物 217 | 体的振动识别声音波形\citep{Davis2014VisualMic}。大部分对计算机视觉的深度学习研究 218 | 并没有专注于这样奇异的应用 —— 扩展图像的领域，相反是一个小的 AI 核心，其目的是复 219 | 制人类的能力。大部分针对计算机视觉的深度学习被用于物体识别或检测一些形状，不管这 220 | 意味着报告在一幅图像中存在哪个物体，在图像中框选每一个物体来作注释，从一幅图像中 221 | 转录一系列符号，还是标记图像中的每个像素属于哪个物体。由于可生成的建模已经成为深 222 | 度学习研究的指导性原理，因此还有大量在图像综合分析上使用深度模型的工作。虽然图像 223 | 综合分析通常无中生有地被认为不是计算机视觉的尝试，有图像综合分析能力的模型通常可 224 | 用于图像复原 —— 一个涉及到修复图像中的缺陷或是从图像中移除物体的计算机视觉任务。 225 | 226 | \subsection{预处理} 227 | \label{subsec:preprocessing} 228 | 229 | 许多应用领域需要复杂的预处理，因为原始的输入以一种对很多深度学习架构来说难于表达 230 | 的形式。计算机视觉通常需要相对少的这种预处理。图像应该被标准化，使得它们的像素都 231 | 位于相同的、合理的范围内，例如 $[0,1]$ 或 $[-1,1]$。把位于 $[0,1]$ 的图像和位 232 | 于 $[0,255]$ 的图像混合在一起通常导致失败。格式化图像具有相同的尺度是唯一的一种严 233 | 格必要的预处理。许多计算机视觉的架构需要一个标准尺寸的图像，所以图像必须被裁剪或 234 | 缩放以适应这种大小。然而，即使这种调整并不总是严格要求。一些卷积模型接受不同大小 235 | 的输入和动态调整的混合区域的大小来保持恒定的输出尺寸 (Waibel et al.,1989)。其它卷 236 | 积模型具有大小可变的输出，自动调整输入的大小，例如去噪或者标记图像中每个像素的模 237 | 型\citep{Hadsell-RSS-07}。 238 | 239 | 数据集增强可能被看作是一种只对训练集预处理的方式。数据集增强是一个极好的方法，以 240 | 减少大多数计算机视觉模型的泛化误差。一个相关的适用于测试时间的想法是显示模型的许 241 | 多不同版本的相同的输入（例如，相同的图像，但在稍微不同的位置进行裁切），并对该模 242 | 型的不同实例进行投票来决定输出。后者的想法可以被解释为一个整体方法，并有助于减少 243 | 泛化误差。 244 | 245 | 其他各种预处理同时被施加到训练和测试集，这样的目的是用一个更规范的形式来表示每个 246 | 样本，以减少模型需要考虑的变体的数量。减少数据中的变体数量，既能够减少泛化误差， 247 | 也能减少需要拟合训练集的模型规模。更简单的任务可以通过更小的模型来解决，而更简单 248 | 的解决方案更容易推广。这种预处理通常被设计为移除某些类型的输入数据的变化，这些变 249 | 化对一个人类设计师是很容易形容，并有信心其和任务无关。当训练大数据集和大模型时， 250 | 这种预处理通常就没有必要了，最好只是让模型学习哪种变化性应该变成不变的。例如，用 251 | 于分类 ImageNet 的 AlexNet 系统只有一个预处理步骤：在每个像素的训练样本上减去平均 252 | 值\citep{Krizhevsky-2012}。 253 | 254 | \subsubsection{对比度归一化} 255 | \label{subsubsec:contrast_nomalization} 256 | 257 | 最明显的、对许多任务可以安全移除的变化来源之一，是图像中的对比度。对比度只是指一 258 | 幅图像中明暗像素之间的差异的大小。有很多方法来量化一幅图像的对比度。在深度学习的 259 | 环境中，对比度通常指一幅图像或者其中一块区域中像素的标准偏差。假设我们有一幅由一 260 | 个张量 $\mathsf{X} \in \mathbb{R}^{r \times c \times 3}$ 表示的图像， 261 | 由 $\mathsfit{X}_{i,j,1}$ 表示在第 $i$ 行第 $j$ 列的红色分量强 262 | 度，$\mathsfit{X}_{i,j,2}$ 表示绿色强度，$\mathsfit{X}_{i,j,3}$ 表示蓝色强度。那 263 | 么整个图像的对比度为： 264 | \begin{equation} 265 | \sqrt{\frac{1}{3rc}\displaystyle\sum_{i=1}^r\sum_{j=1}^c\sum_{k=1}^3(\mathsfit{X}_{i,j,k} 266 | - \bar{\pmb{\mathsf{X}}})^2} 267 | \label{eq:12.1} 268 | \end{equation} 269 | 这里 $\bar{\pmb{\mathsf{X}}}$ 是整个图像的平均光强度： 270 | \begin{equation} 271 | \bar{\pmb{\mathsf{X}}} = \frac{1}{3rc}\displaystyle\sum_{i=1}^r\sum_{j=1}^c\sum_{k=1}^3\mathsfit{X}_{i,j,k} 272 | \label{eq:12.2} 273 | \end{equation} 274 | 275 | \emph{\gls{gcn}} (GCN) 的目的是防止图像有不同量的对比度，通过从每个图像中减去的平 276 | 均值，然后调整图像使得它的像素上的标准差等于常数 277 | $s$。这个方法背后复杂的事实，是没有调整因子可以改变一幅零对比度的图像（所有像素都 278 | 有相同强度的图像）。具有非常低但是非零对比度的图像通常有很少的信息内容。除以真正 279 | 的标准偏差通常只在这样的情况下放大传感器的噪声或压缩伪影。这促使对\gls*{bias}引入 280 | 一个小的、正的规范化参数 $\lambda$，标准差的估计。或者，可以限制分母至少 281 | 为 $\epsilon$。给定一个输入图像 $\pmb{\mathsf{X}}$，GCN 生成一个输出图 282 | 像 $\pmb{\mathsf{X}}'$，以这样定义： 283 | \begin{equation} 284 | \mathsfit{X}\,'_{i,j,k} = s \frac{ 285 | \mathsfit{X}_{i,j,k} - \bar{\mathsfit{X}} 286 | }{ 287 | \mathrm{max}\bigg\{\epsilon, \sqrt{\lambda + \frac{1}{3rc}\sum_{i=1}^r\sum_{j=1}^c\sum_{k=1}^3(\mathsfit{X}_{i,j,k} - \bar{\mathsfit{X}})^2}\bigg\} 288 | } 289 | \label{eq:12.3} 290 | \end{equation} 291 | 292 | 由裁剪为感兴趣对象的大量图像组成的数据集，不太可能包含任何具有几乎恒定强度的图像。 293 | 在这种情况下，稳妥的办法是通过设定 $\lambda = 0$ 来实际上忽略小分母的问题，以及 294 | 设定 $\epsilon$ 为一个例如 $10^{(-8)}$ 的极小值来避免极端罕见的情况下被 $0$ 除。 295 | 这是被 Goodfellow et al. (2013a) 使用在 CIFAR-10 数据集上的方法。小的经过随机剪 296 | 裁的图像更可能有接近恒定的强度，使得冒进的规范化更有用。\citet{Coates2011} 在取 297 | 自 CIFAR-10 的小的、随机选择的图像块上使用了 $\epsilon = 0$ 和 $\lambda = 10$。 298 | 299 | 尺度参数 $s$ 通常可以被设置为 $1$，正如 \citet{Coates2011} 做的，或者选为使得每 300 | 一个单独像素有接近 $1$ 的、在样本上的标准偏差，正如 Goodfellow et al. (2013a) 所 301 | 做的。 302 | 303 | 方程~\ref{eq:12.3} 中的标准偏差仅仅是图像的 $L^2$ 归一化的重新调节（假设图像的平 304 | 均值已经被移除）。以标准偏差的形式定义 GCN 比 $L^2$ 归一化更合适，因为标准偏差包 305 | 含像素数量的除数，所以基于标准偏差的 GCN 允许使用相同的 $s$ 而不管图像的大小。然 306 | 而，观察 $L^2$ 归一化，其和标准偏差成比例这一结果能够帮助构建一个有用的直观感受。 307 | 可以将 GCN 理解为将样本映射到一个球体的外壳。参见图 的示例。这可以是一个有用的特 308 | 性，因为神经网络通常在响应空间的方向上比确切的位置更好。响应同一方向上的不同距离 309 | 需要具有共线的权重向量但是不同偏置的隐藏单元。这样的协调性对学习算法可能难于发现。 310 | 此外，许多浅的图形模型有沿着相同线的多个分离模式的问题。GCN 通过减少每个样本到一 311 | 个方向，而不是一个方向和一个距离，避免了这些问题。 312 | 313 | \subsubsection{数据集增强} 314 | \label{subsubsec:dataset_augmentation} 315 | 316 | \section{语音识别} 317 | \label{sec:speech_recognition} 318 | 319 | \section{自然语言处理} 320 | \label{sec:natural_language_processing} 321 | 322 | \subsection{$n$ 元语法模型} 323 | \label{subsec:ngrams} 324 | 325 | \subsection{神经语言模型} 326 | \label{subsec:neural_language_models} 327 | 328 | \subsection{高维输出} 329 | \label{high_dimentional_outputs} 330 | 331 | -------------------------------------------------------------------------------- /contents/autoencoders.tex: -------------------------------------------------------------------------------- 1 | \chapter{自编码器} 2 | \label{ch:autoencoders} 3 | -------------------------------------------------------------------------------- /contents/beamermindmap.nav: -------------------------------------------------------------------------------- 1 | \beamer@endinputifotherversion {3.36pt} 2 | \headcommand {\slideentry {0}{0}{1}{1/5}{}{0}} 3 | \headcommand {\beamer@framepages {1}{5}} 4 | \headcommand {\beamer@partpages {1}{5}} 5 | \headcommand {\beamer@subsectionpages {1}{5}} 6 | \headcommand {\beamer@sectionpages {1}{5}} 7 | \headcommand {\beamer@documentpages {5}} 8 | \headcommand {\def \inserttotalframenumber {1}} 9 | -------------------------------------------------------------------------------- /contents/beamermindmap.snm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/contents/beamermindmap.snm -------------------------------------------------------------------------------- /contents/beamermindmap.tex: -------------------------------------------------------------------------------- 1 | \documentclass{beamer} 2 | \usepackage[utf8]{inputenc} 3 | \usepackage{tikz} 4 | \usetikzlibrary{mindmap,trees,shadows} 5 | \begin{document} 6 | 7 | % Keys to support piece-wise uncovering of elements in TikZ pictures: 8 | % \node[visible on=<2->](foo){Foo} 9 | % \node[visible on=<{2,4}>](bar){Bar} % put braces around comma expressions 10 | % 11 | % Internally works by setting opacity=0 when invisible, which has the 12 | % adavantage (compared to \node<2->(foo){Foo} that the node is always there, hence 13 | % always consumes space plus that coordinate (foo) is always available. 14 | % 15 | % The actual command that implements the invisibility can be overriden 16 | % by altering the style invisible. For instance \tikzsset{invisible/.style={opacity=0.2}} 17 | % would dim the "invisible" parts. Alternatively, the color might be set to white, if the 18 | % output driver does not support transparencies (e.g., PS) 19 | % 20 | \tikzset{ 21 | invisible/.style={opacity=0}, 22 | visible on/.style={alt={#1{}{invisible}}}, 23 | alt/.code args={<#1>#2#3}{% 24 | \alt<#1>{\pgfkeysalso{#2}}{\pgfkeysalso{#3}} % \pgfkeysalso doesn't change the path 25 | }, 26 | } 27 | 28 | \begin{frame} 29 | \frametitle{Charakteristika} 30 | \begin{tikzpicture}[mindmap, concept color=gray!50, font=\sf, text=white] 31 | 32 | \tikzstyle{level 1 concept}+=[font=\sf, sibling angle=90,level distance = 30mm] 33 | 34 | \node[concept,scale=0.7] {Layer Normalisation} 35 | [clockwise from=135] 36 | child[concept color=orange, visible on=<2->]{ node[concept,scale=0.7]{Different subsets of training data} } 37 | child[concept color=orange, visible on=<3->]{ node[concept,scale=0.7]{spliting nn over many machines} } 38 | child[concept color=orange, visible on=<4->]{ node[concept,scale=0.7]{communication} } 39 | child[concept color=orange, visible on=<5->]{ node[concept,scale=0.7]{complex software} }; 40 | 41 | \end{tikzpicture} 42 | 43 | \end{frame} 44 | 45 | \end{document} -------------------------------------------------------------------------------- /contents/convnets.tex: -------------------------------------------------------------------------------- 1 | \chapter{卷积网络} 2 | \label{ch:convnets} 3 | -------------------------------------------------------------------------------- /contents/generative_models.tex: -------------------------------------------------------------------------------- 1 | \chapter{深度生成式模型} 2 | \label{ch:generative_models} 3 | 4 | In this chapter, we present several of the specific kinds of generative models that can be built and trained using the techniques presented in Chapters 16, 17, 18 and 19. All of these models represent probability distributions over multiple variables in some way. Some allow the probability distribution function to be evaluated explicitly. Others do not allow the evaluation of the probability distribution function, but support operations that implicitly require knowledge of it, such as drawing samples from the distribution. Some of these models are structured probabilistic models described in terms of graphs and factors, using the language of graphical models presented in Chapter 16. Others can not easily be described in terms of factors, but represent probability distributions nonetheless. 5 | 6 | 本章我们会介绍几种特定类型的生成式模型，这些模型可以使用在第 16、17、18 和 19 章中讲解的技术来构建和训练。所有这些模型表示了按照某种方式在多个随机变量上的概率分布。某些模型可以显式地计算概率分布函数。其他一些模型不支持 7 | 8 | 9 | \section{玻尔兹曼机} 10 | 玻尔兹曼机最初是作为一种通用的“连接主义”观点被提出的，这是一种学习二元向量上的任意概率分布的方法。(Fahlman et al., 1983; Ackley et al., 1985; Hinton et al., 1984; Hinton and Sejnowski, 1986). 玻尔兹曼机的变体包含其他类型的变量早已成为了比原始版本更加流行的形式。本节，我们简要介绍二元玻尔兹曼机，讨论在训练和推断时会出现的问题。\\ 11 | 12 | 我们在一个 $d$-维二元向量 $\mathbf{x} \in \{0,1\}^d$ 上定义了玻尔兹曼机。玻尔兹曼机是一个基于能量的模型 (Sec. 16.2.4)，这表示我们使用一个能量函数定义了联合概率分布： 13 | $$P(x) = \frac{\exp(-E( \textbf{\emph{x}}))}{Z},$$ 14 | 其中 $E(x)$ 是能量函数，$Z$ 是满足 $\sum_x P(x) = 1$ 配分函数。玻尔兹曼机的能量函数按照下式给定： 15 | $$E(x) = - \textbf{\emph{x}}^\intercal U \textbf{\emph{x}} - \textbf{\emph{b}}^\intercal \textbf{\emph{x}},$$ 16 | 其中 $\mathbb{U}$ 是模型参数的权重矩阵，$b$ 是偏差参数的向量。\\ 17 | 玻尔兹曼机一般情形是，给定一个 $n$-维训练样本的集合。公式 20.1 描述了观察到的变量上的联合概率分布。尽管这样理论上可行，同时却会限制观察变量之间的到交互到权重矩阵上。 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | -------------------------------------------------------------------------------- /contents/glossaries.tex: -------------------------------------------------------------------------------- 1 | %% glossaries 2 | 3 | %% Chapter 1 4 | 5 | \newglossaryentry{ai}{ 6 | name={人工智能}, 7 | description={\emph{Artifical Intelligence}, AI} 8 | } 9 | 10 | \newglossaryentry{dl}{ 11 | name={深度学习}, 12 | description={\emph{Deep Learning}} 13 | } 14 | 15 | \newglossaryentry{knowledge-base}{ 16 | name={知识库}, 17 | description={\emph{Knowledge Base}} 18 | } 19 | 20 | \newglossaryentry{ml}{ 21 | name={机器学习}, 22 | description={\emph{Machine Learning}} 23 | } 24 | 25 | \newglossaryentry{logistic-regression}{ 26 | name={逻辑回归}, 27 | description={\emph{Logistic Regression}} 28 | } 29 | 30 | \newglossaryentry{naive-bayes}{ 31 | name={朴素贝叶斯}, 32 | description={\emph{naive Bayes}} 33 | } 34 | 35 | \newglossaryentry{representations}{ 36 | name={表征}, 37 | description={\emph{Representations}，表征是信息的呈现方式} 38 | } 39 | 40 | \newglossaryentry{rep-learning}{ 41 | name={表征学习}, 42 | description={\emph{Representation Learning}} 43 | } 44 | 45 | \newglossaryentry{autoencoder}{ 46 | name={自编码器}, 47 | description={\emph{Autoencoder (s)}} 48 | } 49 | 50 | \newglossaryentry{encoder}{ 51 | name={编码器}, 52 | description={\emph{encoder}} 53 | } 54 | 55 | \newglossaryentry{decoder}{ 56 | name={解码器}, 57 | description={\emph{decoder}} 58 | } 59 | 60 | \newglossaryentry{fov}{ 61 | name={变化因素}, 62 | description={\emph{factors of variation}} 63 | } 64 | 65 | \newglossaryentry{mlp}{ 66 | name={多层感知器}, 67 | description={\emph{multilayer perceptron}} 68 | } 69 | 70 | %% Chapter 2 71 | 72 | \newglossaryentry{scalar}{ 73 | name={标量}, 74 | description={scalar} 75 | } 76 | 77 | \newglossaryentry{scalars}{ 78 | name={标量}, 79 | description={Scalars} 80 | } 81 | 82 | \newglossaryentry{vec}{ 83 | name={向量}, 84 | description={vector} 85 | } 86 | 87 | \newglossaryentry{vecs}{ 88 | name={向量}, 89 | description={Vectors} 90 | } 91 | 92 | \newglossaryentry{matrix}{ 93 | name={矩阵}, 94 | description={matrix} 95 | } 96 | 97 | \newglossaryentry{matrices}{ 98 | name={矩阵}, 99 | description={Matrices} 100 | } 101 | 102 | \newglossaryentry{tensor}{ 103 | name={张量}, 104 | description={tensor} 105 | } 106 | 107 | \newglossaryentry{tensors}{ 108 | name={张量}, 109 | description={Tensors} 110 | } 111 | 112 | \newglossaryentry{transpose}{ 113 | name={转置}, 114 | description={transpose} 115 | } 116 | 117 | \newglossaryentry{main-diag}{ 118 | name={主对角线}, 119 | description={main diagonal} 120 | } 121 | 122 | \newglossaryentry{broadcasting}{ 123 | name={广播}, 124 | description={broadcasting} 125 | } 126 | 127 | \newglossaryentry{matrix-product}{ 128 | name={矩阵积}, 129 | description={matrix product} 130 | } 131 | 132 | \newglossaryentry{element-product}{ 133 | name={按元素乘积}, 134 | description={element-wise product} 135 | } 136 | 137 | \newglossaryentry{hadamard-product}{ 138 | name={阿达玛乘积}, 139 | description={Hadamard product} 140 | } 141 | 142 | \newglossaryentry{dot-product}{ 143 | name={点乘}, 144 | description={dot product} 145 | } 146 | 147 | \newglossaryentry{matrix-inversion}{ 148 | name={矩阵求逆}, 149 | description={matrix inversion} 150 | } 151 | 152 | \newglossaryentry{identity-matrix}{ 153 | name={单位矩阵}, 154 | description={identity matrix} 155 | } 156 | 157 | \newglossaryentry{linear-comb}{ 158 | name={线性组合}, 159 | description={linear combination} 160 | } 161 | 162 | \newglossaryentry{span}{ 163 | name={生成空间}, 164 | description={span} 165 | } 166 | 167 | \newglossaryentry{column-space}{ 168 | name={列空间}, 169 | description={column space} 170 | } 171 | 172 | \newglossaryentry{range}{ 173 | name={范围}, 174 | description={range} 175 | } 176 | 177 | \newglossaryentry{linear-dep}{ 178 | name={线性相关}, 179 | description={linear dependence} 180 | } 181 | 182 | \newglossaryentry{linearly-dep}{ 183 | name={线性无关}, 184 | description={linearly dependent} 185 | } 186 | 187 | \newglossaryentry{linearly-indep}{ 188 | name={线性无关}, 189 | description={linearly independent} 190 | } 191 | 192 | \newglossaryentry{linear-indep}{ 193 | name={线性无关}, 194 | description={linear independent} 195 | } 196 | 197 | \newglossaryentry{square}{ 198 | name={方的}, 199 | description={square} 200 | } 201 | 202 | \newglossaryentry{singular}{ 203 | name={奇异矩阵}, 204 | description={singular} 205 | } 206 | 207 | \newglossaryentry{norm}{ 208 | name={范数}, 209 | description={norm} 210 | } 211 | 212 | \newglossaryentry{tri-inequal}{ 213 | name={三角不等式}, 214 | description={triangle inequality} 215 | } 216 | 217 | \newglossaryentry{eu-norm}{ 218 | name={欧几里德范数}, 219 | description={Euclidean norm} 220 | } 221 | 222 | \newglossaryentry{max-norm}{ 223 | name={最大值范数}, 224 | description={max norm} 225 | } 226 | 227 | \newglossaryentry{fr-norm}{ 228 | name={弗罗贝尼乌斯范数}, 229 | description={Frobenius norm} 230 | } 231 | 232 | \newglossaryentry{diag}{ 233 | name={对角线}, 234 | description={Diagonal} 235 | } 236 | 237 | \newglossaryentry{symmetric}{ 238 | name={对称}, 239 | description={symmetric} 240 | } 241 | 242 | \newglossaryentry{unit-vec}{ 243 | name={单位向量}, 244 | description={unit vector} 245 | } 246 | 247 | \newglossaryentry{unit-norm}{ 248 | name={单位范数}, 249 | description={unit norm} 250 | } 251 | 252 | \newglossaryentry{ortho}{ 253 | name={正交的}, 254 | description={orthogonal} 255 | } 256 | 257 | \newglossaryentry{orthonormal}{ 258 | name={标准正交的}, 259 | description={orthonormal} 260 | } 261 | 262 | \newglossaryentry{orthonormal-matrix}{ 263 | name={正交矩阵}, 264 | description={orthonormal matrix} 265 | } 266 | 267 | \newglossaryentry{eigen-decompos}{ 268 | name={特征分解}, 269 | description={eigendecomposition} 270 | } 271 | 272 | \newglossaryentry{eigen-vec}{ 273 | name={特征向量}, 274 | description={eigenvector} 275 | } 276 | 277 | \newglossaryentry{eigen-vecs}{ 278 | name={特征向量}, 279 | description={eigenvectors} 280 | } 281 | 282 | \newglossaryentry{eigen-val}{ 283 | name={特征值}, 284 | description={eigenvalue} 285 | } 286 | 287 | \newglossaryentry{eigen-vals}{ 288 | name={特征值}, 289 | description={eigenvalues} 290 | } 291 | 292 | \newglossaryentry{left-eigen-vec}{ 293 | name={左特征向量}, 294 | description={left eigenvector} 295 | } 296 | 297 | \newglossaryentry{positive-definite}{ 298 | name={正定矩阵}, 299 | description={positive definite} 300 | } 301 | 302 | \newglossaryentry{positive-semidefinite}{ 303 | name={半正定矩阵}, 304 | description={positive semidefinite} 305 | } 306 | 307 | \newglossaryentry{negative-definite}{ 308 | name={负定矩阵}, 309 | description={negative definite} 310 | } 311 | 312 | \newglossaryentry{negative-semidefinite}{ 313 | name={半负定矩阵}, 314 | description={negative semidefinite} 315 | } 316 | 317 | \newglossaryentry{svd}{ 318 | name={奇异值分解}, 319 | description={singular value decomposition} 320 | } 321 | 322 | \newglossaryentry{singular-vecs}{ 323 | name={奇异向量}, 324 | description={singular vectors} 325 | } 326 | 327 | \newglossaryentry{singular-vals}{ 328 | name={奇异值}, 329 | description={singular values} 330 | } 331 | 332 | \newglossaryentry{singular-val}{ 333 | name={奇异值}, 334 | description={singular value} 335 | } 336 | 337 | \newglossaryentry{left-singular-vecs}{ 338 | name={左奇异向量}, 339 | description={left-singular vectors} 340 | } 341 | 342 | \newglossaryentry{right-singular-vecs}{ 343 | name={右奇异向量}, 344 | description={right-singular vectors} 345 | } 346 | 347 | \newglossaryentry{moore-penrose-pseudoinverse}{ 348 | name={摩尔--彭若斯广义逆}, 349 | description={Moore-Penrose pseudoinverse} 350 | } 351 | 352 | \newglossaryentry{pca}{ 353 | name={主成分分析}, 354 | description={principal components analysis} 355 | } 356 | 357 | %% Chapter 4 358 | 359 | \newglossaryentry{overflow}{ 360 | name={溢出}, 361 | description={overflow} 362 | } 363 | 364 | \newglossaryentry{underflow}{ 365 | name={下溢}, 366 | description={underflow} 367 | } 368 | 369 | \newglossaryentry{softmax}{ 370 | name={柔性最大值}, 371 | description={softmax} 372 | } 373 | 374 | \newglossaryentry{cond-num}{ 375 | name={条件数}, 376 | description={condition number} 377 | } 378 | 379 | \newglossaryentry{obj-func}{ 380 | name={目标函数}, 381 | description={objective function} 382 | } 383 | 384 | \newglossaryentry{criterion}{ 385 | name={准则}, 386 | description={criterion, criterion funciton 准则函数} 387 | } 388 | 389 | \newglossaryentry{cost-func}{ 390 | name={代价函数}, 391 | description={cost function} 392 | } 393 | 394 | \newglossaryentry{loss-func}{ 395 | name={损失函数}, 396 | description={loss function} 397 | } 398 | 399 | \newglossaryentry{err-func}{ 400 | name={误差函数}, 401 | description={error function} 402 | } 403 | 404 | \newglossaryentry{gradient-descent}{ 405 | name={梯度下降}, 406 | description={gradient descent} 407 | } 408 | 409 | \newglossaryentry{critical-points}{ 410 | name={临界点}, 411 | description={critical points} 412 | } 413 | 414 | \newglossaryentry{stationary-points}{ 415 | name={驻点}, 416 | description={stationary points} 417 | } 418 | 419 | \newglossaryentry{local-min}{ 420 | name={局部最小值}, 421 | description={local minimum} 422 | } 423 | 424 | \newglossaryentry{local-max}{ 425 | name={局部最大值}, 426 | description={local maximum} 427 | } 428 | 429 | \newglossaryentry{saddle-points}{ 430 | name={鞍点}, 431 | description={saddle points} 432 | } 433 | 434 | \newglossaryentry{global-min}{ 435 | name={全局最小值}, 436 | description={global minimum} 437 | } 438 | 439 | \newglossaryentry{partial-derivatives}{ 440 | name={偏导数}, 441 | description={partial derivatives} 442 | } 443 | 444 | \newglossaryentry{gradient}{ 445 | name={梯度}, 446 | description={gradient} 447 | } 448 | 449 | \newglossaryentry{directional-derivative}{ 450 | name={方向导数}, 451 | description={directional derivative} 452 | } 453 | 454 | \newglossaryentry{steepest-descent}{ 455 | name={最陡下降法}, 456 | description={method of steepest descent} 457 | } 458 | 459 | \newglossaryentry{learning-rate}{ 460 | name={学习速率}, 461 | description={learning rate} 462 | } 463 | 464 | \newglossaryentry{line-search}{ 465 | name={线搜索}, 466 | description={line search} 467 | } 468 | 469 | \newglossaryentry{hill-climbing}{ 470 | name={爬山算法}, 471 | description={hill climbing} 472 | } 473 | 474 | \newglossaryentry{jacobian-matrix}{ 475 | name={雅可比矩阵}, 476 | description={Jacobian matrix} 477 | } 478 | 479 | \newglossaryentry{second-derivative}{ 480 | name={二阶导数}, 481 | description={second derivative} 482 | } 483 | 484 | \newglossaryentry{curvature}{ 485 | name={曲率}, 486 | description={curvature} 487 | } 488 | 489 | \newglossaryentry{hessian-matrix}{ 490 | name={海森矩阵}, 491 | description={Hessian matrix} 492 | } 493 | 494 | \newglossaryentry{second-derivative-test}{ 495 | name={二阶导数检测}, 496 | description={second derivative test} 497 | } 498 | 499 | %% Chapter 12 500 | 501 | \newglossaryentry{weight}{ 502 | name={权重}, 503 | description={\emph{Weight}} 504 | } 505 | 506 | \newglossaryentry{bias}{ 507 | name={偏置}, 508 | description={\emph{Bias}} 509 | } 510 | 511 | \newglossaryentry{SGD}{ 512 | name=SGD, 513 | description={\emph{Stochastic Gradient Descent}, 随机梯度下降算法} 514 | } 515 | 516 | \newglossaryentry{warps}{ 517 | name={线程束}, 518 | description={\emph{Warps}，同时运行的一组线程的称呼} 519 | } 520 | 521 | \newglossaryentry{overfitting}{ 522 | name={过度拟合}, 523 | description={\emph{overfitting}，过度拟合，过拟合，过适} 524 | } 525 | 526 | \newglossaryentry{generalization_error}{ 527 | name={泛化误差}, 528 | description={\emph{Generalization error}，泛化误差} 529 | } 530 | 531 | \newglossaryentry{dropout}{ 532 | name={弃权}, 533 | description={\emph{Dropout}, 弃权} 534 | } 535 | 536 | \newglossaryentry{bdt}{ 537 | name={提高决策树}, 538 | description={\emph{Boosted decision trees}} 539 | } 540 | 541 | \newglossaryentry{gcn}{ 542 | name={全局对比度归一化}, 543 | description={\emph{Global contrast normalization}, 全局对比度归一化} 544 | } 545 | 546 | \newglossaryentry{minibatch}{ 547 | name={小批量}, 548 | description={\emph{Minibatch}, 小批量} 549 | } 550 | 551 | \newglossaryentry{mode}{ 552 | name={众数}, 553 | description={\emph{mode}, 众数} 554 | } 555 | -------------------------------------------------------------------------------- /contents/graphical_models.tex: -------------------------------------------------------------------------------- 1 | \chapter{深度学习的结构化概率模型} 2 | \label{ch:graphical_models} 3 | -------------------------------------------------------------------------------- /contents/guidelines.tex: -------------------------------------------------------------------------------- 1 | \chapter{实践方法论} 2 | \label{ch:guidelines} 3 | -------------------------------------------------------------------------------- /contents/inference.tex: -------------------------------------------------------------------------------- 1 | \chapter{近似推断} 2 | \label{ch:inference} 3 | -------------------------------------------------------------------------------- /contents/intro.tex: -------------------------------------------------------------------------------- 1 | % intro.tex 2 | 3 | \chapter{介绍} 4 | \label{ch:intro} 5 | 6 | 长久以来，发明家们梦想着创造会思考的机器。这种愿望至少可以追溯到古希腊时代。神话 7 | 人物皮格马利翁、代达罗斯和赫菲斯托斯都可以被理解为传说中的发明家，而伽拉泰亚、塔 8 | 罗斯和潘多拉都可以被视为是人工生 9 | 命\citep{ovid2004metamorphoses,sparkes1996red,1997works}。 10 | 11 | 当可编程计算机最初被设想时~——~在它被建造的超过一百年前~——~人们就想知道它们是否可 12 | 能变得智能\citep{Lovelace1842}。今天，\emph{\gls{ai} (AI)} 是一个茁壮成长的领域， 13 | 有着许多实际应用和活跃的研究课题。我们期待智能软件来自动化日常的劳动，理解语音或 14 | 图像，进行医学诊断和支持基础科学研究。 15 | 16 | 在\gls*{ai}早期，这个领域快速处理和解决一些问题，这些问题对人类脑力来说是困难的， 17 | 但对计算机来说则相对直接~——~这些问题可以通过一份有条理的、以数学规则的列表形式来 18 | 描述。\gls*{ai}的真正的挑战是解决那些容易被人执行，但是难于规范描述的任务~——~那些 19 | 我们凭直觉不假思索就能解决的问题，例如识别语音中的单词或者图像中的人脸。 20 | 21 | 这本书是关于这些更直观的问题的一个解决方案。这个解决方案是让计算机从经验中学习， 22 | 并以概念层次的形式理解这个世界，其中的每一个概念以和它相联系的、更简单的概念形式 23 | 定义。通过从经验中收集知识，这种方法避免了需要人类操作者规范地去指定计算机需要的 24 | 所有知识。概念的层次结构允许计算机通过建立更简单的概念来学习复杂的概念。如果我们 25 | 绘制一个图，显示这些概念是如何建立在彼此之上的，这幅图会很深，有许多层。因为这个 26 | 原因，我们称这种人工智能的方法为\emph{\gls{dl}}。 27 | 28 | 许多早期的成功的人工智能发生在相对毫无新意和规范的环境中，并不需要电脑有太多的对 29 | 世界的理解。例如，IBM 的深蓝对弈系统在 1997 年击败了世界冠军卡斯帕罗 30 | 夫\citep{Hsu2002}。国际象棋是一个很简单的世界，只包含 64 个位置和 32 个移动方式受 31 | 到严格限制的棋子。设计一个成功的国际象棋策略是一个巨大的成就，但是因为描述棋子的 32 | 集合和移动的困难性，这对计算机不算是挑战。象棋能够通过一个非常简短的完整规则的列 33 | 表来完整描述，很容易由程序员提前提供。 34 | 35 | 具有讽刺意味的是，对一个人类的来说最困难的脑力工作中的那些抽象和规范的任务，对计 36 | 算机却是最简单的。计算机很早就能够击败即使是最优秀的人类国际象棋选手，但最近才能 37 | 与一般人的能力相匹配地识别物体或语音。一个人的日常生活需要大量的关于世界的知识。 38 | 很多这方面的知识是主观的和直观的，因此很难以一种规范的方式表达。计算机需要捕捉到 39 | 相同的知识，以便表现为一种智能的方式。人工智能中的一个关键的挑战是如何将这些非规 40 | 范的知识转化进计算机。 41 | 42 | 几个\gls*{ai}项目寻求用规范的语言来硬编码对于世界的理解。一台计算机可以自动使用逻 43 | 辑推理规则来对这些规范语言中的语句进行推理。这被称为人工智能 44 | 的\emph{\gls{knowledge-base}}\,方法。这些项目没有一个导致重大的成功。其中一个最著 45 | 名的项目是 Cyc \citep{Lenat-1989-book}。Cyc 是一个推理引擎和以一种称为 CycL 语言 46 | 形式的语句数据库。这些语句是由一个人类监督者输入的。这是一个笨拙的过程。人们费很 47 | 大劲来设计有条理的规则，这些规则具有足够的复杂性来准确描述这个世界。例如，Cyc 未 48 | 能理解一个关于一个名叫 Fred 的人在早晨刮脸的故事\citep{MachineChangedWorld}。它的 49 | 推理引擎检测到故事中前后矛盾的地方：它知道人类没有电子器件，但是因为 Fred 正好拿 50 | 着一个电子剃须刀，它坚信这个 ``正在刮脸的 Fred'' 包含有电子器件。于是它询问 51 | 当 Fred在刮脸时还是不是一个人类。 52 | 53 | 依赖于硬编码知识的系统面对的困难，表明 AI 系统需要获得它们自己知识的能力~——~通过 54 | 从原始数据中提取模式的能力。这个能力被称为\emph{\gls{ml}}。\gls*{ml}的引入允许计 55 | 算机处理涉及到真实世界的问题，并且做出显得主观的决定。一个简单的被称 56 | 为\emph{\gls{logistic-regression}}\,的\gls*{ml}算法能够确定是否建议剖腹 57 | 产\citep{MorYosef90}。另一个简单的被称为\emph{\gls{naive-bayes}}\,的\gls*{ml}算法， 58 | 能够从垃圾邮件中区分出合理的邮件。 59 | 60 | 这些简单的\gls*{ml}算法的性能重度依赖给予它们的数据 61 | 的\emph{\gls{representations}}。例如，当\gls*{logistic-regression}被用在建议剖腹 62 | 产时，AI 系统不直接检查病人。相反，医生告诉这个系统一些相关信息，例如有没有子宫疤 63 | 痕。每段包含在病人描述中的信息被称为\textbf{特征}。\gls*{logistic-regression}学习 64 | 病人的每个特征如何与不同的结果想关联。然而，它不能对任意方式定义的特征起作用。如 65 | 果给\gls*{logistic-regression}一幅病人的 MRI 扫描，而不是医生格式化后的报告，它无 66 | 法做出有用的预测。MRI 扫描中独特的像素和分娩中可能发生的并发症有负面的相关性。 67 | 68 | 这种对\gls*{representations}的依赖是一个普遍的现象，出现在整个计算机科学，甚至日 69 | 常生活中。在计算机科学中，诸如搜索一个数据集合这样的操作，如果这个集合被很好地结 70 | 构化和智能地索引，那么这个搜索可以以指数级别加快处理，人们可以很容易地在阿拉伯数 71 | 字上执行算术运算，但在罗马数字上做算术更为耗时。这是不足为奇的， 72 | 对\gls*{representations}的选择在\gls*{ml}算法的性能上有巨大的影响。一个简单的可视 73 | 化示例，参见图~\ref{fig:different_representations}。 74 | 75 | \begin{figure}[h] 76 | \centering 77 | \includegraphics{different_representations} 78 | \caption{不同\gls*{representations}的例子：假设我们想要在一幅散点图中画一条线来 79 | 区分两种数据。在左边的图中，我们使用直角坐标系描述一些数据，而这个任务是不可 80 | 能的。在右边的图中，我们用极坐标描述一些数据，这个任务就变得很容易用一条竖线 81 | 来解决。这个图由 David Warde-Farley 协助生 82 | 成。\label{fig:different_representations}} 83 | \end{figure} 84 | 85 | 这个问题的一个解决方法是使用\gls*{ml}来探索不只是从\gls*{representations}到输出的 86 | 映射，还有\gls*{representations}本身。这个方法被称为\emph{\gls{rep-learning}}。学 87 | 习过的\gls*{representations}往往会导致比手工设计的\gls*{representations}更好的性 88 | 能。它们还允许 AI 系统以最少的人为干预来快速地适应新的任务。一 89 | 个\gls*{rep-learning}算法可以在几分钟内为一个简单的任务发现一个很好的特征集，或者 90 | 对一个复杂的任务，需要几个小时到几个月。手动为一个复杂的任务设计特征需要大量的时 91 | 间和人力；它可能耗费整个研究社区几十年的时间。 92 | 93 | 一个\gls*{rep-learning}算法的典型例子是\emph{\gls{autoencoder}}。一 94 | 个\gls*{autoencoder}由一个\emph{\gls{encoder}}\,和一个\emph{\gls{decoder}}\,组 95 | 成，\gls*{encoder}将输入数据转换为不同形式的表征，\gls*{decoder}将新的表征转换回 96 | 原始格式。\gls*{autoencoder}被训练成当一个输入进 97 | 过\gls*{encoder}然后\gls*{decoder}时保存尽可能多的信息，但也被训练使得新的表征有 98 | 各种很好的特性。不同种类的\gls*{autoencoder}的目的是获得不同性质的特性。 99 | 100 | 当为了学习特征而设计特征或算法时，我们的目标通常是分离能解释被观察数据的% 101 | \emph{\gls{fov}}。在这种背景下，我们用单词``因素''来简单指不同的影响来源；这些因 102 | 素通常不是通过乘法组合。这样的因素通常不是能直接观察得到量。相反，它们可能存在于 103 | 影响到可观察量的物理世界中不可观察的对象或者不可观察的自然力。它们也可能存在于人 104 | 类大脑中的构思，这些构思提供有用的精简解释或推断所观察数据的成因。它们可以被认为 105 | 是概念或抽象，帮助我们理解数据中的丰富的变化。当分析一个语音记录时，\gls*{fov}包 106 | 括说话人的年龄、性别、口音和他们所说的话。当分析一辆汽车的图像时，\gls*{fov}包括 107 | 汽车的位置，汽车的颜色，和太阳的角度和亮度。 108 | 109 | 在许多现实世界的\gls*{ai}应用中的一个主要困难是，许多\gls*{fov}影响每一个我们能够 110 | 观察到的数据。在一辆红色汽车的图像中的单个像素在夜间可能非常接近黑色。汽车轮廓的 111 | 形状取决于视角。大多数应用程序都需要我们去\textbf{理清}\gls*{fov}并丢弃我们不在乎 112 | 的那些。 113 | 114 | 当然，从原始数据中提取这样的高层、抽象的特征是很困难的。许多这些\gls*{fov}，如一 115 | 个说话人的口音，只能通过使用复杂的，几乎是人类水平的对数据的理解来识别。当获取一 116 | 个解决原始问题的表征相当困难，初看上去，\gls*{rep-learning}似乎不能帮助我们。 117 | 118 | \emph{\gls{dl}}\,通过引入以其它更简单的\gls*{representations}的形式所表示的%s 119 | \gls*{representations}，来解决这个\gls*{rep-learning}中的核心问题。\gls*{dl}允许 120 | 计算机从更简单的概念中构建出复杂的概念。 121 | 图~\ref{fig:illustration_of_a_deep_learning_model} 显示了一个\gls*{dl}系统如何能 122 | 够通过结合更简单的概念~——~例如角点和轮廓，这些相应地以边缘的形式定义~——~表示一幅 123 | 人像的概念。 124 | 125 | \begin{figure}[h] 126 | \centering 127 | \includegraphics{illustration_of_a_deep_learning_model} 128 | \caption{一个\gls*{dl}模型的举例。理解原始的传递感觉的输入数据~——~例如这幅表示 129 | 为像素值集合的图像~——~对一台计算机来说是困难的。从一系列像素到一个物体识别的 130 | 特征映射是非常复杂的。学习或评估这个映射，如果直接处理似乎是无法克服 131 | 的。\gls*{dl}通过打破所需的复杂的映射到一系列嵌套的简单的映射~——~每一个由模型 132 | 的一个不同的层描述~——~解决了这个困难。输入被呈现于\textbf{可见层}，之所以这样 133 | 命名，是因为它包含了我们能够观察到的变量。然后，是一系列\textbf{隐藏层}，从图 134 | 像中提取越来越抽象的功能。这些层被称为``隐藏''，因为他们的值没有在数据中给出； 135 | 相反，模型必须确定哪些概念有助于解释所观察数据的关系。这里的图像是由每一个隐 136 | 藏单元表示的某类特征的可视化处理。给定像素，第一层可以很容易地通过比较相邻像 137 | 素的亮度识别边缘。由于第一个隐藏层对边缘的描述，第二个隐藏层可以很容易地搜索 138 | 的角点和扩展的轮廓，它们可识别为边缘的集合。鉴于第二个隐藏层以角点和轮廓形式 139 | 的图像描述，第三个隐藏层可以通过找出特定的轮廓和角点的集合，检测到整个特定物 140 | 体的组成部分。最后，这个包含有物体组成部分形式的图像描述，可以用来识别图像中 141 | 呈现的物体。这些图像在得到\citet{ZeilerFergus14}许可后重新生 142 | 成。\label{fig:illustration_of_a_deep_learning_model}} 143 | \end{figure} 144 | 145 | 这一\gls*{dl}模型的典型示例即是前馈深度网络或者\emph{\gls{mlp}}\,(MLP)。一 146 | 个\gls*{mlp}仅仅是一个数学函数，映射一系列输入值到输出值。这一函数是由许多更简单 147 | 的函数组合而成。你可以把每一个不同数学函数的应用看作提供一个新的输入的表征。 148 | 149 | 学习正确的数据表征的想法提供了\gls*{dl}上的一个观点。\gls*{dl}的另一个观点是，深 150 | 度允许计算机学习一个多步骤的计算机程序。每一层的表征可以被认为是在并行地执行了其 151 | 它一组指令后的计算机内存的状态。具有更大深度的网络可以在序列中执行更多的指令。顺 152 | 序指令提供了很大的能力，因为以后的指令可以参考前期指令的结果。根据\gls*{dl}的这个 153 | 观点，一层的激活中并不是所有的信息必须编码解释输入的\gls*{fov}。表征还存储状态信 154 | 息，有助于执行一个可以使输入有意义的程序。这个状态信息可以类似于一个传统的计算机 155 | 程序中的计数器或指针。它与输入的具体内容无关，但它帮助模型组织它的处理。 156 | 157 | 有两种主要的方法来衡量一个模型的深度。第一种观点基于为了评估整个架构必须执行的顺 158 | 序指令的数量。我们可以把这看做经过一个流程图的最长路径的长度，这个流程图描述了给 159 | 定每个模型的输入如何计算它的输出。正如两个相同的计算机程序会有不同的长度~——~取决 160 | 于这个程序是用哪个语言编写的，相同的功能被画成不同深度的流程图~——~取决于允许哪个 161 | 功能作为流程图中的单独的步骤。图~\ref{fig:computational_graphs} 说明了这种语言的 162 | 选择如何对同一架构给出两个不同的衡量。 163 | 164 | \begin{figure}[h] 165 | \centering 166 | \includegraphics{computational_graphs} 167 | \caption{将一个输入映射为一个输出的运算图示例，其中每个节点实行一个操作。深度是 168 | 从输入到输出的最长路径长度，但是依赖于构建一个可能的运算步骤的定义。在这些图 169 | 中描绘的运算是一个逻辑回归模型的输出，$\sigma(w^Tx)$，其中 $\sigma$ 是逻辑 S 170 | 型函数。如果我们使用加法、乘法和逻辑 S 型作为我们的计算机语言的元素，那么这个 171 | 模型深度为 3。如果我们把逻辑回归本身看做一个元素，那么这个模型深度 172 | 为 1。\label{fig:computational_graphs}} 173 | \end{figure} 174 | 175 | 另一个在深度概率模型中使用的方法，并不将一个模型的深度看做运算图形的深度，而是描 176 | 述概念间如何彼此相互关联的图形深度。在这种情况下，运算流程图~——~其中需要计算每个 177 | 概念的表征~——~的深度，可能比这些概念自身的图形要深得多。这是因为系统在更小概念上 178 | 的理解，在给出关于更复杂概念的信息时，能够被改进。例如，一个正在观察一张人脸图 179 | 像~——~其中一只眼睛被阴影遮住~——~的 AI 系统，可能起初只看到一个眼睛。在检测到呈现 180 | 的是一张人脸后，它能够推断出很可能也有第二只眼睛。在这个情况下，概念图仅包含两 181 | 层~——~一层针对眼睛，一层针对人脸~——~但是如果我们改进对每个概念的估算，给予另外 182 | 的 $n$ 次，那么运算图形包含有 $2n$ 层。 183 | 184 | 由于这两种观点~——~运算图形的深度，或者概率模型图形的深度~——~中哪一个最有实质作用 185 | 并不总是很清晰，并且因为不同的人选择不同的最小元素的集合来构造他们的图形，对一个 186 | 架构的深度来说没有一个唯一正确的值，就像对一个计算机程序的长度来说没有一个唯一正 187 | 确的值。同样关于一个模型需要有多少深度才有资格被评为``深的''也没有一个共识。然 188 | 而，\gls*{dl}能够可靠地被用于模型~——~那些涉及到比传统\gls*{ml}所做的更多通过学习 189 | 获得的功能或概念构成的模型~——~研究。 190 | 191 | 总结来说，\gls*{dl}，这本书的主题，是一种 AI 方法。具体来说，它是一种\gls*{ml}类 192 | 型，一种允许计算机系统随着经验和数据改进的技术。按照本书的作者们，\gls*{ml}是构建 193 | 能够在复杂的、真实的环境中运行的 AI 系统的唯一切实可行的方法。\gls*{dl}是一种特殊 194 | 的\gls*{ml}，通过学习将世界表示成嵌套的概念层次~——~每个概念由相关的更简单的概念定 195 | 义，而更抽象的\gls*{representations}以更少抽象的\gls*{representations}形式计 196 | 算~——~实现了强大的能力和灵活性。图~\ref{fig:venn_diagram} 阐明了这些不同 AI 学科 197 | 之间的关系。图~\ref{fig:different_ai_disciplines} 给出了每一个如何工作的高层次原 198 | 理图。 199 | 200 | \begin{figure}[h] 201 | \centering 202 | \includegraphics{venn_diagram} 203 | \caption{一个维恩图，显示\gls*{dl}如何是\gls*{rep-learning}的一个类型，其相应地 204 | 是\gls*{ml}的一个类型，\gls*{ml}是许多但不是全部 AI 的方法。每个维恩图的一个 205 | 部分包含有一个 AI 技术的示例。\label{fig:venn_diagram}} 206 | \end{figure} 207 | 208 | \begin{figure}[h] 209 | \centering 210 | \includegraphics{different_ai_disciplines} 211 | \caption{显示不同的 AI 学科中的一个 AI 系统中不同的部分如何中相互联系的流程图。 212 | 着色的方框表明这些组件能够从数据中学 213 | 习。\label{fig:different_ai_disciplines}} 214 | \end{figure} 215 | 216 | \section{谁应该读这本书？} 217 | \label{sec:who_should_read_this_book} 218 | 219 | 这本书对各种读者都会有用，但我们心怀两个主要的受众来写它。一个目标受众是正在学 220 | 习\gls*{ml}的大学学生（本科生或研究生），包括那些开启职业生涯 221 | 于\gls*{dl}和\gls*{ai}研究的学生。另一个目标受众是没有\gls*{ml}或统计背景的软件工 222 | 程师，但是想要快速获得并在他们的产品或平台上开始使用\gls*{dl}。\gls*{dl}已经被证 223 | 明在许多软件学科中是有用的，包括计算机视觉、语音处理、自然语言处理、机器人学、生 224 | 物信息学和化学、视频游戏、搜索引擎、在线广告和金融。 225 | 226 | 这本书被组织为三个部分，以便适应于各种读者。第\hyperref[part_basics]{一}部分介绍 227 | 基础的数学工具和\gls*{ml}概念。第\hyperref[part_practical]{二}部分描述大部分已经 228 | 认可的\gls*{dl}算法，它们是基本上已经被解决的技术。第\hyperref[part_research]{三}部 229 | 分描述更多推测性的概念，它们被广泛认为在未来的\gls*{dl}中是重要的。 230 | 231 | 读者可以按照他们的兴趣和背景随意跳过那些不相关的部分。例如，熟悉线性代数，概率， 232 | 和基本的\gls*{ml}概念的读者可以跳过第\hyperref[part_basics]{一}部分，而只想实现一 233 | 个可工作系统的读者不需要阅读第\hyperref[part_practical]{二}部分之后的内容。为了帮 234 | 助选择哪些章节阅读，图~\ref{fig:book_organization} 提供了一个流程图，显示了该书的 235 | 高层次组织。 236 | 237 | \begin{figure}[h] 238 | \centering 239 | \begin{tikzpicture}[ 240 | base/.style={rectangle,draw,thick,inner sep=5pt,font=\small}, 241 | chap/.style={base,minimum width=30mm,minimum height=12mm}, 242 | chapsm/.style={base,minimum width=16mm,minimum height=12mm}, 243 | part1/.style={base,minimum width=10cm,minimum height=4.5cm}, 244 | part2/.style={base,minimum width=14cm,minimum height=7.5cm}, 245 | part3/.style={base,minimum width=14cm,minimum height=8.5cm}] 246 | 247 | \node(c1) [chap] {\hyperref[ch:intro]{1.介绍}}; 248 | 249 | \node(p1box) [part1,below=0.5 of c1] {}; 250 | \node(p1) [below=2mm] at (p1box.north) { 251 | \hyperref[part_basics]{第一部分：应用于本书的数学和机器学习基础} 252 | }; 253 | \draw[thick,-{Latex[]}] (c1) to (p1box); 254 | 255 | \node(c2) [chap,below=1.6cm of c1,xshift=-2.4cm] { 256 | \hyperref[ch:linear_algebra]{2.线性代数} 257 | }; 258 | \node(c3) [chap,below=1.6cm of c1,xshift=2.4cm] { 259 | \hyperref[ch:prob]{ 260 | \begin{tabular}{l} 261 | 3.概率论\\ 262 | 与信息论\\ 263 | \end{tabular} 264 | } 265 | }; 266 | \node(c4) [chap,below=0.5 of c2] { 267 | \hyperref[ch:numerical]{4.数值计算} 268 | }; 269 | \node(c5) [chap,below=0.5 of c3] { 270 | \hyperref[ch:ml]{5.机器学习基础} 271 | }; 272 | \draw[thick,-{Latex[]}] (c2) to (c3); 273 | \draw[thick,-{Latex[]}] (c2) to (c4); 274 | \draw[thick,-{Latex[]}] (c3) to (c5); 275 | \draw[thick,-{Latex[]}] (c4) to (c5); 276 | 277 | \node(p2box) [part2,below=0.5 of p1box] {}; 278 | \draw[thick,-{Latex[]}] (p1box) to (p2box); 279 | 280 | \node(p2) [below=2mm] at (p2box.north) { 281 | \hyperref[part_practical]{第二部分：深度网络：现代实践} 282 | }; 283 | \node(c6) [chap,below=2mm of p2] { 284 | \hyperref[ch:mlp]{6.深度前驱网络} 285 | }; 286 | \node(c7) [chap,below=of c6,xshift=-5cm] { 287 | \hyperref[ch:regularization]{7.规范化} 288 | }; 289 | \node(c8) [chap,below=of c6,xshift=-1cm] { 290 | \hyperref[ch:optimization]{8.优化} 291 | }; 292 | \node(c9) [chapsm,below=of c6,xshift=3cm] { 293 | \hyperref[ch:convnets]{9. CNNs} 294 | }; 295 | \node(c10) [chapsm,below=of c6,xshift=5.6cm] { 296 | \hyperref[ch:rnn]{10. RNNs} 297 | }; 298 | \node(c11) [chap,above=5mm,xshift=-2cm] at (p2box.south) { 299 | \hyperref[ch:guidelines]{11.实践方法论} 300 | }; 301 | \node(c12) [chap,above=5mm,xshift=2cm] at (p2box.south) { 302 | \hyperref[ch:applications]{12.应用} 303 | }; 304 | 305 | \draw[thick,-{Latex[]}] (c6) to (c7); 306 | \draw[thick,-{Latex[]}] (c6) to (c8); 307 | \draw[thick,-{Latex[]}] (c6) to (c9); 308 | \draw[thick,-{Latex[]}] (c6) to (c10.north west); 309 | 310 | \foreach \x in {7,...,10} { 311 | \draw[thick,-{Latex[]}] (c\x) to (c11); 312 | \draw[thick,-{Latex[]}] (c\x) to (c12); 313 | }; 314 | 315 | \node(p3box) [part3,below=0.5 of p2box] {}; 316 | \draw[thick,-{Latex[]}] (p2box) to (p3box); 317 | 318 | \node(p3) [below=2mm] at (p3box.north) { 319 | \hyperref[part_research]{第三部分：深度学习研究} 320 | }; 321 | \node(c14) [chap,below=2mm of p3] { 322 | \hyperref[ch:autoencoders]{14. \gls*{autoencoder}} 323 | }; 324 | \node(c13) [chap,left=1.5 of c14] { 325 | \hyperref[ch:linear_factors]{13. 线性因子模型} 326 | }; 327 | \node(c15) [chap,right=1.5 of c14] { 328 | \hyperref[ch:representation]{15. \gls*{rep-learning}} 329 | }; 330 | \node(c16) [chap,below=0.5 of c13] { 331 | \hyperref[ch:graphical_models]{ 332 | \begin{tabular}{l} 333 | 16.结构化\\ 334 | 概率模型\\ 335 | \end{tabular} 336 | } 337 | }; 338 | \node(c19) [chap,below=0.5 of c16] { 339 | \hyperref[ch:inference]{19.推断} 340 | }; 341 | \node(c17) [chap,below=0.5 of c15] { 342 | \hyperref[ch:monte_carlo]{17.蒙特卡洛法} 343 | }; 344 | \node(c18) [chap,below=0.5 of c17] { 345 | \hyperref[ch:partition]{18.配分函数} 346 | }; 347 | \node(c20) [chap,above=5mm] at (p3box.south) { 348 | \hyperref[ch:generative_models]{20.深度生成式模型} 349 | }; 350 | 351 | \draw[thick,-{Latex[]}] (c13) to (c14); 352 | \draw[thick,-{Latex[]}] (c14) to (c15); 353 | \draw[thick,-{Latex[]}] (c13) to (c16); 354 | \draw[thick,-{Latex[]}] (c16) to (c17); 355 | \draw[thick,-{Latex[]}] (c16) to (c19); 356 | \draw[thick,-{Latex[]}] (c17) to (c18); 357 | \draw[thick,-{Latex[]}] (c14) to (c20); 358 | \draw[thick,-{Latex[]}] (c19) to (c20); 359 | \draw[thick,-{Latex[]}] (c18) to (c20); 360 | 361 | \end{tikzpicture} 362 | \caption{本书高层次的组织。从一章到另一章的箭头表示前一章是理解后一章的先决条 363 | 件。\label{fig:book_organization}} 364 | \end{figure} 365 | 366 | 我们假设所有的读者都有计算机科学背景，熟悉编程，对运算性能问题、复杂度理论、入门 367 | 的微积分知识和一些图论的术语有基本的理解。 368 | 369 | \section{深度学习的历史趋势} 370 | \label{sec:historical_trends_in_deep_learning} 371 | 372 | \subsection{不断增长的模型规模} 373 | \label{subsec:increasing_model_sizes} 374 | -------------------------------------------------------------------------------- /contents/linear_algebra.tex: -------------------------------------------------------------------------------- 1 | \chapter{线性代数} 2 | \label{ch:linear_algebra} 3 | 4 | 线性代数是广泛使用在整个科学和工程中的一个数学分支。然而，由于线性代数是一种连续 5 | 的形式而不是离散数学，许多计算机科学家对它少有经验。很好地理解线性代数，对理解和 6 | 使用许多\gls*{ml}算法来工作，是必不可少的，对\gls*{dl}尤其如此。因此，我们在介 7 | 绍\gls*{dl}之前先专注于对关键的线性代数必备知识做些陈述。 8 | 9 | 如果你已经熟悉了线性代数，尽管跳过这一章。如果你对这些概念有了一些先期的经验，但 10 | 是需要一个详细的参考来复习关键的公式，我们推荐 \emph{The Matrix Cookbook} 11 | \citep{matrix-cookbook}。如果你完全没有接触过线性代数，这一章会教你足够的知识来阅 12 | 读本书，但是我们强烈建议你也去咨询其它专门教授线性代数的材料，例 13 | 如\citep{shilov1977linear}。本章会完全略过很多重要的线性代数的主题，它们对理 14 | 解\gls*{dl}不是必须的。 15 | 16 | \section{标量、向量、矩阵和张量} 17 | \label{sec:scalars_vectors_matrices_and_tensors} 18 | 19 | 线性代数的研究涉及到几种数学对象的类型： 20 | 21 | \begin{itemize} 22 | \item \emph{\gls{scalars}}：一个标量仅仅是一个单独的数字，相反，大多数其它线性代 23 | 数的研究对象通常是多个数组。我们用斜体来写标量。我们通常用小写命名标量。当我们 24 | 介绍它们时，我们指定它们是什么样的数字。例如：当定义一个实数值的标量时，我们可 25 | 能说``设 $s \in \mathbb{R}$ 为直线的斜率''，或者，当定义一个自然数标量 26 | 时，``设 $n \in \mathbb{N}$ 为单元的个数''。 27 | \item \emph{\gls{vecs}}：一个\gls*{vec}是一个数组。这些数字按照顺序排列。我们可以 28 | 通过这一顺序中的索引来确定每一个单独的数字。通常我们以小写的粗体字体 29 | 给\gls*{vec}命名，例如 $\pmb{x}$。\gls*{vec}的元素以伴有下标的斜体字体表 30 | 示。$\pmb{x}$ 的第一个元素是 $x_1$，第二个是 $x_2$，依此类推。我们还要说 31 | 明\gls*{vec}中存储的是什么类型的数字。如果每个元素是 $\mathbb{R}$ 中的数， 32 | 而\gls*{vec}有 $n$ 个元素，那么\gls*{vec}位于以 $\mathbb{R}$ 的 $n$ 次笛卡尔积 33 | 的所形成的集合内，表示为 $\mathbb{R}^n$。当我们需要显式地表示一个\gls*{vec}中的 34 | 元素，我们把它们写成方括号围起来的一列： 35 | \begin{equation} 36 | x = \begin{bmatrix}x_1\\ x_2\\ \vdots\\ x_n\end{bmatrix} 37 | \label{eq:vec_example} 38 | \end{equation} 39 | 我们可以把\gls*{vec}看做表示空间的点，每个元素提供沿着不同坐标轴的坐标。\\ 40 | 有时候我们需要索引一个向量中的一个元素集合。在这种情况下，我们定义一个包含索引 41 | 的集合，并把这个集合写成一个下标。例如，为了获得 $x_1$，$x_3$ 和 $x_6$，我们定 42 | 义集合 $S = {1, 3, 6}$，写为 $\pmb{x}_S$。我们使用 $-$ 标记表示一个集合的补充。 43 | 例如 $\pmb{x}_{-1}$ 是包含 $\pmb{x}$ 中除了 $x_1$ 的所有元素 44 | 的\gls*{vec}，而 $\pmb{x}_{-S}$ 是包含 $\pmb{x}$ 中除了 $x_1$，$x_2$ 和 $x_6$ 45 | 之外的所有元素的向量。 46 | \item \emph{\gls{matrices}}：一个矩阵是一个数字的二维数组，所以每个元素由两个索引 47 | 确定，而不是一个。我们通常用大写的粗体字体表示矩阵，例如 $\pmb{A}$。如果一个实 48 | 数值的矩阵 $\pmb{A}$ 高度为 $m$，宽度为 49 | $n$，那么我们说$\pmb{A} \in \mathbb{R}^{m \times n}$。我们通常使用斜体~——~但不 50 | 是粗体字体~——~表示一个矩阵的元素，索引用逗号分开列出。例 51 | 如，$A_{1,1}$ 是 $\pmb{A}$ 左上角的元素，而 $A_{m,n}$ 是右下角的元素。我们可以 52 | 为横向坐标写一个 ``:'' 来表示所有竖向坐标 $i$ 的数字。例如，$\pmb{A}_{i,:}$ 表 53 | 示竖向坐标 $i$ 的横跨 $\pmb{A}$ 的部分。即 $\pmb{A}$ 的第 $i$ 行。同样 54 | 的，$\pmb{A}_{:,i}$ 是 $\pmb{A}$ 的第 $i$ 列。当我们需要显式地表示一个矩阵的元 55 | 素，我们把它们写成一个用方括号围起来的数组： 56 | \begin{equation} 57 | \begin{bmatrix}A_{1,1} & A_{1,2} \\ A_{2,1} & A_{2,2}\end{bmatrix} 58 | \label{eq:matrix_example} 59 | \end{equation} 60 | 有时候我们可能需要索引矩阵值的表达式，它不仅仅是一个单个的字母。在这种情况下， 61 | 我们在表达式后使用下标，但不转换为小写。例如，$f(\pmb{A})_{i,j}$ 给出了应用函 62 | 数 $f$ 到 $\pmb{A}$ 上后计算得到的 $(i,j)$ 位置的元素。。 63 | \item \emph{\gls{tensors}}：在有些情况下我们会需要一个多于两个坐标的数组。在一般 64 | 情况下，排列在一个规则的网格~——~具有可变数量的坐标轴~——~上的数组，被称为一 65 | 个\emph{\gls{tensor}}。我们用这样的字体表示一个名为 ``A'' 的张 66 | 量：$\pmb{\mathsf{A}}$。我们把表示 $\pmb{\mathsf{A}}$ 在 $(i,j,k)$ 坐标的元素写 67 | 为 $\mathsfit{A}_{i,j,k}$。 68 | \end{itemize} 69 | 70 | 矩阵的一个重要的操作是\emph{\gls{transpose}}。一个矩阵的\gls*{transpose}是将矩阵 71 | 沿着一个对角线~——~称为\emph{\gls{main-diag}}，从左上角指向右下角~——~做镜像。参见 72 | 图~\ref{fig:transpose_of_matrix} 中对这个操作的图形化描述。我们把一个矩 73 | 阵 $\pmb{A}$ 的转置表示为 $\pmb{A}^{\top}$，以这样定义 74 | \begin{equation} 75 | (\pmb{A}^{\top})_{i,j} = A_{j,i} 76 | \label{eq:transpose_of_matrix} 77 | \end{equation} 78 | 79 | \begin{figure}[h] 80 | \centering 81 | \includegraphics{transpose_of_matrix} 82 | \caption{矩阵的转置可以被看做沿着\gls*{main-diag}的镜 83 | 像\label{fig:transpose_of_matrix}} 84 | \end{figure} 85 | 86 | \gls*{vecs}可以被看做是只含有一列的矩阵。如此一个\gls*{vec}的\gls*{transpose}就是 87 | 一个只有一行的矩阵。有时候这样定义一个\gls*{vec}：在一行的矩阵的文本区中写出它的 88 | 元素，然后使用一个\gls*{transpose}操作来把它转换成标准的列\gls*{vec}，例 89 | 如，$\pmb{x} = [x_1, x_2, x_3]^{\top}$。 90 | 91 | 一个标量可以被看做是只有一个元素的矩阵。因此，我们可以看到一个标量就是它自己 92 | 的\gls*{transpose}：$a = a^{\top}$。 93 | 94 | 只要矩阵有相同的形状，我们可以把它们相互相加，只需要将它们对应的元素相 95 | 加：$\pmb{C} = \pmb{A} + \pmb{B}$，这里 $C_{i,j} = A_{i,j} + B_{i,j}$。 96 | 97 | 我们也可以把一个标量加到一个矩阵上，或者用一个标量乘以一个矩阵，只需要在矩阵上执 98 | 行操作：$\pmb{D} = a \cdot \pmb{B} + c$，这里 $D_{i,j} = a \cdot B_{i,j} + c$。 99 | 100 | 在\gls*{dl}的环境中，我们也使用一些较传统的符号。我们允许矩阵和一个\gls*{vec}相加， 101 | 产生另一个矩阵：$\pmb{C} = \pmb{A} + \pmb{b}$，这里 102 | $C_{i,j} = A_{i,j} + b_j$。换句话说，\gls*{vec} $\pmb{b}$ 被加到矩阵的每一行。这 103 | 个速记法消除了需要在相加前定义一个复制 $\pmb{b}$ 到每一行的矩阵。这个 $\pmb{b}$ 104 | 到多个位置的隐式拷贝被称为\emph{\gls{broadcasting}}。 105 | 106 | \section{矩阵和向量的乘法} 107 | \label{sec:multiplying_matrices_and_vectors} 108 | 109 | 涉及矩阵的最重要的操作之一是两个矩阵的乘法。矩 110 | 阵 $\pmb{A}$ 和 $\pmb{B}$ 的\emph{\gls{matrix-product}}\,是另一个矩阵 111 | $\pmb{C}$。为了这种积可定义，$\pmb{A}$ 的列数量必须和 $\pmb{B}$ 的行数相同。如 112 | 果 $\pmb{A}$ 的形状为 $m \times n$，而 $\pmb{B}$ 的形状为 $n \times p$，那 113 | 么 $\pmb{C}$ 的形状为 $m \times p$。我们可以把两个或更多矩阵放在一起来 114 | 写\gls*{matrix-product}，例如： 115 | \begin{equation} 116 | \pmb{C} = \pmb{A}\pmb{B} 117 | \label{eq:matrix_product} 118 | \end{equation} 119 | 120 | 乘积操作被定义为： 121 | \begin{equation} 122 | C_{i,j} = \sum_{k}A_{i,k}B_{k,j} 123 | \label{eq:product_operation} 124 | \end{equation} 125 | 126 | 注意两个矩阵的标准乘积\textbf{不}仅仅是一个包含有单独元素乘积的矩阵。这样的操作是 127 | 存在的，并被称为\emph{\gls{element-product}}\,或者\emph{\gls{hadamard-product}}， 128 | 表示为 $\pmb{A} \odot \pmb{B}$。 129 | 130 | 两个具有相同维度的\gls*{vecs} 131 | $\pmb{x}$ 和 $\pmb{y}$ 的\emph{\gls{dot-product}}\,是\gls*{matrix-product} 132 | $\pmb{x}^{\top}\pmb{y}$。我们可以把\gls*{matrix-product} $\pmb{C} = 133 | \pmb{A}\pmb{B}$ 看做计 134 | 算 $\pmb{A}$ 的第 $i$ 行和 $\pmb{B}$ 的第 $j$ 列的\gls*{dot-product} $C_{i,j}$。 135 | 136 | \gls*{matrix-product}操作有很多有用的特性，使得对矩阵的数学分析更方便。例如，矩阵 137 | 的乘法是可分配的： 138 | \begin{equation} 139 | \pmb{A}(\pmb{B} + \pmb{C}) = \pmb{A}\pmb{B} + \pmb{A}\pmb{C} 140 | \label{eq:distributive_matrix_multiplication} 141 | \end{equation} 142 | 也可结合： 143 | \begin{equation} 144 | \pmb{A}(\pmb{B}\pmb{C}) = (\pmb{A}\pmb{B})\pmb{C} 145 | \label{eq:associative_matrix_multiplication} 146 | \end{equation} 147 | 不像标量乘法，矩阵乘法是\textbf{不}可交换的（$\pmb{A}\pmb{B} = \pmb{B}\pmb{A}$ 的 148 | 条件并不总是成立）。但是，两个\gls*{vecs}之间的\gls*{dot-product}是可交换的： 149 | \begin{equation} 150 | \pmb{x}^{\top}\pmb{y} = \pmb{y}^{\top}\pmb{x} 151 | \label{eq:commutative_vec_multiplication} 152 | \end{equation} 153 | 154 | \gls*{matrix-product}的\gls*{transpose}有一个简单的形式： 155 | \begin{equation} 156 | (\pmb{A}\pmb{B})^{\top} = \pmb{B}^{\top}\pmb{A}^{\top} 157 | \label{eq:transpose_of_matrix_product} 158 | \end{equation} 159 | 160 | 这使我们利用这样一个乘积值为一个标量时，它和自己的\gls*{transpose}相等的事实，来 161 | 证明方程~\ref{eq:commutative_vec_multiplication}： 162 | \begin{equation} 163 | \pmb{x}^{\top}\pmb{y} = (\pmb{x}^{\top}\pmb{y})^{\top} = \pmb{y}^{\top}\pmb{x} 164 | \label{eq:demonstrate_commutative_vec_multiplication} 165 | \end{equation} 166 | 167 | 由于这本教科书的重点不是线性代数，我们在这里不会试图列出全面 168 | 的\gls*{matrix-product}的有用特性，但读者应该知道有更多。 169 | 170 | 现在我们知道了足够的线性代数的数学符号来写下一个线性方程的系统： 171 | \begin{equation} 172 | \pmb{A}\pmb{x} = \pmb{b} 173 | \label{eq:system_of_linear_equations} 174 | \end{equation} 175 | 这里 $\pmb{A} \in \mathbb{R}^{m \times n}$ 是一个已知的矩阵，$\pmb{b} \in 176 | \mathbb{R}^m$ 是一个已知的\gls*{vec}，而 $\pmb{x} \in \mathbb{R}^n$ 是一个我们想 177 | 要解出的未知变量的\gls*{vec}。$\pmb{A}$ 的每一行和 $\pmb{b}$ 的每个元素提供了另一 178 | 个限制。我们可以重写方程~\ref{eq:system_of_linear_equations} 为： 179 | \begin{gather} 180 | \pmb{A}_{1,:}\pmb{x} = b_1\\ 181 | \pmb{A}_{2,:}\pmb{x} = b_2\\ 182 | \ldots \\ 183 | \pmb{A}_{m,:}\pmb{x} = b_m 184 | \end{gather} 185 | 186 | 或者，甚至更明确地： 187 | \begin{gather} 188 | \pmb{A}_{1,1}x_1 + \pmb{A}_{1,2}x_2 + \ldots + \pmb{A}_{1,n}x_n = b_1\\ 189 | \pmb{A}_{2,1}x_1 + \pmb{A}_{2,2}x_2 + \ldots + \pmb{A}_{2,n}x_n = b_2\\ 190 | \ldots\\ 191 | \pmb{A}_{m,1}x_1 + \pmb{A}_{m,2}x_2 + \ldots + \pmb{A}_{m,n}x_n = b_m 192 | \end{gather} 193 | 194 | 矩阵--\gls*{vec}乘积的符号提供了这种方程形式的一个更紧凑的表示。 195 | 196 | \section{单位矩阵和逆矩阵} 197 | \label{sec:identity_and_inverse_matrices} 198 | 199 | 线性代数提供一个强大的工具，被称为\emph{\gls{matrix-inversion}}，允许我们以分析的 200 | 方法解不同值的 $\pmb{A}$ 的方程~\ref{eq:system_of_linear_equations}。 201 | 202 | 为了描述\gls*{matrix-inversion}，我们首先需要定义一 203 | 个\emph{\gls{identity-matrix}}\,的概念。一个\gls*{identity-matrix}是这样一个矩阵， 204 | 把它乘以任何\gls*{vec}都不会改变\gls*{vec}。我们将保 205 | 留 $n$ 维\gls*{vecs}的\gls*{identity-matrix}表示为 $\pmb{I}_n$。正式 206 | 地，$\pmb{I}_n \in \mathbb{R}^{n \times n}$，并且 207 | \begin{equation} 208 | \forall \pmb{x} \in \mathbb{R}^n, \pmb{I}_n\pmb{x} = \pmb{x} 209 | \label{eq:definition_of_identity_matrix} 210 | \end{equation} 211 | 212 | \gls*{identity-matrix}的结构很简单：所有沿着主对角线的元素是 213 | $1$，同时其它元素是$0$。参见图~\ref{fig:identity_matrix} 的示例。 214 | 215 | \begin{figure}[h] 216 | \centering 217 | \includegraphics{identity_matrix} 218 | \caption{\gls*{identity-matrix}的示例：这是 219 | $\pmb{I}_3$\label{fig:identity_matrix}} 220 | \end{figure} 221 | 222 | $\pmb{A}$ 的\gls*{matrix-inversion}表示为 $\pmb{A}^{-1}$，它被定义为这样的矩阵： 223 | \begin{equation} 224 | \pmb{A}^{-1}\pmb{A} = \pmb{I}_n 225 | \label{eq:matrix-inverse} 226 | \end{equation} 227 | 228 | 现在我们可以通过以下步骤解方程~\ref{eq:system_of_linear_equations}： 229 | \begin{gather} 230 | \pmb{A}\pmb{x} = \pmb{b}\\ 231 | \pmb{A}^{-1}\pmb{A}\pmb{x} = \pmb{A}^{-1}\pmb{b}\\ 232 | \pmb{I}_n\pmb{x} = \pmb{A}^{-1}\pmb{b}\\ 233 | \pmb{x} = \pmb{A}^{-1}\pmb{b} 234 | \end{gather} 235 | 236 | 当然，这依赖于可能找到 $\pmb{A}^{-1}$。我们在接下来一节中讨论 $\pmb{A}^{-1}$ 存在 237 | 的条件。 238 | 239 | 当 $\pmb{A}^{-1}$ 存在时，存在几种不同算法用于在闭合式中找到它。理论上，同样的逆 240 | 矩阵可以被用于多次解不同 $\pmb{b}$ 值的方程。然而，$\pmb{A}^{-1}$ 主要作为一个假 241 | 设的工具使用，实际上不应该被用在大多数软件应用中。由于在一个数字计算机 242 | 中 $\pmb{A}^{-1}$ 可以仅由有限精度表示，利用 $\pmb{b}$ 值的算法通常可以取得更精确 243 | 的 $\pmb{x}$ 的估算。 244 | 245 | \section{线性相关和生成空间} 246 | \label{sec:linear_dependence_and_span} 247 | 248 | 为使 $\pmb{A}^{-1}$ 存在，方程~\ref{eq:system_of_linear_equations} 必须对每 249 | 个 $\pmb{b}$ 的值有唯一的解。然而，方程系对有些 $\pmb{b}$ 的值也可能无解或有无限 250 | 多解。对一个特定的 $\pmb{b}$ 不可能有介于一个和无限多个之间的解；如果 $\pmb{x}$ 251 | 和 $\pmb{y}$ 都是解，那么 252 | \begin{equation} 253 | \pmb{z} = \alpha\pmb{x} + (1 - \alpha)\pmb{y} 254 | \end{equation} 255 | 对于任意实数 $\alpha$ 也是一个解。 256 | 257 | 为了分析方程有多少解，我们可以把 $\pmb{A}$ 的列看做指向从\textbf{原点}（由全部 258 | 为 $0$ 的向量指定的点）出发的不同方向，并确定有多少路径到达 $\pmb{b}$。在这个观点 259 | 下，$\pmb{x}$ 的每个元素指定了我们沿着每个方向要走多远，这里 $x_i$ 指定沿着 260 | 列 $i$ 移动多远： 261 | \begin{equation} 262 | \pmb{A}\pmb{x} = \sum_{i}x_i\pmb{A}_{:,i} 263 | \end{equation} 264 | 265 | 通常，这种类型的操作被称为\emph{\gls{linear-comb}}。正式地，一个由一 266 | 组\gls*{vecs} ${\pmb{v}^{(1)}, \ldots, \pmb{v}^{(i)}}$ 构成的\gls*{linear-comb}， 267 | 是将每个\gls*{vec} $\pmb{v}^{(i)}$ 乘以一个相应的标量系数并且把结果相加： 268 | \begin{equation} 269 | \sum_{i}c_i\pmb{v}^{(i)} 270 | \end{equation} 271 | 272 | 一组向量的\emph{\gls{span}}\,是由原始\gls*{vecs}的\gls*{linear-comb}得到的所有点 273 | 的集合。 274 | 275 | 确定 $\pmb{A}\pmb{x} = \pmb{b}$ 是否有一个解，相当于测试 $\pmb{b}$ 是否 276 | 在 $\pmb{A}$ 列中的\gls*{span}。这个特定的\gls*{span}被称 277 | 为\emph{\gls{column-space}}\,或者 $\pmb{A}$ 的\emph{\gls{range}}。 278 | 279 | 为了使方程系 $\pmb{A}\pmb{x} = \pmb{b}$ 对所有 $\pmb{b} \in \mathbb{R}^m$ 的所有 280 | 值有唯一解，我们需要 $\pmb{A}$ 的所有\gls*{column-space}为 $\mathbb{R}$。如 281 | 果 $\mathbb{R}^m$ 中的任何点被排除于\gls*{column-space}之外，那个点是一个潜在的无 282 | 解的 $\pmb{b}$ 值。$\pmb{A}$ 的所有\gls*{column-space}是 $\mathbb{R}^m$ 的需求， 283 | 立即暗示了 $\pmb{A}$ 必须有至少 $m$ 个列，即 $n \geq m$。否 284 | 则，\gls*{column-space}的维度会小于 $m$。例如，考虑一个 $3 \times 2$ 的矩阵。目 285 | 标 $\pmb{b}$ 是 3 维的，但是 $\pmb{x}$ 仅仅是 2 维，所以修改 $\pmb{x}$ 的值最好情 286 | 况下允许我们描绘出一个 $\mathbb{R}^3$ 中的 2 维平面。方程当且仅当 $\pmb{b}$ 位于 287 | 平面上时有一个解。 288 | 289 | 对于每个点有一个解，$n \geq m$ 仅仅是一个必要条件。它不是充分条件，因为有可能一些 290 | 列是冗余的。考虑一个 $2 \times 2$ 的矩阵，其中两列都是相同的。这与一个仅含有一个 291 | 重复列的 $2 \times 1$ 的矩阵 有相同的\gls*{column-space}。换句话说，即使有两 292 | 列，\gls*{column-space}仍然仅仅是一条线，无法包含所有的 $\mathbb{R}^2$。 293 | 294 | 正式地，这种冗余被称为\emph{\gls{linear-dep}}。一个\gls*{vecs}集，如果其中没有一 295 | 个\gls*{vec}是其它集和中\gls*{vecs}的\gls*{linear-comb}，那么这 296 | 个\gls*{vecs}集是\emph{\gls{linearly-indep}}\,的。如果我们往集合中加上一 297 | 个\gls*{vec}，它是一个集合中其它\gls*{vecs}的\gls*{linear-comb}，那么新 298 | 的\gls*{vec}并不往集合的\gls*{span}中增加任何点。这意味着对于矩阵 299 | 的\gls*{column-space}要包含所有 $\mathbb{R}^m$，这个矩阵必须含有至少一 300 | 个 $m$ 个\gls*{linearly-indep}列的集合。这个条件是方 301 | 程~\ref{eq:system_of_linear_equations} 的必要条件和充分条件，使得方程对每 302 | 个 $\pmb{b}$ 值有一个解。注意这个需求中的集合，是正好 303 | 有 $m$ 个\gls*{linear-indep}的列，不是至少 $m$ 列。没有 $m$ 维\gls*{vecs}的集合可 304 | 以有多于 $m$ 个互相\gls*{linearly-indep}的列，但是一个具有多于 $m$ 列的矩阵可能有 305 | 多于一个这样的集合。 306 | 307 | 为了使矩阵有一个转置，我们另外需要确保方程~\ref{eq:system_of_linear_equations} 对 308 | 每一个 $\pmb{b}$ 的值\textbf{最多}有一个解。为此，我们需要确保矩阵有最多 $m$ 个列。 309 | 否则就有多于一个方法来确定每个解的参数。 310 | 311 | 综合起来，这意味着矩阵必须是\emph{\gls{square}}，即，我们需要 $m = n$ 并且所有的 312 | 列必须是\gls*{linearly-indep}。一个具有\gls*{linearly-dep}列的方块矩阵被称 313 | 为\emph{\gls{singular}}。 314 | 315 | 如果 $\pmb{A}$ 不是矩阵或者是方块矩阵但不是\gls*{singular}，仍然可能解这个方程。 316 | 但是我们不能使用\gls*{matrix-inversion}的方法来找出解。 317 | 318 | 目前为止我们已经讨论过了在左边乘的逆矩阵。也可能定义一个在右边乘的逆： 319 | \begin{equation} 320 | \pmb{A}\pmb{A}^{-1} = \pmb{I} 321 | \end{equation} 322 | 323 | 对于方块矩阵，左边求逆和右边求逆是相同的。 324 | 325 | \section{范数} 326 | \label{sec:norms} 327 | 328 | 有时候我们需要测量一个\gls*{vec}的长度。在\gls*{ml}中，我们通常使用一个被称 329 | 为\emph{\gls{norm}}\,的函数测量\gls*{vecs}的长度。正式地，对于 330 | $p \in \mathbb{R}, p \geq 1$，$L^p$ 的范数由 331 | \begin{equation} 332 | \|\pmb{x}\|_p = \left(\sum_i|x_i|^p\right)^{\frac{1}{p}} 333 | \label{eq:lp_norm} 334 | \end{equation} 335 | 给出。 336 | 337 | 这些范数，包括 $L^p$ 范数，是将\gls*{vecs}映射为非负值的函数。凭直觉地，一 338 | 个\gls*{vec} $\pmb{x}$ 的范数测量从原点到点 $\pmb{x}$ 的距离。更严格地，一个范数 339 | 是满足以下特性的任意函数 $f$： 340 | \begin{itemize} 341 | \item $f(\pmb{x}) = 0 \Rightarrow \pmb{x} = \pmb{0}$ 342 | \item $f(\pmb{x} + \pmb{y}) \leq f(\pmb{x}) + f(\pmb{y})$ 343 | (\emph{\gls{tri-inequal}}\,) 344 | \item $\forall \alpha \in \mathbb{R}, f(\alpha \pmb{x}) = |\alpha|f(\pmb{x})$ 345 | \end{itemize} 346 | 347 | 具有 $p = 2$ 的 $L^2$ 范数被称为\emph{\gls{eu-norm}}。它是从原点到点 $\pmb{x}$ 的 348 | 欧几里德距离。$L^2$ 范数被频繁地使用在\gls*{ml}中以至于它常常被简单表示 349 | 为 $\|\pmb{x}\|$，而忽略其下标 $2$。通常也使用平方 $L^2$ 范数测量一个\gls*{vec}的 350 | 长度，它可以简单地由 $\pmb{x}^{\top}\pmb{x}$ 来计算。 351 | 352 | 平方 $L^2$ 范数在数学和计算上比 $L^2$ 范数本身更方便。例如，每个平方 $L^2$ 范数对 353 | 于每一个 $\pmb{x}$ 元素的导数，仅依赖于对应的 $\pmb{x}$ 的元素，而所有 $L^2$ 范数 354 | 的导数依赖于整个\gls*{vec}。在许多环境中，平方 $L^2$ 范数可能是不受欢迎的，因为它 355 | 在原点附近缓慢地增长。在几个\gls*{ml}应用中，区分完全为 $0$ 的元素和很小但非 $0$ 356 | 的元素是很重要的。在这些情况下，我们转而采用一个在所有位置以相同速率增长，但是在 357 | 数学上保留简单特性的函数：$L^1$ 范数。$L^1$ 范数可以简化为： 358 | \begin{equation} 359 | \|\pmb{x}\|_1 = \sum_i|x_i| 360 | \end{equation} 361 | 362 | 当 $0$ 和 非 $0$ 元素非常重要时，$L^1$ 范数被普遍使用在\gls*{ml}中。每次一 363 | 个 $\pmb{x}$ 元素从 $0$ 移动了 $\epsilon$，$L^1$ 范数增加了 $\epsilon$。 364 | 365 | 我们有时候通过计算非 $0$ 元素的个数来测量\gls*{vec}的大小。有些作者把这个函数表示 366 | 为``$L^0$''范数，但这是个错误的术语。一个\gls*{vec}中的非 $0$ 元素的个数不是一个 367 | 范数，因为通过 $\alpha$ 来调整\gls*{vec}不改变非 $0$ 元素的个数。$L^1$ 模常常被用 368 | 作非 $0$ 元素个数的代替者。 369 | 370 | 另一个在\gls*{ml}中普遍出现的范数是 371 | $L^{\infty}$，也被称为\emph{\gls{max-norm}}。这个范数简化为\gls*{vec}中最大幅度元 372 | 素的绝对值， 373 | \begin{equation} 374 | \|\pmb{x}\|_{\infty} = \max_i|x_i| 375 | \end{equation} 376 | 377 | 有时候我们也想要测量矩阵的大小。在\gls*{dl}的环境中，最普遍的方式是以不同的、费解 378 | 的\emph{\gls{fr-norm}} 379 | \begin{equation} 380 | \|A\|_F = \sqrt{\sum_{i,j}A_{i,j}^2} 381 | \end{equation} 382 | 它类似于一个\gls*{vec}的 $L^2$ 范数。 383 | 384 | 两个\gls*{vecs}的点乘可以重写为范数的形式。具体来说， 385 | \begin{equation} 386 | \pmb{x}^{\top}\pmb{y} = \|\pmb{x}\|_2\|\pmb{y}\|_2\cos \theta 387 | \end{equation} 388 | 其中 $\theta$ 是 $\pmb{x}$ 和 $\pmb{y}$ 之间的夹角。 389 | 390 | \section{特殊类型的矩阵和向量} 391 | \label{sec:special_kinds_of_matrices_and_vectors} 392 | 393 | 一些特别有用的特殊类型的矩阵和\gls*{vecs}。 394 | 395 | \emph{\gls{diag}}\,矩阵大部分由 $0$ 组成，仅仅沿着主对角线有非 $0$ 元素。正式地， 396 | 一个矩阵 $\pmb{D}$ 当且仅当对所有 $i \neq j$ 的 $D_{i,j} = 0$ 时是对角线的。我们 397 | 已经见过了一个对角矩阵的例子：单位矩阵，其中所有的对角线元素为 $1$。我们写 398 | 成 $\mathrm{diag}(\pmb{v})$ 来表示一个方块对角矩阵，其中对角线元素由\gls*{vec} 399 | $\pmb{v}$ 的元素给出。对角矩阵在某种程度上让人感兴趣是因为被一个对角矩阵相乘，在 400 | 计算上是非常有效率的。计算 $\mathrm{diag}(\pmb{v})\,\pmb{x}$，我们只需要用 $v_i$ 401 | 来调整每个元素 402 | $x_i$。换句话说，$\mathrm{diag}(\pmb{v})\,\pmb{x} = \pmb{v} \odot \pmb{x}$。对一 403 | 个方块对角矩阵求逆也同样高效。仅当每个对角线元素为非 $0$ 时矩阵的逆存在，在这种情 404 | 况下，$\mathrm{diag}(\pmb{v})^{-1} = \mathrm{diag}([1/v_1, \ldots, 405 | 1/v_n]^{\top})$。在许多情况下，我们可能会得到一些非常一般的以任意矩阵形式 406 | 的\gls*{ml}算法，但通过限制一些矩阵为对角矩阵可获得一个代价更低的（和更少描述性的） 407 | 算法。 408 | 409 | 不是所有的对角矩阵需要是方块型的。构建一个矩形的对角矩阵是可能的。非方块对角矩阵 410 | 没有逆，但是它仍然可能被它们以较低的代价相乘。对于一个非方块对角矩阵 $\pmb{D}$， 411 | 乘积 $\pmb{D}\pmb{x}$ 会涉及到调整 $\pmb{x}$ 的每个元素，并且，如果 $\pmb{D}$ 的 412 | 高度比宽度大则往结果中连接一些 $0$，或者当 $\pmb{D}$ 的宽度大于高度时则舍 413 | 弃\gls*{vec}的最后一些元素。 414 | 415 | 一个\emph{\gls{symmetric}}\,矩阵是任何和其自身的转置相等的矩阵： 416 | \begin{equation} 417 | \pmb{A} = \pmb{A}^{\top} 418 | \end{equation} 419 | 对称矩阵常常出现在其中的元素由一些有两个参数的函数生成的时候，其元素不依赖于这两 420 | 个参数的顺序。例如，如果 $\pmb{A}$ 是一个距离测量的矩阵，$\pmb{A}_{i,j}$ 给出了从 421 | 点 $i$ 到点 $j$ 的距离，那么因为距离函数是对称的，$\pmb{A}_{i,j} = 422 | \pmb{A}_{j,i}$。 423 | 424 | 一个\emph{\gls{unit-vec}}\,是一个具有\emph{\gls{unit-norm}}\,的\gls*{vec}： 425 | \begin{equation} 426 | \|\pmb{x}\|_2 = 1 427 | \end{equation} 428 | 429 | 一个\gls*{vec} $\pmb{x}$ 和一个 \gls*{vec} $\pmb{y}$，如 430 | 果 $\pmb{x}^{\top}\pmb{y} = 0$，那么它们是相互\emph{\gls{ortho}}。如果两 431 | 个\gls*{vecs}都有非 $0$ \gls*{norm}，这意味着它们以 $90^{\circ}$ 角相互垂直。 432 | 在 $\mathbb{R}^n$ 中，最多有 $n$ 个具有非 $0$ \gls*{norm}的\gls*{vecs}可以相互正 433 | 交。如果\gls*{vecs}不仅是正交的，还有\gls*{unit-norm}，那么我们称它们 434 | 是\emph{\gls{orthonormal}}。 435 | 436 | 一个\emph{\gls{orthonormal-matrix}}\,是一个方块矩阵，其各行是相 437 | 互\gls*{orthonormal}，而各列也是相互\gls*{orthonormal}： 438 | \begin{equation} 439 | \pmb{A}^{\top}\pmb{A} = \pmb{A}\pmb{A}^{\top} = \pmb{I} 440 | \end{equation} 441 | 442 | 这表示 443 | \begin{equation} 444 | \pmb{A}^{-1} = \pmb{A}^{\top} 445 | \end{equation} 446 | 所以正交矩阵有趣在它们的逆可以以很低的代价来计算。认真注意正交矩阵的定义。相反， 447 | 它们的行不仅仅是正交的，而且是完全标准正交的。没有一个特殊的术语来定义一个行或列 448 | 正交但不是标准正交的矩阵。 449 | 450 | \section{特征分解} 451 | \label{sec:eigendecomposition} 452 | 453 | 通过把整体分解成多个组成部分，或者找到一些具有普遍性的特性而不是我们选择来表示的 454 | 方式，许多数学对象能够被更好理解。 455 | 456 | 例如，整数能够被分解成素数因子。我们表示数字 $12$ 的方式会随着我们以十进制或者二 457 | 进制的方式而改变，但总会是 $12 = 2 \times 2 \times 3$。从这样的表示我们可以最终得 458 | 到有用的特性，诸如 $12$ 不能被 $5$ 除，或者任意乘以 $12$ 后能被 $3$ 除。 459 | 460 | 正如我们通过把一个整数分解为素数因子来发现某些整数的真实性质，我们也能以显示关于 461 | 矩阵的功能特性的方式~——~这些特性从一个元素数组的表示中并不明显~——~分解它们。 462 | 463 | 一个最广泛使用的矩阵分解被称为\emph{\gls{eigen-decompos}}，使用它我们把一个矩阵分 464 | 解为一系列特征向量和特征值的集合。 465 | 466 | 一个方块矩阵 $\pmb{A}$ 的\emph{\gls{eigen-vec}}\,是这样一个非 $0$ 向量 $\pmb{v}$， 467 | 它被 $\pmb{A}$ 乘后仅仅改变了 $\pmb{v}$ 的缩放： 468 | \begin{equation} 469 | \pmb{A}\pmb{v} = \lambda\pmb{v} 470 | \end{equation} 471 | 缩放因子 $\lambda$ 被称为相对于这个\gls*{eigen-vec}的\emph{\gls{eigen-val}}。（也 472 | 可以找到一个\emph{\gls{left-eigen-vec}}，这样 473 | $\pmb{v}^{\top}\pmb{A} = \lambda\pmb{v}^{\top}$，但是我们通常关注的是 474 | 右\gls*{eigen-vec}）。 475 | 476 | 如果 $\pmb{v}$ 是 $\pmb{A}$ 的一个\gls*{eigen-vec}，那么对于 $s \in \mathbb{R}, 477 | s \neq 0$ 的任意缩放的\gls*{vec} $s\pmb{v}$，$s\pmb{v}$ 也是如此。此 478 | 外，$s\pmb{v}$ 仍然有相同的\gls*{eigen-val}。因为这个原因，我们通常只找单 479 | 位\gls*{eigen-vecs}。 480 | 481 | 假设矩阵 $\pmb{A}$ 有 482 | $n$个线性不相关的\gls*{eigen-vecs}，$\{\pmb{v}^{(1)}, \ldots, \pmb{v}^{(n)}\}$， 483 | 并有相应的\gls*{eigen-vals} 484 | $\{\lambda_1, \ldots, \lambda_n\}$。我们可以把所有\gls*{eigen-vecs}串联起来形成一 485 | 个每列有一个\gls*{eigen-vec}的矩阵$\pmb{V}$：$\pmb{V} = [\pmb{v}^{(1)}, \ldots, 486 | \pmb{v}^{(n)}]$。同样地，我们能够把\gls*{eigen-vals}串联起来形成一个\gls*{vec} 487 | $\pmb{\lambda} = [\lambda_1, \ldots, \lambda_n]^{\top}$。那么 $\pmb{A}$ 的特征分 488 | 解就由 489 | \begin{equation} 490 | \pmb{A} = \pmb{V}\mathrm{diag}(\pmb{\lambda})\pmb{V}^{-1} 491 | \end{equation} 492 | 给出。 493 | 494 | 我们已经看到\textbf{构建}具有特定的\gls*{eigen-vals}和\gls*{eigen-vecs}的矩阵允许 495 | 我们在期望的方向上伸展空间。然而，我们往往想要把矩阵\textbf{分解}为他们 496 | 的\gls*{eigen-vals}和\gls*{eigen-vecs}。这样做可以帮助我们分析矩阵的某些属性，就 497 | 像把一个整数分解成它的素数因子，可以帮助我们了解该整数的行为。 498 | 499 | 不是每个矩阵能够被分解为\gls*{eigen-vals}和\gls*{eigen-vecs}。在某些情况下，存在 500 | 这样的分解，但可能涉及到复数而不是实数。幸运地，在这本书中，我们通常只需要分解一 501 | 些特殊的、有着简单分解的矩阵类别。特别地，只使用实数值 502 | 的\gls*{eigen-vecs}和\gls*{eigen-vals}，每一个实数对称矩阵能够被分解为一个表达 503 | 式： 504 | \begin{equation} 505 | \pmb{A} = \pmb{Q}\pmb{\Lambda}\pmb{Q}^{\top} 506 | \end{equation} 507 | 其中 $\pmb{Q}$ 是一个由\gls*{eigen-vecs} $\pmb{A}$ 组成的正交矩阵， 508 | 而 $\pmb{\Lambda}$ 是一个对角矩阵。\gls*{eigen-val} $\Lambda_{i,i}$ 与 $\pmb{Q}$ 509 | 的第 $i$ 列~——~表示为 $\pmb{Q}_{:,i}$~——~中的\gls*{eigen-vec}相关。由 510 | 于 $\pmb{Q}$ 是一个正交矩阵，我们可以把 $\pmb{A}$ 看做通过 $\pmb{v}^{(i)}$ 方向上 511 | 的 $\lambda_i$ 调整的缩放空间。参见 512 | 图~\ref{fig:effect_of_eigenvectors_and_eigenvalues} 的示例。 513 | 514 | \begin{figure}[h] 515 | \centering 516 | \includegraphics{eigen_effect} 517 | \caption{一个\gls*{eigen-vecs}和\gls*{eigen-vals}影响的示例。这里我们有一个矩 518 | 阵 $\pmb{A}$，它有两 519 | 个\gls*{orthonormal}\gls*{eigen-vecs}，有\gls*{eigen-val} 520 | $\lambda_1$ 的 $\pmb{v}^{(1)}$ 和有\gls*{eigen-val} 521 | $\lambda_2$ 的 $\pmb{v}^{(2)}$。（\textbf{左边}）我们把所有单位\gls*{vecs} 522 | $\pmb{u} \in \mathbb{R}^2$ 的集合绘成一个单位圆。（\textbf{右边}）我们绘上了 523 | 所有点 $\pmb{A}\pmb{u}$ 的集合。通过观察 $\pmb{A}$ 扭曲单位圆的方式，我们能够 524 | 看到它在 $\pmb{v}^{(i)}$ 方向上被 $\lambda_i$ 缩放了空间。 525 | \label{fig:effect_of_eigenvectors_and_eigenvalues}} 526 | \end{figure} 527 | 528 | 虽然任何实数对称矩阵 $\pmb{A}$ 可确保有一个特征分解，但它可能不是唯一的。如果有两 529 | 个或两个以上的\gls*{eigen-vecs}共享相同的\gls*{eigen-val}，那么任何一组位于它们生 530 | 成空间的正交\gls*{vecs}也是具有那个\gls*{eigen-val}的\gls*{eigen-vecs}，而我们可 531 | 以等价地用这些\gls*{eigen-vecs}选择一个 $\pmb{Q}$。按照惯例，我们通常以降序排 532 | 序 $\Lambda$ 中的元素。在这种惯例下，只有当所有的\gls*{eigen-vals}是唯一时，特征 533 | 分解是唯一的。 534 | 535 | 矩阵的特征分解告诉我们很多关于矩阵的有用的事实。当且仅当任 536 | 何\gls*{eigen-vals}是 $0$ 时，矩阵是奇异的。一个实数对称矩阵的特征分解也能够被用 537 | 于以 $\|\pmb{x}\|_2 = 1$ 的条件优化 $f (\pmb{x}) = \pmb{x}^{\top}$ 形式的二次方表 538 | 达式。当 $\pmb{x}$ 等于一个 $\pmb{A}$ 的\gls*{eigen-vec}时，$f$ 的取值是相应 539 | 的\gls*{eigen-val}。$f$ 在约束域内的的最大值是\gls*{eigen-val}的最大值，它在约束 540 | 域内的最小值是\gls*{eigen-val}的最小值。 541 | 542 | 一个\gls*{eigen-vals}都是正数的矩阵被称为\emph{\gls{positive-definite}}。一 543 | 个\gls*{eigen-vals}都是正数或者 $0$ 的矩阵被称 544 | 为\emph{\gls{positive-semidefinite}}。相同地，如果所有的\gls*{eigen-vals}都是负数， 545 | 那么矩阵是\emph{\gls{negative-definite}}，而如果所有\gls*{eigen-vals}都是负数或 546 | 者 $0$，它是\emph{\gls{negative-semidefinite}}。\gls*{positive-semidefinite}有趣 547 | 在它们确保 548 | $\forall\pmb{x}, \pmb{x}^{\top}\pmb{A}\pmb{x} \geq 0$。\gls*{positive-definite}另 549 | 外能确保 $\pmb{x}^{\top}\pmb{A}\pmb{x} = 0 \Rightarrow \pmb{x} = 0$. 550 | 551 | \section{奇异值分解} 552 | \label{sec:singular_value_decomposition} 553 | 554 | 在~\ref{sec:eigendecomposition} 一节，我们看到了如何将一个矩阵分解 555 | 为\gls*{eigen-vecs}和\gls*{eigen-vals}。\emph{\gls{svd}}（SVD）提供了另一种分解一 556 | 个矩阵为\emph{\gls{singular-vecs}}\,和\emph{\gls{singular-vals}}\,的方式。SVD允许 557 | 我们去发现一些和特征分解相同类型的信息。然而，SVD 更普遍适用。每一个实数矩阵有一 558 | 个\gls*{singular-val}分解，但\gls*{eigen-val}分解不是。例如，如果一个矩阵不是方块 559 | 的，那么就没有特征分解，相反我们必须使用一个\gls*{singular-val}分解。 560 | 561 | 回忆一下特征分解涉及到分析一个矩阵 $\pmb{A}$ 来发现一个\gls*{eigen-vecs}的矩 562 | 阵 $\pmb{V}$ 和一个\gls*{eigen-vals}的\gls*{vec} $\pmb{\lambda}$，这样我们可以重 563 | 写$\pmb{A}$ 为： 564 | \begin{equation} 565 | \pmb{A} = \pmb{V}\mathrm{diag}(\pmb{\lambda})\pmb{V}^{-1} 566 | \end{equation} 567 | 568 | \gls*{singular-val}分解类似，只是这次我们把 $\pmb{A}$ 写为三个矩阵的乘积： 569 | \begin{equation} 570 | \pmb{A} = \pmb{U}\pmb{D}\pmb{V}^{\top} 571 | \end{equation} 572 | 573 | 假设 $\pmb{A}$ 是一个 $m \times n$ 的矩阵。那么 $\pmb{U}$ 被定义为一个 $m \times 574 | n$ 的矩阵，$\pmb{D}$ 是一个 $m \times n$ 的矩阵，$\pmb{V}$ 是一个 $n \times n$的 575 | 矩阵。 576 | 577 | 这些矩阵每个都被定义为具有一个特殊结构。矩阵 $\pmb{U}$ 和 $\pmb{V}$ 都被定义为正 578 | 交矩阵。矩阵 $\pmb{D}$ 被定义为一个对角矩阵。注意 $\pmb{D}$ 不是必须为方块矩阵。 579 | 580 | 沿着 $\pmb{D}$ 对角线的元素被称为矩 581 | 阵 $\pmb{A}$ 的\emph{\gls{singular-val}}。$\pmb{U}$ 的列被称 582 | 为\emph{\gls{left-singular-vecs}}。$\pmb{V}$ 的列被称 583 | 为\emph{\gls{right-singular-vecs}}。 584 | 585 | 实际上我们可以以 $\pmb{A}$ 的特征分解的功能方面来解 586 | 释 $\pmb{A}$ 的\gls*{singular-val}分 587 | 解。$\pmb{A}$ 的\gls*{left-singular-vecs}是$\pmb{A}\pmb{A}^{\top}$ 的 588 | \gls*{eigen-vecs}。$\pmb{A}$ 的\gls*{right-singular-vecs}是 589 | $\pmb{A}^{\top}\pmb{A}$ 的\gls*{eigen-vecs}。$\pmb{A}$ 的非 $0$ 590 | \gls*{singular-vals}是 $\pmb{A}^{\top}\pmb{A}$ 的\gls*{eigen-vecs}的平方根。对 591 | 于 $\pmb{A}\pmb{A}^{\top}$ 也一样。 592 | 593 | 也许 SVD 最有用的功能，是我们能够用它来部分归纳出非方块矩阵的逆矩阵，正如我们在接 594 | 下来一节会看到的。 595 | 596 | \section{摩尔--彭若斯广义逆} 597 | \label{sec:the_moore_penrose_pseudoinverse} 598 | 599 | 矩阵求逆并不是为非方块的矩阵定义的。假设我们想要取得一个矩阵 $\pmb{A}$ 的左逆矩 600 | 阵 $\pmb{B}$，以便我们可以通过左乘每一边得到 601 | \begin{equation} 602 | \pmb{x} = \pmb{B}\pmb{y} 603 | \end{equation} 604 | 来解一个线性方程 605 | \begin{equation} 606 | \pmb{A}\pmb{x} = \pmb{y} 607 | \end{equation} 608 | 609 | 依赖于这个问题的结构，有可能不能设计一个唯一的从 $\pmb{A}$ 到 $\pmb{B}$ 的映射。 610 | 611 | 如果 $\pmb{A}$ 的高大于它的宽，那么这个方程有可能无解。如果 $\pmb{A}$ 的宽大于高， 612 | 那么有可能有多个解。 613 | 614 | \emph{\gls{moore-penrose-pseudoinverse}}\,允许我们在这种情况下取得进 615 | 展。$\pmb{A}$ 的广义逆被定义为一个矩阵 616 | \begin{equation} 617 | \pmb{A}^+ = \lim_{\alpha \searrow 0}(\pmb{A}^+\pmb{A} + 618 | \alpha\pmb{I})^{-1}\pmb{A}^{\top} 619 | \end{equation} 620 | 实际为了计算这个广义逆的算法并不是基于这个定义，而是这个公式 621 | \begin{equation} 622 | \pmb{A}^+ = \pmb{V}\pmb{D}^+\pmb{U}^{\top} 623 | \end{equation} 624 | 其中 $\pmb{U}$，$\pmb{D}$ 和 $\pmb{V}$ 是 $\pmb{A}$ 的\gls*{singular-val}分解，而 625 | 一个对角矩阵 $\pmb{D}$ 的广义逆 $\pmb{D}^+$ 是通过取它的非 $0$ 元素的倒数然后取所 626 | 得矩阵的转置得到的。 627 | 628 | 当 $\pmb{A}$ 的列数多于行数，那么使用广义逆解一个线性方程提供了许多可能解中的一个。 629 | 明确地，它给出在所有可能的解中具有最小欧几里得范数 $\|\pmb{x}\|_2$ 的解$\pmb{x} 630 | = \pmb{A}^+\pmb{y}$。 631 | 632 | 当 $\pmb{A}$ 的行数多于列数，可能无解。在这种情况下，使用广义逆为我们给出了就欧几 633 | 里得范数 $\|\pmb{A}\pmb{x} - \pmb{y}\|_2$ 而言使得 $\pmb{A}\pmb{x}$ 尽可能接 634 | 近$\pmb{y}$ 的 $\pmb{x}$ 值。 635 | 636 | \section{迹算子} 637 | \label{sec:the_trace_operator} 638 | 639 | 迹算子给出了一个矩阵的所有对角线元素的和： 640 | \begin{equation} 641 | \mathrm{Tr}(\pmb{A}) = \sum_i\pmb{A}_{i,i} 642 | \end{equation} 643 | 644 | 迹算子之所以有用是有多种原因的。一些不借助求和符号难于具体说明的算子，能够使用矩 645 | 阵乘积和迹算子来说明。例如，迹算子提供了一个写出矩阵的弗罗贝尼乌斯范数的替代方 646 | 法： 647 | \begin{equation} 648 | \|A\|_F = \sqrt{\mathrm{Tr}(\pmb{A}\pmb{A}^{\top})} 649 | \label{eq:trace_operator_of_frobenius_norm} 650 | \end{equation} 651 | 652 | 以迹算子的形式写一个表达式开辟了利用许多有用特性来处理表达式的机会。例如，迹算子 653 | 作用于转置算子后不变： 654 | \begin{equation} 655 | \mathrm{Tr}(\pmb{A}) = \mathrm{Tr}(\pmb{A}^{\top}) 656 | \end{equation} 657 | 658 | 由许多因子组成的方块矩阵，如果相应矩阵的形状允许得到的乘积有定义，这个方块矩阵的 659 | 迹，对于将最后的因子移到首位也不变： 660 | \begin{equation} 661 | \mathrm{Tr}(\pmb{A}\pmb{B}\pmb{C}) = \mathrm{Tr}(\pmb{C}\pmb{A}\pmb{B}) = 662 | \mathrm{Tr}(\pmb{B}\pmb{C}\pmb{A}) 663 | \end{equation} 664 | 或者更普遍地， 665 | \begin{equation} 666 | \mathrm{Tr}(\prod^n_{i=1}\pmb{F}^{(i)} = 667 | \mathrm{Tr}(\pmb{F}^{(n)}\prod^{n-1}_{i=1}\pmb{F}^{(i)}) 668 | \label{eq:trace_of_square_matrix} 669 | \end{equation} 670 | 这个循环排列的不变性即使当得到的乘积有一个不同的形状仍然保持成立。例如，对 671 | 于 $\pmb{A} \in \mathbb{R}^{m \times n}$ 和 672 | $\pmb{B} \in \mathbb{R}^{n \times m}$，即使 673 | $\pmb{A}\pmb{B} \in \mathbb{R}^{m \times m}$ 和 674 | $\pmb{B}\pmb{A} \in \mathbb{R}^{n \times n}$，我们有 675 | \begin{equation} 676 | \mathrm{Tr}(\pmb{A}\pmb{B}) = \mathrm{Tr}(\pmb{B}\pmb{A}) 677 | \end{equation} 678 | 679 | 另一个要记住的有用的事实是一个标量是它自身的迹：$a = \mathrm{Tr}(a)$。 680 | 681 | \section{行列式} 682 | \label{sec:the_determinant} 683 | 684 | 一个方块矩阵的行列式，表示为 685 | $\det(\pmb{A})$，是一个将矩阵映射为实数标量的函数。行列式等于矩阵的所 686 | 有\gls*{eigen-vals}的乘积。行列式的绝对值可以被看作是衡量被矩阵相乘后扩展或者压缩 687 | 了多少空间。如果行列式为 $0$，那么空间被完全沿着至少一个维度压缩，导致它丢失了所 688 | 有体积。如果行列式为 $1$，那么变换是保体积的。 689 | 690 | \section{示例：主成分分析} 691 | \label{sec:example:principal_components_analysis} 692 | 693 | 一个简单的\gls*{ml}算法，\emph{\gls{pca}}\,或者 \emph{PCA}，能够仅仅利用线性代数 694 | 的基本知识来推导。 695 | 696 | 假设我们在 $\mathbb{R}^n$ 中有一个 $m$ 个点的集合 697 | $\{\pmb{x}^{(1)}, \ldots, \pmb{x}^{(m)}\}$。假设我们想要在这些点上应用有损数据压 698 | 缩。有损数据压缩意味着以一个需要更少内存但是可能丢失一些精度的方式存储这些点。我 699 | 们想要丢失尽可能少的精度。 700 | 701 | 一种我们能对这些点进行编码的方式是表示它们的一个低维度版本。对每个 702 | 点 $\pmb{x}^{(i)} \in \mathbb{R}^n$，我们能找到一个相应的编码向量 703 | $\pmb{c}^{(i)} \in \mathbb{R}^l$。如果 $l$ 小于 $n$，它会用比原始数据更少内存用于 704 | 存储编码的点。我们想要找到某个编码函数 705 | $f(\pmb{x}) = \pmb{c}$，它为一个输入生成编码，以及一个解码函数，给定它的编码生成 706 | 重构的输入，$\pmb{x} \approx g(f(\pmb{x}))$。 707 | 708 | PCA 是由我们选择的解码函数定义的。更明确地说，要使得解码非常简单，我们选择使用矩 709 | 阵操作来将编码映射回 $\mathbb{R}^n$。让 $g(\pmb{c}) = \pmb{D}\pmb{c}$，其 710 | 中 $\pmb{D} \in \mathbb{R}^{n \times l}$ 是定义解码的矩阵。 711 | 712 | 为这个解码器计算最优的编码可能是一个困难的问题。为了让编码问题保持简 713 | 单，PCA 将 $\pmb{D}$ 的列限制为彼此正交。（注意 $\pmb{D}$ 严格地说仍然不是``一个 714 | 正交矩阵''，除非 $l = n$） 715 | 716 | 随着目前所描述的问题，有可能有许多解，因为如果我们对所有点按比例减小 $c_i$ 我们能 717 | 够增加 $\pmb{D}_{:,i}$ 的规模。为了给出问题的唯一解，我们限制 $\pmb{D}$ 的所有列 718 | 具有单位\gls*{norm}。 719 | 720 | 为了将这个基本的思想转化为一个我们能够实现的算法，我们首先需要做的是计算出如何为 721 | 每个输入点 $\pmb{x}$ 产生最优的编码点 $\pmb{c}^*$。一种方法是最小化输入 722 | 点 $\pmb{x}$ 和它的复原值 $g(\pmb{c}^*)$ 之间的距离。我们可以用一个\gls*{norm}来 723 | 衡量这个距离。在主成分算法中，我们使用 $L^2$ \gls*{norm}： 724 | \begin{equation} 725 | \pmb{c}^* = \mathop{\arg\min}_{\pmb{c}}\|\pmb{x} - g(\pmb{c})\|_2 726 | \end{equation} 727 | 728 | 我们可以换成平方 $L^2$ \gls*{norm}而不是 $L^2$ \gls*{norm}自身，因为它们都被相同 729 | 的 $\pmb{c}$ 值最小化。这是因为 $L^2$ \gls*{norm}是非负的，而平方算子对非负参数是 730 | 单调增加的。 731 | \begin{equation} 732 | \pmb{c}^* = \mathop{\arg\min}_{\pmb{c}}\|\pmb{x} - g(\pmb{c})\|^2_2 733 | \end{equation} 734 | 被最小化的函数简化为 735 | \begin{equation} 736 | (\pmb{x} - g(\pmb{c}))^{\top}(\pmb{x} - g(\pmb{c})) 737 | \end{equation} 738 | （由于 $L^2$ \gls*{norm}的定义，方程~\ref{eq:lp_norm}） 739 | \begin{equation} 740 | = \pmb{x}^{\top}\pmb{x} - \pmb{x}^{\top}g(\pmb{c}) - g(\pmb{c})^{\top}\pmb{x} 741 | + g(\pmb{c})^{\top}g(\pmb{c}) 742 | \end{equation} 743 | （由于分配律） 744 | \begin{equation} 745 | = \pmb{x}^{\top}\pmb{x} - 2\pmb{x}^{\top}g(\pmb{c}) + 746 | g(\pmb{c})^{\top}g(\pmb{c}) 747 | \end{equation} 748 | （因为标量 $g(\pmb{x})^{\top}$ 等于其自身的转置）。 749 | 750 | 现在我们能再次改变正在被最小化的函数，来忽略第一项，因为这一项不依赖 751 | 于 $\pmb{c}$： 752 | \begin{equation} 753 | \pmb{c}^* = \mathop{\arg\min}_{\pmb{c}} - 2\pmb{x}^{\top}g(\pmb{c}) + 754 | g(\pmb{c})^{\top}g(\pmb{c}) 755 | \end{equation} 756 | 757 | 为了更进一步，我们必须代入 $g(\pmb{c})$ 的定义： 758 | \begin{gather} 759 | \pmb{c}^* = \mathop{\arg\min}_{\pmb{c}}-2\pmb{x}^{\top}\pmb{D}\pmb{c} + 760 | \pmb{c}^{\top}\pmb{D}^{\top}\pmb{D}\pmb{c}\\ 761 | = \mathop{\arg\min}_{\pmb{c}}-2\pmb{x}^{\top}\pmb{D}\pmb{c} + 762 | \pmb{c}^{\top}\pmb{I}_l\pmb{c} 763 | \end{gather} 764 | 765 | （由于约束在 $\pmb{D}$ 上的正交性和单位\gls*{norm}） 766 | \begin{equation} 767 | = \mathop{\arg\min}_{\pmb{c}}-2\pmb{x}^{\top}\pmb{D}\pmb{c} + 768 | \pmb{c}^{\top}\pmb{c} 769 | \end{equation} 770 | 771 | 我们能够使用\gls*{vec}微积分解这个最优化问题（如果你不知道怎么做，参 772 | 见~\ref{sec:gradient-based_optimization} 节）： 773 | \begin{gather} 774 | \nabla_{\pmb{c}}(-2\pmb{x}^{\top}\pmb{D}\pmb{c} + \pmb{c}^{\top}\pmb{c}) = 0\\ 775 | -2\pmb{D}^{\top}\pmb{x} + 2\pmb{c} = 0\\ 776 | \pmb{c} = \pmb{D}^{\top}\pmb{x} 777 | \end{gather} 778 | 779 | 这使得算法更有效率：我们能够仅仅使用一个矩阵--\gls*{vec}算子来最优化地编 780 | 码 $\pmb{x}$。要编码一个\gls*{vec}，我们应用编码器函数 781 | \begin{equation} 782 | f(\pmb{x}) = \pmb{D}^{\top}\pmb{x} 783 | \end{equation} 784 | 利用更进一步的矩阵操作，我们也能够定义 PCA 的重构算子： 785 | \begin{equation} 786 | r(\pmb{x}) = g(f(\pmb{x})) = \pmb{D}\pmb{D}^{\top}\pmb{x} 787 | \label{eq:pca_reconstruction_operation} 788 | \end{equation} 789 | 790 | 接下来，我们需要选择编码矩阵 $\pmb{D}$。为此，我们回顾下最小化输入和重构的 $L^2$ 791 | 距离的想法。然而，既然我们会使用相同的矩阵 $\pmb{D}$ 来解码所有点，我们不能再孤立 792 | 地考虑这些点。相反，我们必须最小化在所有维度和所有点上计算的误差矩阵的弗罗贝尼乌 793 | 斯\gls*{norm}： 794 | \begin{equation} 795 | \pmb{D}^* = \mathop{\arg\min}_{\pmb{D}}\sqrt{\sum_{i,j}(x^{(i)}_j - 796 | r(\pmb{x}^{(i)})_j)^2}\quad\text{使}\;\pmb{D}^{\top}\pmb{D} = 797 | \pmb{I}_l\;\text{满足} 798 | \label{eq:frobenius_norm_of_errors_matrix} 799 | \end{equation} 800 | 801 | 为了推导找出 $\pmb{D}^*$ 的算法，我们开始会考虑 $l = 1$ 的情况。在这种情况 802 | 下，$\pmb{D}$ 仅仅是单个\gls*{vec}，$\pmb{d}$。将方 803 | 程~\ref{eq:pca_reconstruction_operation} 代入方 804 | 程~\ref{eq:frobenius_norm_of_errors_matrix} 并将 $\pmb{D}$ 简化为 $\pmb{d}$，这个 805 | 问题缩小为 806 | \begin{equation} 807 | \pmb{d}^* = \mathop{\arg\min}_{\pmb{d}}\sum_i\|\pmb{x}^{(i)} - 808 | \pmb{d}\pmb{d}^{\top}\pmb{x}^{(i)}\|^2_2\quad\text{使}\;\|\pmb{d}\|_2 = 809 | 1\;\text{满足} 810 | \end{equation} 811 | 812 | 上面的公式化是实施代入的最直接的方法，但在写方程的风格上不是最令人满意的方法。它 813 | 把标量值 $\pmb{d}^{\top}\pmb{x}^{(i)}$ 放在\gls*{vec} $\pmb{d}$ 的右边。把标量系 814 | 数写在它们作用于的\gls*{vec}更符合习惯。所以我们通常把这样一个公式写为 815 | \begin{equation} 816 | \pmb{d}^* = \mathop{\arg\min}_{\pmb{d}}\sum_i\|\pmb{x}^{(i)} - 817 | \pmb{d}^{\top}\pmb{x}^{(i)}\pmb{d}\|^2_2\quad\text{使}\;\|\pmb{d}\|_2 = 818 | 1\;\text{满足} 819 | \end{equation} 820 | 或者，利用一个标量是它自身的转置这一事实，写为 821 | \begin{equation} 822 | \pmb{d}^* = \mathop{\arg\min}_{\pmb{d}}\sum_i\|\pmb{x}^{(i)} - 823 | \pmb{x}^{(i)\top}\pmb{d}\pmb{d}\|^2_2\quad\text{使}\;\|\pmb{d}\|_2 = 824 | 1\;\text{满足} 825 | \end{equation} 826 | 读者应该力求变得熟悉这样的妆点性的重新整理。 827 | 828 | 到这里，以一个设计好的样本矩阵的形式，而不是在单独样本\gls*{vecs}上的求和，来重写 829 | 这个问题会更有帮助。这会允许我们使用更紧凑的符号。让 $\pmb{X} \in \mathbb{R}^{m 830 | \times n}$ 作为由整齐堆积所有描述这些点的\gls*{vecs}~——~诸如 831 | $\pmb{X}_{i,:} = {x^{(i)}}^{\top}$~——~定义的矩阵。我们现在能够重写问题为 832 | \begin{equation} 833 | \pmb{d}^* = \mathop{\arg\min}_{\pmb{d}}\sum_i\|\pmb{X} - 834 | \pmb{X}\pmb{d}\pmb{d}^{\top}\|^2_F\quad\text{使}\;\pmb{d}^{\top}\pmb{d} = 835 | 1\;\text{满足} 836 | \end{equation} 837 | 838 | 暂时忽略约束，我们能够如下简化弗罗贝尼乌斯范数部分： 839 | \begin{gather} 840 | \mathop{\arg\min}_{\pmb{d}}\|\pmb{X} - \pmb{X}\pmb{d}\pmb{d}^{\top}\|^2_F\\ = 841 | \mathop{\arg\min}_{\pmb{d}}\mathrm{Tr}\,\bigg(\Big(\pmb{X} - 842 | \pmb{X}\pmb{d}\pmb{d}^{\top}\Big)^{\top}\Big(\pmb{X} - 843 | \pmb{X}\pmb{d}\pmb{d}^{\top}\Big)\bigg) 844 | \end{gather} 845 | 846 | （由于方程~\ref{eq:trace_operator_of_frobenius_norm}） 847 | \begin{gather} 848 | = \mathop{\arg\min}_{\pmb{d}}\mathrm{Tr}(\pmb{X}^{\top}\pmb{X} - 849 | \pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top} - 850 | \pmb{d}\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X} + 851 | \pmb{d}\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top})\\ = 852 | \mathop{\arg\min}_{\pmb{d}}\mathrm{Tr}(\pmb{X}^{\top}\pmb{X}) - 853 | \mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) - 854 | \mathrm{Tr}(\pmb{d}\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X}) + 855 | \mathrm{Tr}(\pmb{d}\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top})\\ = 856 | \mathop{\arg\min}_{\pmb{d}} - 857 | \mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) - 858 | \mathrm{Tr}(\pmb{d}\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X}) + 859 | \mathrm{Tr}(\pmb{d}\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) 860 | \end{gather} 861 | 862 | （因为不涉及 $\pmb{d}$ 的项不影响 $\arg\min$） 863 | \begin{equation} 864 | = \mathop{\arg\min}_{\pmb{d}} - 865 | 2\mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) + 866 | \mathrm{Tr}(\pmb{d}\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) 867 | \end{equation} 868 | 869 | （因为我们能够循环更替一个迹中矩阵的顺序，方程~\ref{eq:trace_of_square_matrix}） 870 | \begin{equation} 871 | = \mathop{\arg\min}_{\pmb{d}} - 872 | 2\mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) + 873 | \mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}\pmb{d}\pmb{d}^{\top}) 874 | \end{equation} 875 | 876 | （再次使用相同的特性） 877 | 878 | 到这里，我们重新引入约束： 879 | \begin{gather} 880 | \mathop{\arg\min}_{\pmb{d}} - 881 | 2\mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) + 882 | \mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}\pmb{d}\pmb{d}^{\top}) 883 | \quad\text{使}\;\pmb{d}^{\top}\pmb{d} = 1\;\text{满足}\\ 884 | = \mathop{\arg\min}_{\pmb{d}} - 885 | 2\mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) + 886 | \mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) 887 | \quad\text{使}\;\pmb{d}^{\top}\pmb{d} = 1\;\text{满足} 888 | \end{gather} 889 | 890 | （由于约束） 891 | \begin{gather} 892 | = \mathop{\arg\min}_{\pmb{d}} - 893 | \mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) 894 | \quad\text{使}\;\pmb{d}^{\top}\pmb{d} = 1\;\text{满足}\\ 895 | = \mathop{\arg\min}_{\pmb{d}} 896 | \mathrm{Tr}(\pmb{X}^{\top}\pmb{X}\pmb{d}\pmb{d}^{\top}) 897 | \quad\text{使}\;\pmb{d}^{\top}\pmb{d} = 1\;\text{满足}\\ 898 | = \mathop{\arg\min}_{\pmb{d}} 899 | \mathrm{Tr}(\pmb{d}^{\top}\pmb{X}^{\top}\pmb{X}\pmb{d}) 900 | \quad\text{使}\;\pmb{d}^{\top}\pmb{d} = 1\;\text{满足} 901 | \end{gather} 902 | 903 | 这个最优化问题可以使用特征分解来解。明确地说，最优化的 $\pmb{d}$ 由对应于最大 904 | 的\gls*{eigen-val}的\gls*{eigen-vec} $\pmb{X}^{\top}\pmb{X}$ 给出。 905 | 906 | 在普遍情况下，$l > 1$，矩阵 $\pmb{D}$ 由对应于最大的\gls*{eigen-val}的 $l$ 907 | \gls*{eigen-vecs}给出。这可以使用归纳证明来显示。我们建议把写这个证明作为练习。 908 | 909 | 线性代数是理解\gls*{dl}所必需的基本数学学科之一。另一个\gls*{ml}中普遍存在的重要 910 | 的数学领域是概率论，接下来介绍。 911 | -------------------------------------------------------------------------------- /contents/linear_factors.tex: -------------------------------------------------------------------------------- 1 | \chapter{线性因子模型} 2 | \label{ch:linear_factors} 3 | -------------------------------------------------------------------------------- /contents/ml.tex: -------------------------------------------------------------------------------- 1 | \chapter{机器学习基础} 2 | \label{ch:ml} 3 | 4 | Deep learning is a specific kind of machine learning. In order to understand deep learning well, one must have a solid understanding of the basic principles of machine learning. This chapter provides a brief course in the most important general principles that will be applied throughout the rest of the book. Novice readers or those who want a wider perspective are encouraged to consider machine learning textbooks with a more comprehensive coverage of the fundamentals, such as Murphy (2012) or Bishop (2006). If you are already familiar with machine learning basics, feel free to skip ahead to Sec. 5.11. That section covers some per- spectives on traditional machine learning techniques that have strongly influenced the development of deep learning algorithms. 5 | 6 | 深度学习是一种特殊情形的机器学习。扎实的机器学习原理知识能够帮助更好的理解深度学习。这一章节提供了一个简要的机器学习课程，覆盖了重要的机器学习原理，这些原理贯穿了本书的其他章节。新的读者或者想扩展视角的读者可以考虑阅读更全面覆盖机器学习基础知识的教科书，比如 \cite{MMmphy}，或者 \cite{Bishop}。如果你已经熟悉机器学习原理，你可以跳到5.11节。在5.11节中，覆盖了强烈影响深度学习算法发展的传统机器学习技术的一些因素。 7 | 8 | We begin with a definition of what a learning algorithm is, and present an example: the linear regression algorithm. We then proceed to describe how the challenge of fitting the training data differs from the challenge of finding patterns that generalize to new data. Most machine learning algorithms have settings called hyperparameters that must be determined external to the learning algorithm itself; we discuss how to set these using additional data. Machine learning is essentially a form of applied statistics with increased emphasis on the use of computers to statistically estimate complicated functions and a decreased emphasis on proving confidence intervals around these functions; we therefore present the two central approaches to statistics: frequentist estimators and Bayesian inference. Most machine learning algorithms can be divided into the categories of supervised learning and unsupervised learning; we describe these categories and give some examples of simple learning algorithms from each category. Most deep learning algorithms are based on an optimization algorithm called stochastic gradient descent. We describe how to combine various algorithm components such as an optimization algorithm, a cost function, a model, and a dataset to build a machine learning algorithm. Finally, in Sec. 5.11, we describe some of the factors that have limited the ability of traditional machine learning to generalize. These challenges have motivated the development of deep learning algorithms that overcome these obstacles. 9 | 10 | 我们从什么是学习算法的定义开始，并且展示了一个学习算法的例子：线性回归算法 (Linear Regression Algorithm)。然后，我们继续描述拟合训练数据的挑战与发现的模式并将其推广到新的数据上的挑战之间的不同。大多数机器学习算法有超参数(hyperparameter)的设定，超参数是由外部决定的而不是算法本身。机器学习本质上是应用统计学的一种形式，注重从统计学的角度利用计算机来估计复杂的函数，并且降低了围绕这些函数置信区间证明的强调；因此，我们介绍两种常用的统计学方法：频率估计和贝叶斯推理。大多数机器学习算法可分为监督学习和无监督学习两类；我们描述这些类别并且每一类给出一些简单的例子。大多数深度学习算法是建立在随机梯度下降优化算法之上的。我们描述了如何将不同的算法组件，比如，优化算法，成本函数，模型，数据，组合在一起去构建机器学习算法。最后，在5.11节中，我们描述了一些限制传统机器学习泛化的一些因素。这些挑战促进了深度学习的发展去克服这些障碍。 11 | 12 | 13 | 14 | \section{学习算法 Learning Algorithms} 15 | 16 | A machine learning algorithm is an algorithm that is able to learn from data. But what do we mean by learning? Mitchell (1997) provides the definition “A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E.” One can imagine a very wide variety of experiences E, tasks T, and performance measures P, and we do not make any attempt in this book to provide a formal definition of what may be used for each of these entities. Instead, the following sections provide intuitive descriptions and examples of the different kinds of tasks, performance measures and experiences that can be used to construct machine learning algorithms. 17 | 18 | 机器学习算法是一种能够从数据中学习的算法。但是，所说的学习指的是什么呢？Mitchell (1997) 给出了定义 “对于某类任务T和性能度量P，如果一个计算机程序在T上以P衡量的性能随着经验E而自我完善，那么我们称这个计算机程序在从经验E学习。“ 19 | 20 | \section{Capacity, Overfitting and Underfitting} 21 | 22 | \section{Hyperparameters and Validation Sets} 23 | 24 | \section{Estimators, Bias and Variance} 25 | 26 | \section{Maximum Likelihood Estimation} 27 | 28 | \section{Bayesian Statistics} 29 | 30 | \section{Supervised Learning Algorithms} 31 | 32 | \section{Unsupervised Learning Algorithms} 33 | 34 | \section{Stochastic Gradient Descent} 35 | 36 | \section{Building a Machine Learning Algorithm} 37 | 38 | \section{Challenges Motivating Deep Learning} -------------------------------------------------------------------------------- /contents/mlp.tex: -------------------------------------------------------------------------------- 1 | \chapter{深度前驱网络} 2 | \label{ch:mlp} 3 | -------------------------------------------------------------------------------- /contents/monte_carlo.tex: -------------------------------------------------------------------------------- 1 | \chapter{蒙特卡罗法} 2 | \label{ch:monte_carlo} 3 | 随机算法有两个类别：拉斯维加斯（Las Vegas）算法和蒙特卡罗（Monte Carlo）算法（后简称蒙特卡罗法）. 拉斯维加斯算法总是准确地返回正确的结果（或者失败）. 这类算法需要随机数量的资源，通常是时间或者内存. 4 | 而蒙特卡罗法返回有着随机错误率的结果. 错误率一般可以通过增加资源（如运行时间和内存）降低. 对任何固定的计算预算，蒙特卡罗法可以给出一个近似结果. \\ 5 | 6 | 很多机器学习中的问题太过困难以至于我们无法期望得到准确的解. 这和准确的确定型算法和拉斯维加斯算法区分开来. 我们必须使用确定型近似算法或者蒙特卡罗近似. 7 | 8 | 9 | 10 | 11 | 在 16.2.2 节，我们看到了很多概率模型（通常是无向图模型）是由一个没有正规化的概率分布 $\tilde{p}(\mathbf{x};\theta)$ 定义的. 我们必须通过除以一个配分函数 $Z(\pmb{\theta})$ 来正规化 $\tilde{p}$ 才能得到一个合法的概率分布： 12 | 13 | \begin{equation} \label{eq:pyth} 14 | p(\mathbf{x};\pmb{\theta}) = \frac{1}{Z(\pmb{\theta})} \tilde{p}(\mathbf{x}; \pmb{\theta}). 15 | \end{equation} 16 | 17 | 配分函数对连续型变量是积分，而对离散型变量是对所有状态的非正规化概率进行求和： 18 | 19 | \begin{equation} \label{eq:pyth} 20 | \int \!\tilde{p}(\pmb{x})\, \mathrm{d}\pmb{x} 21 | \end{equation} 22 | 23 | 或者 24 | 25 | \begin{equation} \label{eq:pyth} 26 | \sum_{x} \tilde{p}(\pmb{x}). 27 | \end{equation} 28 | 29 | 这个操作对很多有趣的模型都是难解的. 30 | 31 | 如我们将在第 20 章中看到的，有些深度学习模型被设计成有可解的正规化常量，或者被设计成不需要包含计算 $p(\mathbf{x})$ 的. 然而，其他的模型需要直接面对难解的配分函数的挑战. 本章，我们会给出一些用来训练和评估那些有着难解配分函数的模型的技术. 32 | 33 | \section{对数似然梯度 log-likelihood gradient} 34 | \label{sec:llg} 35 | 36 | 让通过最大似然估计在学习无向的模型中尤其困难的原因是配分函数依赖于参数. 对数似然函数关于参数的梯度包含一个配分函数的梯度项： 37 | 38 | \begin{equation} \label{eq:pyth} 39 | \nabla_{\pmb{\theta}} \log p(\mathbf{x};\pmb{\theta}) = \nabla_{\pmb{\theta}} \log \tilde{p}(\mathbf{x};\pmb{\theta}) - \nabla_{\pmb{\theta}} \log Z(\pmb{\theta}) 40 | \end{equation} 41 | 42 | 这是一个著名的分解——将学习分成正负两个部分.\\ 43 | 44 | 对大多数有趣的无向图模型，负部（negative phase）是困难的. 没有隐含变量或者隐含变量间的交互很少的模型通常会有可解的正部（positive phase） 典型的包含一个直接简单的正部而非常困难的负部的模型是 RBM，它的隐含单元在给定可见单元的时候是彼此是条件独立的. 而正部困难的例子是，隐含元之间的交互特别复杂，这个在第 19 章会讲述. 本章聚焦在负部的难解性上.\\ 45 | 46 | 让我们仔细看看 $\log Z$ 的梯度： 47 | 48 | \begin{equation} \label{eq:pyth} 49 | \frac{\partial}{\partial \pmb{\theta}} \log Z 50 | \end{equation} 51 | \begin{equation} \label{eq:pyth} 52 | =\frac{\frac{\partial}{\partial \pmb{\theta}} Z}{Z} 53 | \end{equation} 54 | \begin{equation} \label{eq:pyth} 55 | =\frac{\frac{\partial}{\partial \pmb{\theta}} \sum_{\mathbf{x}} \tilde{p}(\mathbf{x})}{Z} 56 | \end{equation} 57 | \begin{equation} \label{eq:pyth} 58 | =\frac{\sum_{\mathbf{x} \frac{\partial}{\partial \pmb{\theta}}} \tilde{p}(\mathbf{x})}{Z} 59 | \end{equation} 60 | 61 | 对于那些对所有的 $\mathbf{x}$ 保证 $p(\mathbf{x}) > 0$ 的模型，我们可以为 $\tilde{p}(\mathbf{x})$ 替换 $\exp(\log \tilde{p}(\mathbf{x})$： 62 | \begin{equation} \label{eq:pyth} 63 | \frac{\sum_{\mathbf{x}} \frac{\partial}{\partial \pmb{\theta}} \exp(\log \tilde{p}(\mathbf{x}))}{Z} 64 | \end{equation} 65 | \begin{equation} \label{eq:pyth} 66 | =\frac{\sum_{\mathbf{x}} \exp(\log\tilde{p}(\mathbf{x})) \frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})}{Z} 67 | \end{equation} 68 | \begin{equation} \label{eq:pyth} 69 | =\frac{\sum_{\mathbf{x}} \tilde{p}(\mathbf{x}) \frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})}{Z} 70 | \end{equation} 71 | \begin{equation} \label{eq:pyth} 72 | =\sum_{x}p(\mathbf{x}) \frac{\partial}{\partial \pmb{\theta}} \log \tilde{p}(\mathbf{x}) 73 | \end{equation} 74 | \begin{equation} \label{eq:pyth} 75 | =\mathbf{E}_{x\sim p(\mathbf{x})} \frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x}). 76 | \end{equation} 77 | 78 | 这个推导对离散的 $\pmb{x}$ 进行求和，类似地也可以对连续的 $\pmb{x}$ 进行积分. 在连续版本的推到中，我们使用 Leibniz 法则在积分符号下进行微分，获得等式： 79 | \begin{equation} \label{eq:pyth} 80 | \frac{\partial}{\partial \pmb{\theta}} \int \!\tilde{p}(\mathbf{x}) \, \mathrm{d}\pmb{x} = \int \!\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\pmb{x}) \,\mathrm{d}\pmb{x}. 81 | \end{equation} 82 | 83 | 等式只有在 $\tilde{p}$ 和 $\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})$ 满足某种规范化条件时可用. 用测度论的术语，条件是： 84 | \begin{enumerate*}[label={\roman*)}] 85 | \item $\tilde{p}$ 必须是一个对每个 $\pmb{\theta}$ 值的 $\pmb{x}$ 的 Lebesgue-可积函数； 86 | \item $\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})$ 必须对所有的 $\pmb{\theta}$ 和几乎所有的 $\pmb{x}$ 存在 87 | \item 必须存在一个可积分函数 $R(\pmb{x})$ 控制住 $\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})$（如对所有的 $\pmb{\theta}$ 和几乎所有的 $\pmb{x}$ 有 $|\frac{\partial}{\partial \pmb{\theta}}\tilde{p}(\mathbf{x})|\leq R(\pmb{x})$）. 88 | \end{enumerate*} 89 | 90 | 幸运的是，大多数机器学习模型满足这些条件.\\ 91 | 92 | 这个等式 93 | \begin{equation} \label{eq:pyth15} 94 | \nabla_{\pmb{\theta}} \log Z = \mathbb{E}_{\mathbf{x}\sim p(\mathbf{x})} \nabla_{\pmb{\theta}} \log \tilde{p}(\mathbf{x}) 95 | \end{equation} 96 | 是一系列 Monte Carlo 方法的基础，可以用来近似最大化那些有着难解的配分函数的模型的似然函数.\\ 97 | 98 | 学习无向模型的 Monte Carlo 方法给出了一个直觉框架，我们可以利用这样的框架来思考正部和负部. 在正部中，我们对那些从数据抽取的 $\pmb{x}$ 增加 $\log \tilde{p}(\mathbf{x})$. 在负部中，我们通过减少从模型分布中个采样的 $\log \tilde{p}(\mathbf{x})$ 来降低配分函数.\\ 99 | 100 | 在深度学习文献中，通常会用能量函数参数化 $\log \tilde{p}$（Eq. 16.7）. 在这种情况下，我们可以将正部解释为降低训练样本的能量，而负部则是提升从模型中采样的样本的能量，如图 18.1 所示. 101 | 102 | \section{随机最大似然和对比散度} 103 | 104 | 实现 \eqref{eq:pyth15} 的基本方式是每次需要计算梯度时从一个随机初始化状态的 Markov 链的集合中进行老化（burning）. 在使用随机梯度下降算法进行学习时，这个 Markov 链必须每个梯度步都已经老化. 这个想法就是算法~\ref{alg:mcmc} 105 | 中的训练过程. 内循环中的 Markov 链老化的计算代价让这个过程在计算上不可行，但是这个过程本身是其他实效的近似算法的起点. 106 | 107 | % \begin{algorithm}[H] 108 | % 设置 $\epsilon$，一个很小的正数作为步长. 109 | % 设置 $\k$，Gibbs 步数，足够长满足老化条件. 在一个小的图像块（image patch）上训练 RBM 可能需要 $100$. 110 | 111 | 112 | % \caption{用来最大化对数似然函数的 MCMC 算法，使用梯度下降来处理难解的配分函数} 113 | % \label{alg:algorithm1} 114 | % \end{algorithm} 115 | 116 | \begin{algorithm} 117 | \begin{algorithmic} 118 | \caption{用来最大化对数似然函数的 MCMC 算法，使用梯度下降来处理难解的配分函数} 119 | \label{alg:mcmc} 120 | \STATE 设置 $\epsilon$，一个很小的正数作为步长. 121 | \STATE 设置 $k$，Gibbs 步数，足够长满足老化条件. 在一个小的图像块（image patch）上训练 RBM 可能需要 $100$. 122 | \WHILE{未收敛} 123 | \STATE 从训练集中采样 $m$ 个样本 $\{x^{(1)},\dots,x^{(m)}\}$ 的一个\gls{minibatch}. 124 | \STATE $\mathbf{g} \leftarrow \frac{1}{m}\,\sum_{i = 1}^{m} \nabla_{\pmb{\theta}} \log\tilde{p}(x^{(i)};\pmb{\theta})$. 125 | \STATE 将随机值为对应 $m$ 个样本 $\{\tilde{\mathbf{x}}^{(1)},\dots,\tilde{\mathbf{x}}^{(m)}\}$ 初始化（如，从一个均匀分布或者正态分布，或者也可能是有匹配于模型边缘分布的分布）. 126 | \FOR{$i = 1$ to $k$} 127 | \FOR{$j = 1$ to $m$} 128 | \STATE $\tilde{\mathbf{x}}^{(j)} \leftarrow \mathrm{gibbs\_update}(\tilde{\mathbf{x}}^{(j)})$ 129 | \ENDFOR 130 | \ENDFOR 131 | \STATE $\mathbf{g} \leftarrow \frac{1}{m}\,\sum_{i = 1}^{m} \nabla_{\pmb{\theta}} \log\tilde{p}(x^{(i)};\pmb{\theta})$. 132 | \STATE $\pmb{\theta} \leftarrow \pmb{\theta} + \epsilon \mathbf{g}$. 133 | \ENDWHILE 134 | 135 | \end{algorithmic} 136 | \end{algorithm} 137 | 138 | 我们可以将最大似然 MCMC 方法看成是尝试达到两个力量的平衡，一个力量在数据出现时将模型分布上推，而另一个则在模型的样本出现时下推模型分布. 139 | 图~\ref{fig:18.1} 140 | 141 | % \begin{figure} 142 | % \centering 143 | % \includegraphics[width=1.0\textwidth]{figure18-1} 144 | % \caption{算法~\ref{alg:mcmc} 的正部和负部. 左图，在正部中，我们从数据分布中采样，上推他们的未规范化概率. 可能在数据中的点被更多地上推. 右图，在负部中，我们从模型的概率分布采样，下推他们的未规范化概率. 这样会抵制正部的倾向于在每个处都给未规范化概率加上一个大的常量. 当数据分布和模型分布等同时，正部和负部分别有同样的机会上推和下推. 这种情形出现时，就不再回产生梯度（期望形式），训练必须终止.} 145 | % \label{fig:18.1} 146 | % \end{figure} 147 | 148 | \begin{figure}[htp] 149 | \centering \includegraphics[width=1.0\textwidth]{figure18-1} 150 | \caption{算法~\ref{alg:mcmc} 的正部和负部. 左图，在正部中，我们从数据分布中采样，上推他们的未规范化概率. 可能在数据中的点被更多地上推. 右图，在负部中，我们从模型的概率分布采样，下推他们的未规范化概率. 这样会抵制正部的倾向于在每个处都给未规范化概率加上一个大的常量. 当数据分布和模型分布等同时，正部和负部分别有同样的机会上推和下推. 这种情形出现时，就不再回产生梯度（期望形式），训练必须终止.} 151 | \label{fig:18.1} 152 | \end{figure} 153 | 154 | 155 | 156 | -------------------------------------------------------------------------------- /contents/notation.tex: -------------------------------------------------------------------------------- 1 | \chapter{数学符号} 2 | \label{ch:notation} 3 | 4 | 这一部分提供了一个简明的索引，描述整本书中使用的数学符号。如果你不熟悉任何对应的 5 | 数学概念，这个符号索引可能看起来很吓人。然而，不要绝望，我们在 2 --- 4 章里描述了 6 | 这些概念的大部分。 7 | 8 | \begin{center} 9 | \setstretch{1.5} 10 | {\Large\bfseries 数和数组}\\ 11 | \vspace{1em} 12 | \begin{tabular}{c l} 13 | $a$ & 标量（整数或实数）\\ 14 | $\pmb{a}$ & 向量 \\ 15 | $\pmb{A}$ & 矩阵 \\ 16 | $\pmb{\mathsf{A}}$ & 张量 \\ 17 | $\pmb{I}_n$ & $n$ 行 $n$ 列的单位矩阵 \\ 18 | $\pmb{I}$ & 单位矩阵，其维度隐含在上下文中 \\ 19 | $\pmb{e}^{(i)}$ & 标准的基向量 $[0, \ldots, 0, 1, 0, \ldots, 0]$，$1$ 的位置由 $i$ 确定 \\ 20 | $\mathrm{diag}(\pmb{a})$ & 对角线元素为 $\pmb{a}$ 的对角矩阵 \\ 21 | $\mathrm{a}$ & 标量随机变量 \\ 22 | $\mathbf{a}$ & 向量值随机变量 \\ 23 | $\mathbf{A}$ & 矩阵值随机变量 24 | \end{tabular} 25 | \end{center} 26 | 27 | \vspace{1em} 28 | 29 | \begin{center} 30 | \setstretch{1.5} 31 | {\Large\bfseries 集合和图}\\ 32 | \vspace{1em} 33 | \begin{tabular}{c l} 34 | $\mathbb{A}$ & 集合 \\ 35 | $\mathbb{R}$ & 实数集合 \\ 36 | $\{0,1\}$ & 包含 $0$ 和 $1$ 的集合 \\ 37 | $\{0,1,\ldots,n\}$ & $0$ 到 $n$ 的所有整数集合 \\ 38 | $[a,b]$ & 包括 $a$ 和 $b$ 的实数区间 \\ 39 | $(a,b]$ & 左开右闭区间，不包括 $a$ 但包括 $b$ \\ 40 | $\mathbb{A}\backslash\mathbb{B}$ & 集合差，例如，包含有 $\mathbb{A}$ 的元素但其不在 $\mathbb{B}$ 中的集合 \\ 41 | $\mathcal{G}$ & 图 \\ 42 | $Pa_{\mathcal{G}}(x_i)$ & 图 $\mathcal{G}$ 中 $x_i$ 的父顶点 43 | \end{tabular} 44 | \end{center} 45 | 46 | \vspace{1em} 47 | 48 | \begin{center} 49 | \setstretch{1.5} 50 | {\Large\bfseries 索引}\\ 51 | \vspace{1em} 52 | \begin{tabular}{c l} 53 | $a_i$ & 向量 $\pmb{a}$ 的第 $i$ 个元素，索引起始位置为 $1$ \\ 54 | $a_{-i}$ & 向量 $\pmb{a}$ 中除了第 $i$ 个元素之外的所有其它元素 \\ 55 | $A_{i,j}$ & 矩阵 $\pmb{A}$ 的 $i,j$ 位置元素 \\ 56 | $A_{i,:}$ & 矩阵 $\pmb{A}$ 的第 $i$ 行 \\ 57 | $A_{:,i}$ & 矩阵 $\pmb{A}$ 的第 $i$ 列 \\ 58 | $\mathsfit{A}_{i,j,k}$ & 三维张量 $\pmb{\mathsf{A}}$ 的 $(i,j,k)$ 位置的元素 \\ 59 | $\pmb{\mathsf{A}}_{:,:,i}$ & 三维张量在 $i$ 处的二维切分 \\ 60 | $\mathrm{a}_i$ & 随机向量 $\mathbf{a}$ 的第 $i$ 个元素 61 | \end{tabular} 62 | \end{center} 63 | 64 | \vspace{1em} 65 | 66 | \begin{center} 67 | \setstretch{1.5} 68 | {\Large\bfseries 线性代数操作}\\ 69 | \vspace{1em} 70 | \begin{tabular}{c l} 71 | $\pmb{A}^{\top}$ & 矩阵 $\pmb{A}$ 的转置 \\ 72 | $\pmb{A}^+$ & 矩阵 $\pmb{A}$ 的摩尔--彭若斯广义逆 \\ 73 | $\pmb{A} \odot \pmb{B}$ & 矩阵 $\pmb{A}$ 和 $\pmb{B}$ 的按元素（阿达玛）乘积 \\ 74 | $\det(\pmb{A})$ & 矩阵 $\pmb{A}$ 的行列式 75 | \end{tabular} 76 | \end{center} 77 | 78 | \vspace{1em} 79 | 80 | \begin{center} 81 | \setstretch{1.5} 82 | {\Large\bfseries 微积分}\\ 83 | \vspace{1em} 84 | \begin{tabular}{c l} 85 | $\frac{dy}{dx}$ & $y$ 对 $x$ 求导 \\ 86 | $\frac{\partial y}{\partial x}$ & $y$ 对 $x$ 求偏微分 \\ 87 | $\nabla_{\pmb{x}}y$ & $y$ 在 $\pmb{x}$ 上的梯度 \\ 88 | $\nabla_{\pmb{X}}y$ & $y$ 对 $\pmb{X}$ 求矩阵导数 \\ 89 | $\nabla_{\pmb{\mathsf{X}}}y$ & 包含 $y$ 对 $\pmb{\mathsf{X}}$ 求得的导数的张量 \\ 90 | $\frac{\partial f}{\partial \pmb{x}}$ & $f : \mathbb{R}^n \rightarrow \mathbb{R}^m$ 的雅可比矩阵 $\pmb{J} \in \mathbb{R}^{m \times n}$ \\ 91 | $\nabla^2_{\pmb{x}}f(\pmb{x})$ 或 $\pmb{H}(f)(\pmb{x})$ & $f$ 在输入点 $\pmb{x}$ 的海森矩阵\\ 92 | $\displaystyle\int f(\pmb{x})d\pmb{x}$ & 在整个 $\pmb{x}$ 上的定积分\\ 93 | $\displaystyle\int_{\mathbb{S}} f(\pmb{x})d\pmb{x}$ & 在集合 $\mathbb{S}$ 上对 $\pmb{x}$ 的定积分 \\ 94 | \end{tabular} 95 | \end{center} 96 | 97 | \vspace{1em} 98 | 99 | \begin{center} 100 | \setstretch{1.5} 101 | {\Large\bfseries 概率与信息论}\\ 102 | \vspace{1em} 103 | \begin{tabular}{c l} 104 | $\mathrm{a} \bot \mathrm{b}$ & 随机变量 $\mathrm{a}$ 与 $\mathrm{b}$ 互相独立 \\ 105 | $\mathrm{a} \bot \mathrm{b}\: | \: \mathrm{c}$ & 给定 $\mathrm{c}$ 时它们条件独立 \\ 106 | $P(\mathrm{a})$ & 一个离散变量上的概率分布 \\ 107 | $p(\mathrm{a})$ & 一个连续变量，或者类型没有指定的变量上的概率分布 \\ 108 | $\mathrm{a} \sim P$ & 随机变量 $\mathrm{a}$ 具有 $P$ 的分布 \\ 109 | $\mathbb{E}_{\mathrm{x} \sim P} [f(x)]$ 或 $\mathbb{E}f(x)$ & $f(x)$ 对 $P(\mathrm{x})$ 的期望 \\ 110 | $\mathrm{Var}(f(x))$ & 在 $P(\mathrm{x})$ 下 $f(x)$ 的方差 \\ 111 | $\mathrm{Cov}(f(x),g(x))$ & 在 $P(\mathrm{x})$ 下 $f(x)$ 和 $g(x)$ 的协方差 \\ 112 | $H(\mathrm{x})$ & 随机变量 $\mathrm{x}$ 的香农熵 \\ 113 | $D_{\mathrm{KL}}(P \parallel Q)$ & $\mathrm{P}$ 和 $\mathrm{Q}$ 的 $\mathrm{KL}$ 散度 \\ 114 | $\mathcal{N}(\pmb{x};\pmb{\mu};\pmb{\Sigma})$ & $\pmb{x}$ 上均值为 $\pmb{\mu}$，协方差为 $\pmb{\Sigma}$ 的高斯分布 \\ 115 | \end{tabular} 116 | \end{center} 117 | 118 | \vspace{1em} 119 | 120 | \begin{center} 121 | \setstretch{1.5} 122 | {\Large\bfseries 函数}\\ 123 | \vspace{1em} 124 | \begin{tabular}{c l} 125 | $f : \mathbb{A} \rightarrow \mathbb{B}$ & 定义域为 $\mathbb{A}$，值域为 $\mathbb{B}$ 的函数 $f$ \\ 126 | $f \circ g$ & 函数 $f$ 和 $g$ 的组合 \\ % 复合函数 127 | $f(\pmb{x};\pmb{\theta})$ & $\pmb{x}$ 的函数，$\pmb{x}$ 由 $\pmb{\theta}$ 参数化。有时候我们只写 $f(\pmb{x})$，忽略参数 $\pmb{\theta}$ 来简化符号。 \\ 128 | $\log x$ & $x$ 的自然对数 \\ 129 | $\sigma(x)$ & {\serif Logistic sigmoid}，$\displaystyle\frac{1}{1 + \exp(-x)}$ \\ 130 | $\zeta(x)$ & {\serif Softplus}，$\log(1 + \exp(x))$ \\ 131 | $||\pmb{x}||_p$ & $\pmb{x}$ 的 $L^p$ \gls*{norm} \\ 132 | $||\pmb{x}||$ & $\pmb{x}$ 的 $L^2$ \gls*{norm} \\ 133 | $x^+$ & $x$ 的正数部分，即 $\max(0,x)$ \\ 134 | $\pmb{1}_{\mathrm{condition}}$ & 如果条件真为 $1$，否则为 $0$ \\ 135 | \end{tabular} 136 | \end{center} 137 | 138 | 有时候我们使用一个参数是一个标量的函数 $f$，但是将它应用到一个向量、矩阵或者张量： 139 | $f(\pmb{x})$，$f(\pmb{X})$，或 $f(\pmb{\mathsf{X}})$。这意思是将 $f$ 按元素应用 140 | 到数组。例如，如果 $\pmb{\mathsf{C}} = \sigma(\pmb{\mathsf{X}})$，那么对于所有有 141 | 效的 $i$，$j$ 和 $k$ 的值，$\mathsfit{C}_{i,j,k} = \sigma(\mathsfit{X}_{i,j,k})$。 142 | 143 | \vspace{1em} 144 | 145 | \begin{center} 146 | \setstretch{1.5} 147 | {\Large\bfseries 数据集和分布}\\ 148 | \vspace{1em} 149 | \begin{tabular}{c l} 150 | $p_{\mathrm{data}}$ & 数据生成的分布 \\ 151 | $\hat{p}_{\mathrm{data}}$ & 由训练集定义的经验分布 \\ 152 | $\mathbb{X}$ & 一个训练样本集 \\ 153 | $\pmb{x}^{(i)}$ & （输入自）数据集的第 $i$ 个样本 \\ 154 | $y^{(i)}$ 或 $\pmb{y}^{(i)}$ & 与 $\pmb{x}^{(i)}$ 关联的有监督学习的目标 \\ 155 | $\pmb{X}$ & $m \times n$ 矩阵，其具有在 $\pmb{X}_i$ 行中的输入样本 $\pmb{x}^{(i)}$ \\ 156 | % TODO: 原文最后有个冒号，可能还没完成 157 | \end{tabular} 158 | \end{center} 159 | -------------------------------------------------------------------------------- /contents/numerical.tex: -------------------------------------------------------------------------------- 1 | \chapter{数值计算} 2 | \label{ch:numerical} 3 | 4 | \gls*{ml}算法通常需要大量的数值计算。这通常指那些解决数学问题的算法，这样的算法使 5 | 用的方法是通过一个迭代的过程，而不是给定一个对正确解的象征性的表达式分析导出一个 6 | 公式。常见的操作包括优化（找到一个参数的值，最小化或者最大化一个函数）和解线性方 7 | 程组。当函数涉及到实数，在一个计算机上即使只是对一个数学函数求值都是困难的，它无 8 | 法用有限内存精确表示。 9 | 10 | \section{溢出和下溢} 11 | \label{sec:overflow_and_underflow} 12 | 13 | 在一个数字计算机上做连续的数学计算的主要困难，是我们需要用一个有限的、以 bit 位的 14 | 模式的数字来表示无限多的实数。这意味着对于几乎所有的实数，当我们在计算机中表示这 15 | 些数字时引起了一些近似误差。在多数情况下，这仅仅是舍入误差。舍入误差是有问题的， 16 | 尤其是当它经过许多操作后进一步恶化，并且，如果算法没有被设计为最小化舍入误差的累 17 | 加，它们能使理论上可行的算法在实际中失败。 18 | 19 | 一种特别严重的舍入误差的形式是\emph{\gls{underflow}}。\gls*{underflow}发生在当数 20 | 字接近 $0$ 而被舍入为 $0$ 的时候。许多函数当它们的参数为 $0$ 而不是一个小的正数时 21 | 表现出本质上的不同。例如，我们通常想要避免被 $0$ 除（当这种情况发生时有些软件环境 22 | 会产生异常，其它的会返回结果为一个占位符 \verb!not-a-number! 的值）或者取 $0$ 的 23 | 对数（这通常被当作 $-\infty$ 对待，如果它被用于更进一步的算数操作会变 24 | 成 \verb!not-a-number!）。 25 | 26 | 另一个有高度破坏性的数值误差的形式是\emph{\gls{overflow}}。\gls*{overflow}发生在 27 | 当具有大的数量级的数字被近似为 $\infty$ 或 $-\infty$ 的时候。进一步的算数计算通常 28 | 把这些无限值改为 \verb!not-a-number! 值。 29 | 30 | 一个函数必须针对\gls*{underflow}和\gls*{overflow}稳定化的函数是\gls*{softmax}函 31 | 数。\gls*{softmax}函数常常被用于预测和一个多项分布关联的概率。\gls*{softmax}函数 32 | 被定义为 33 | \begin{equation} 34 | \mathrm{softmax}(\pmb{x})_i = \frac{\exp(x_i)}{\sum_{j=1}^n\exp(x_j)} 35 | \end{equation} 36 | 37 | 考虑当所有的 $x_i$ 等于某个常数 $c$ 时会发生什么。通过分析，我们能够看到所有的输 38 | 出应该等于 $\frac{1}{n}$。从数字上看，当 $c$ 有很大的数量级时这可能不会发生。如 39 | 果 $c$ 是很小的负数，那么 $\exp(c)$ 会\gls*{underflow}。这意味着\gls*{softmax}的 40 | 分母会变成 $0$，所以最后的结果是未定义的。当 $c$ 是非常大的正 41 | 数，$\exp(c)$ 会\gls*{overflow}，再一次导致整个表达式为未定义的。这两个困难都能够 42 | 通过对 $\mathrm{softmax}(\pmb{z})$ ~——~这里 $\pmb{z} = \pmb{x} - \max_ix_i$ 43 | ~——~求值来解决。通过分析，简单的代数显示，将输入\gls*{vec}加上或者减去一个标 44 | 量，$\mathrm{softmax}$ 函数的值不会被改变。对 $\max_ix_i$ 做减法导致 $\exp$ 有最 45 | 大的参数而为 $0$，这排除了\gls*{overflow}的可能。同样地，分母中至少一项值为 $1$， 46 | 这排除了分母中导致被 $0$ 除的\gls*{underflow}的可能。 47 | 48 | 还有一个小问题。分子上的\gls*{underflow}仍然能引起整个表达式求值为 $0$。这意味着 49 | 如果我们通过先运行 $\mathrm{softmax}$ 子程序然后传递其结果给 $\log$ 函数来实 50 | 现 $\log\mathrm{softmax(\pmb{x})}$ 时，我们会错误地得到 51 | $-\infty$。相反，我们必需实现一个单独的函数，它以一个在数值上稳定的方式计 52 | 算 $\log\mathrm{softmax}$。$\log\mathrm{softmax}$ 函数能够使用我们用于稳定 53 | 化 $\mathrm{softmax}$ 函数的相同技巧来被稳定。 54 | 55 | 在这本书中，对于大部分内容，我们没有明确地详细说明所有涉及到实现不同算法的数值上 56 | 的考虑。底层库的开发者应该在实现\gls*{dl}算法时把数值问题记在心里。本书的大部分读 57 | 者可以简单地依赖已经提供稳定实现的底层库。在有些情况下，有可能实现一个新的算法并 58 | 且自动让新的实现稳定化。Theano 59 | \citep{bergstra+al:2010-scipy-small,Bastien-2012}是一个软件包的例子，它自动检测并 60 | 稳定化许多常见的、出现在\gls*{dl}环境中的、数值上不稳定的表达式。 61 | 62 | \section{不合理的条件作用} 63 | \label{sec:poor_conditioning} 64 | 65 | 条件作用是指一个函数如何随着它的输入中的微小变化快速改变。那些当它们的输入被微小 66 | 扰动时快速变化的函数可能对科学计算是有问题的，这是因为在输入中的舍入误差可以导致 67 | 输出上的巨大变化。 68 | 69 | 考虑函数 $f(\pmb{x}) = \pmb{A}^{-1}\pmb{x}$。当 $\pmb{A} \in \mathbb{R}^{n 70 | \times n}$ 有一个\gls*{eigen-val}分解，它的\emph{\gls{cond-num}}\,是 71 | \begin{equation} 72 | \max_{i,j}|\frac{\lambda_i}{\lambda_j}| 73 | \end{equation} 74 | 75 | 这是最大和最小幅度的\gls*{eigen-val}的比率。当这个数很大时，矩阵求逆对于输入中的 76 | 误差是特别敏感的。 77 | 78 | 这个敏感性是矩阵本身的一个本质特性，不是在矩阵求逆中舍入误差的结果。当我们用真的 79 | 逆矩阵相乘时，条件不合理的矩阵放大了预先存在的误差。在实践中，这个误差会被求逆过 80 | 程自身中的误差进一步加剧。 81 | 82 | \section{基于梯度的最优化} 83 | \label{sec:gradient-based_optimization} 84 | 85 | 大部分\gls*{dl}算法涉及到某种优化。优化是指通过改变 $\pmb{x}$ 来最小化或者最大化 86 | 某个函数 $f(\pmb{x})$ 的任务。我们通常以最小化 $f(\pmb{x})$ 的形式表达大部分优化 87 | 问题。最大化可以通过一个最小化 $-f(\pmb{x})$ 的算法来完成。 88 | 89 | 我们想要最小化或者最大化的函数被称 90 | 为\emph{\gls{obj-func}}\,或者\emph{\gls{criterion}}。当我们正在最小化它的时候，我 91 | 们也可能称它\emph{\gls{cost-func}}，\emph{\gls{loss-func}}，或 92 | 者\emph{\gls{err-func}}。尽管有些\gls*{ml}出版物给这些术语指定特别的意义，在这本 93 | 数中，我们交换使用这些术语。 94 | 95 | 我们常常用一个上标 $*$ 表示最小化或者最大化一个函数的值。例如，我们可能 96 | 说 $\pmb{x}^* = \arg\min f(\pmb{x})$。 97 | 98 | 我们假设读者已经熟悉微积分，但是这里提供了一个关于微积分概念如何和最优化相联系的 99 | 简要回顾。 100 | 101 | 假设我们有一个函数 $y = f(x)$，其中 $x$ 和 $y$ 都是实数。这个函数的导数被表示 102 | 为 $f'(x)$ 或者 $\frac{dy}{dx}$。导数 $f'(x)$ 给出了 $f(x)$ 在点 $x$ 的斜率。换句 103 | 话说，它指定了如何调整输入中的一个小的变化，以至于获得相应的输出中的变化：$f(x + 104 | \epsilon) \approx f(x) + \epsilon f'(x)$。 105 | 106 | \begin{figure}[h] 107 | \centering 108 | \includegraphics{gradient_descent} 109 | \caption{一个图例，演示一个函数的导数如何能够被用于沿着函数往下移动到一个最小值。 110 | 这个技术被称为\emph{\gls{gradient-descent}}。\label{fig:gradient_descent}} 111 | \end{figure} 112 | 113 | 导数对于最小化一个函数是非常有用的，因为它告诉我们如何改变 $x$ 以至于在 $y$ 上产 114 | 生一个小的改进。例如，我们知道对于足够小的 $\epsilon$，$f(x - \epsilon 115 | \mathrm{sign}(f'(x)))$ 比 $f(x)$ 小。这样我们能够通过以导数的相反符号小步地移 116 | 动 $x$ 来减小 117 | $f(x)$。这个技术被称为\emph{\gls{gradient-descent}}。这个技术的示例参见 118 | 图~\ref{fig:gradient_descent}。 119 | 120 | 当 $f'(x) = 0$ 时，导数没有提供关于往哪个方向移动的信息。在 $f'(x) = 0$ 的点被称 121 | 为\emph{\gls{critical-points}}\,或者\emph{\gls{stationary-points}}。一 122 | 个\emph{\gls{local-min}}\,是一个在 $f(x)$ 比所有相邻点都小的位置处的点，所以不再 123 | 可能通过做极小的步进来减小 $f(x)$。一个\emph{\gls{local-max}}\,是一个在 $(fx)$ 比 124 | 所有相邻点都大的位置处的点，所以不再可能通过做极小的步进来增加 125 | $f(x)$。某些\gls*{critical-points}既不是最大值也不是最小值。它们被称 126 | 为\emph{\gls{saddle-points}}。每种类型的临界点参见图~\ref{fig:critical_points}。 127 | 128 | \begin{figure}[h] 129 | \centering 130 | \includegraphics{critical_points} 131 | \caption{一维空间中三种临界点的示例。一个临界点是斜率为 $0$ 的点。这样的一个点 132 | 既可以是一个局部最小值~——~它比相邻点更低，一个局部最大值~——~它比相邻点更高， 133 | 也可以是一个鞍点~——~它有高于和低于这个点自身的相邻 134 | 点。\label{fig:critical_points}} 135 | \end{figure} 136 | 137 | 一个取得 $f(x)$ 的绝对最低值的点是一个\emph{\gls{global-min}}。函数可能存在只有一 138 | 个\gls*{global-min}或者多个\gls*{global-min}。也有可能存在并不是全局最优化的局部 139 | 最小值。在\gls*{dl}环境中，我们优化的函数可能有许多不是最优的局部最小值，而且许多 140 | 鞍点被非常平整的区域包围。所有这些使得最优化非常困难，尤其当函数的输入是多维的时 141 | 候。所以我们通常满足于找到一个非常低的 $f$ 的值，但不是必须在任何正式意义上是最小 142 | 的。参见图~\ref{fig:approximate_minimization} 的示例。 143 | 144 | \begin{figure}[h] 145 | \centering 146 | \includegraphics{approximate_minimization} 147 | \caption{最优化算法可能失败\label{fig:approximate_minimization}} 148 | \end{figure} 149 | 150 | 我们常常最小化有多个输入的函数：$f: \mathbb{R}^n \rightarrow \mathbb{R}$。为了 151 | 让``最小化''的概念有意义，必须只有一个（标量）输出。 152 | 153 | 对于具有多个输入的函数，我们必须利用\emph{\gls{partial-derivatives}}\,的概念。偏 154 | 导数 $\frac{\partial}{\partial x_i}f(\pmb{x})$ 测量 $f$ 在点 $\pmb{x}$ 仅当变 155 | 量 $x_i$ 增加时如何改变。\emph{\gls{gradient}}\,概括了在导数是相对于一 156 | 个\gls*{vec}的情况下导数的概念：$f$ 的梯度是包含所有偏导数的\gls*{vec}，表示 157 | 为 $\nabla_{\pmb{x}}f(\pmb{x})$。梯度中的元素 $i$ 是 $f$ 对于 $x_i$ 的偏导数。在 158 | 多维中，临界点是那些梯度中的每个元素等于 $0$ 的点。 159 | 160 | $\pmb{u}$ 方向（一个单位\gls*{vec}）上的\emph{\gls{directional-derivative}}\,是函 161 | 数 $f$ 在 $u$ 方向上的斜率。换句话说，方向导数是函数 $f(\pmb{x} + 162 | \alpha\pmb{u})$ 对于 $\alpha$ 的导数，在 $\alpha = 0$ 处求值。使用这个链式规则， 163 | 我们能够看到 164 | $\frac{\partial}{\partial\alpha}f(\pmb{x} + \alpha\pmb{u}) = 165 | \pmb{u}^{\top}\nabla_{\pmb{x}}f(\pmb{x})$。 166 | 167 | 为了最小化 $f$，我们想要找到 $f$ 减小最快的方向。我们能够使用方向导数来这样做： 168 | \begin{gather} 169 | \min_{\pmb{u},\pmb{u}^{\top}\pmb{u}=1}\pmb{u}^{\top}\nabla_{\pmb{x}}f(\pmb{x})\\ 170 | = \min_{\pmb{u},\pmb{u}^{\top}\pmb{u}=1}\|\pmb{u}\|_2\|\nabla_{\pmb{x}}f(\pmb{x})\|_2\cos\theta 171 | \end{gather} 172 | 其中 $\theta$ 是 $\pmb{u}$ 和梯度的夹角。代入 $\|\pmb{u}\|_2 = 1$ 并且忽略不依赖 173 | 于 $\pmb{u}$ 的因子，这简化为 $\min_{\pmb{u}}\cos\theta$。当 $\pmb{u}$ 指向梯度的 174 | 相反方向时其被最小化。换句话说，梯度直接指向上面，而负的梯度直接指向下面。我们能 175 | 够通过沿着负的梯度方向移动来减小 176 | $f$。这被称为\emph{\gls{steepest-descent}}\,或者\emph{\gls{gradient-descent}}。 177 | 178 | 最陡下降提出了一个新的点 179 | \begin{equation} 180 | \pmb{x}' = \pmb{x} - \epsilon\nabla_{\pmb{x}}f(\pmb{x}) 181 | \end{equation} 182 | 其中 $\epsilon$ 是\emph{\gls{learning-rate}}，一个决定步长的正的标量。我们可以用 183 | 几个不同方法来选择 $\epsilon$。一个流行的方法是把 $\epsilon$ 设为一个小的常数。 184 | 有时候，我们能够解步长大小，使方向导数消失。另一种方法是对几个 $\epsilon$ 的值求 185 | 得$f(\pmb{x} - \epsilon\nabla_{\pmb{x}}f(\pmb{x}))$，选择导致最小\gls*{obj-func} 186 | 值的那个。最后一个策略被称为一个\emph{\gls{line-search}}。 187 | 188 | 最陡下降在梯度中的每个元素为 $0$ （或者，在实践中，非常接近于 $0$）时会于一点。在 189 | 某些情况下，我们可能避免运行这个迭代算法，而只是通过解 $\pmb{x}$ 的方 190 | 程 $\nabla_{\pmb{x}}f(\pmb{x}) = 0$ 直接跳到临界点。 191 | 192 | 尽管梯度下降被限制于连续空间的最优化，朝更好的配置做小的移动（即大致是最好的小的 193 | 移动）的一般概念可以推广到离散空间。上升一个离散参数的\gls*{obj-func}被称 194 | 为\emph{\gls{hill-climbing}} \citep{Russel+Norvig-book2003}。 195 | 196 | \subsection{超越梯度：雅可比和海森矩阵} 197 | \label{subsec:beyong_the_gradient} 198 | 199 | 有时候我们需要找到一个函数的所有偏导数，它的输入和输出都是\gls*{vecs}。包含所有这 200 | 样偏导数的矩阵被称为一个\emph{\gls{jacobian-matrix}}。具体来说，如果我们有一个函 201 | 数 $\pmb{f}: \mathbb{R}^m \rightarrow \mathbb{R}^n$，那 202 | 么 $\pmb{f}$ 的\gls*{jacobian-matrix} $\pmb{J} \in \mathbb{R}^{n \times m}$ 被定 203 | 义为 $J_{i,j} = \frac{\partial}{\partial x_j}f(\pmb{x})_i$。 204 | 205 | 有时候我们也对导数的导数感兴趣。这被称为一个\emph{\gls{second-derivative}}。例如， 206 | 对于一个函数 $f: \mathbb{R}^n \rightarrow \mathbb{R}$，$f$ 对于 $x_j$ 的导数，其 207 | 对于 $x_i$ 的导数表示为 $\frac{\partial^2}{\partial x_i \partial x_j}f$。在单个维 208 | 度中，我们能够用 $f''(x)$ 209 | 表示$\frac{d^2}{dx^2}$。二阶导数告诉我们当改变输入时一阶导数会如何改变。这很重要， 210 | 因为它告诉我们一个梯度的步进是否会引起足够多的、我们期望的基于梯度自身的改进。我 211 | 们可以把二阶导数看做测量\emph{\gls{curvature}}。假设我们有一个二次函数（许多实际 212 | 出现的函数不是二次的，但是至少局部上能够被很好近似为二次）。如果这样一个函数有一 213 | 个 $0$ 的二阶导数，那么就没有曲率。它是一个完全平整的直线，而且它的值能够只使用梯 214 | 度来预测。如果梯度为 $1$，那么我们能做出一个沿着负的梯度、大小为 $\epsilon$ 的步 215 | 进，而代价函数会减少 $\epsilon$。如果二阶导数是负的，函数曲线朝下，所以代价函数实 216 | 际上会减小超过 $\epsilon$。最后，如果二阶导数是正的，函数曲线朝上，所以代价函数能 217 | 减少小于 $\epsilon$。参见图~\ref{fig:second_derivative} 来了解曲率的不同形式如何 218 | 影响通过梯度预测的代价函数的值和真实值的联系。 219 | 220 | \begin{figure}[h] 221 | \centering 222 | \includegraphics{second_derivative} 223 | \caption{二阶导数决定了一个函数的曲率。这里我们展示具有不同曲率的二次函数。虚线 224 | 指示了代价函数的值~——~我们期望的、当做一个向下的梯度步进时只基于梯度信息的值。 225 | 在负曲率的情况下，代价函数实际上减小得比梯度预测的更快。在无曲率的情况下，梯 226 | 度正确预测其减小。在正曲率的情况下，函数减小得比期望的更慢，并最终开始增加， 227 | 所以太大的步进实际上会不经意地增加函数。\label{fig:second_derivative}} 228 | \end{figure} 229 | 230 | 当函数有多个输入维度，就有许多二阶导数。这些导数能够被收集进一个矩阵，被称 231 | 为\emph{\gls{hessian-matrix}}。\gls*{hessian-matrix} $\pmb{H}(f)(\pmb{x})$ 被定义 232 | 为这样 233 | \begin{equation} 234 | \pmb{H}(f)(\pmb{x})_{i,j} = \frac{\partial^2}{\partial x_i \partial x_j}f(\pmb{x}) 235 | \end{equation} 236 | 相等地，海森矩阵是梯度的雅可比矩阵。 237 | 238 | 任何二阶偏导数连续的地方，微分算子满足交换律，即，它们的顺序可交换： 239 | \begin{equation} 240 | \frac{\partial^2}{\partial x_i \partial y_j}f(\pmb{x}) = \frac{\partial^2}{\partial x_j \partial x_i}f(\pmb{x}) 241 | \end{equation} 242 | 这意味着 243 | $H_{i,j} = H_{j,i}$，所以\gls*{hessian-matrix}在这样的点是对称的。我们 244 | 在\gls*{dl}环境中碰到的大部分函数有一个几乎在任何位置对称的\gls*{hessian-matrix}。 245 | 因为\gls*{hessian-matrix}是实数矩阵并且是对称的，我们能够把它分解成一个实 246 | 数\gls*{eigen-vals}集合和一个\gls*{eigen-vecs}的正交基。在一个由一个单 247 | 位\gls*{vec} $\pmb{d}$ 表示的特定方向上的二阶导数， 248 | 由 $\pmb{d}^{\top}\pmb{H}\pmb{d}$ 得出。当 $\pmb{d}$ 是 $\pmb{H}$ 的一 249 | 个\gls*{eigen-vec}，那个方向上的二阶导数由相应的\gls*{eigen-val}得出。对于其 250 | 它 $\pmb{d}$ 的方向，方向性的二阶导数是所有\gls*{eigen-vals}的一个加权平均，具 251 | 有 $0$ 和 $1$ 之间的权重，并且和 $\pmb{d}$ 有更小夹角的\gls*{eigen-vecs}接收更多 252 | 权重。最大的\gls*{eigen-val}决定了最大的二阶导数，而最小的\gls*{eigen-val}决定了 253 | 最小的二阶导数。 254 | 255 | （方向性的）二阶导数告诉我们能期待一个梯度下降的步进表现得怎样好。我们可以做一个 256 | 二阶泰勒级数，在当前点 $\pmb{x}^{(0)}$ 处逼近函数 $f(\pmb{x})$： 257 | \begin{equation} 258 | f(\pmb{x}) \approx f(\pmb{x}^{(0)}) + (\pmb{x} - \pmb{x}^{(0)})^{\top}\pmb{g} + \frac{1}{2}(\pmb{x} - \pmb{x}^{(0)})^{\top}\pmb{H}(\pmb{x} - \pmb{x}^{(0)}) 259 | \end{equation} 260 | 这里 $\pmb{g}$ 是梯度，$\pmb{H}$ 是在点 $\pmb{x}^{(0)}$ 的\gls*{hessian-matrix}。 261 | 如果我们使用一个 $\epsilon$ 的\gls*{learning-rate}，那么新的 262 | 点 $\pmb{x}$ 会由 $\pmb{x}^{(0)} - \epsilon\pmb{g}$ 得出。把这代入我们的近似方程， 263 | 我们得到 264 | \begin{equation} 265 | f(\pmb{x}^{(0)} - \epsilon\pmb{g}) \approx f(\pmb{x}^{(0)}) - \epsilon\pmb{g}^{\top}\pmb{g} + \frac{1}{2}\epsilon^2\pmb{g}^{\top}\pmb{H}\pmb{g} 266 | \end{equation} 267 | 这里有三个项：函数的原始值，由函数斜率引起的期望的改进，以及为了把函数曲率计算在 268 | 内我们必需应用的校正。当最后一项非常大时，梯度下降步进实际上能够往上移动。当 269 | $\pmb{g}^{\top}\pmb{H}\pmb{g}$ 是 $0$ 或负数，泰勒级数近似预测了不断地增加 270 | $\epsilon$ 会不断地减小 $f$。在实践中，对于大的 $\epsilon$ 泰勒级数不太可能保持 271 | 准确，所以在这种情况下必需借助于更有启发式的 $\epsilon$ 的选择。当 272 | $\pmb{g}^{\top}\pmb{H}\pmb{g}$ 是正的，求解最优的步长~——~最大地减小函数的泰勒级 273 | 数近似~——~得出 274 | \begin{equation} 275 | \epsilon^* = \frac{\pmb{g}^{\top}\pmb{g}}{\pmb{g}^{\top}\pmb{H}\pmb{g}} 276 | \end{equation} 277 | 278 | 在最坏的情况下，当 $\pmb{g}$ 和 $\pmb{H}$ 对应于最大\gls*{eigen-val} 279 | $\lambda_{\max}$ 的\gls*{eigen-vec}对齐，那么这个最优步长由 280 | $\frac{1}{\lambda_{\max}}$ 得出。为了达到我们最小化的函数能够很好地被一个二次函 281 | 数近似的程度，于是\gls*{hessian-matrix}的\gls*{eigen-vals}确定了 282 | \gls*{learning-rate}的大小。 283 | 284 | 二阶导数可以被用于确定一个临界点是否是一个局部最大值、局部最小值，或者鞍点。回想 285 | 到在一个临界点上，$f'(x) = 0$。当 $f''(x) > 0$，这意味着当我们往右移动 286 | 时 $f'(x)$增加，当往左移动时 $f'(x)$ 减小。这意味着对于足够小 287 | 的 $\epsilon$，$f'(x - \epsilon) < 0$ 288 | 而$f'(x + \epsilon) > 0$。换句话说，当我们往右移动，斜率开始指向右上方，而当我们 289 | 往左移动，斜率开始指向左上方。这样，当 $f'(x) = 0$ 而 $f''(x) > 0$ 时，我们能得出 290 | 结论 $x$ 是一个局部最小值。相似地，当 $f'(x) = 0$ 而 $f''(x) < 0$ 时，我们能得出 291 | 结论 $x$ 是一个局部最大值。这被称为\emph{\gls{second-derivative-test}}。不幸的是， 292 | 当 $f''(x) = 0$，检测是不确定的。在这种情况下，$x$ 可能是一个鞍点，或者是一个平整 293 | 区域的一部分。 294 | 295 | 在多个维度中，我们需要检查函数的所有二阶导数。使用\gls*{hessian-matrix}的特征分解， 296 | 我们能够把\gls*{second-derivative-test}概括为多个维度。在一个临界 297 | 点，$\nabla_{\pmb{x}}f(\pmb{x}) = 0$，我们能够检 298 | 查\gls*{hessian-matrix}的\gls*{eigen-vals}来确定临界点是否是一个局部最大值、局部 299 | 最小值或鞍点。当\gls*{hessian-matrix}是正无穷（它的所有\gls*{eigen-vals}是正的）， 300 | 这个点是一个局部最小值。这可以通过观察在任意方向上的方向性的二阶导数来理解，并参 301 | 考单变量的\gls*{second-derivative-test}。同样的，当\gls*{hessian-matrix}是负无穷 302 | （它的所有\gls*{eigen-vals}是负的），这个点是一个局部最大值。在多个维度中，有些情 303 | 况下实际上有可能找到鞍点的正的迹象。当至少一个\gls*{eigen-val}是正的以及至少一 304 | 个\gls*{eigen-val}是负的时候，我们知道 $\pmb{x}$ 在一个 $f$ 的横截面上是一个局部 305 | 最大值，但是在另一个横截面上是一个局部最小值。参见图~\ref{fig:saddle_point} 的示 306 | 例。最后，正如单变量的版本，多维的\gls*{second-derivative-test}可以是不确定的。无 307 | 论当所有的非零\gls*{eigen-vals}有相同符号，但至少一个\gls*{eigen-val}是 $0$ 的时 308 | 候，检测是不确定的。这是因为单变量的\gls*{second-derivative-test}在对应于 309 | 零\gls*{eigen-val}的横截面上是不确定的。 310 | 311 | \begin{figure}[h] 312 | \centering 313 | \includegraphics{saddle_point} 314 | \caption{一个包含正和负曲率的鞍点。这个函数示例是 $f(\pmb{x}) = x^2_1 - x^2_2$。 315 | 沿着对应于 $x_1$ 的坐标轴，函数的曲线朝上。这个坐标轴 316 | 是\gls*{hessian-matrix}的一个\gls*{eigen-vec}并有一个正的\gls*{eigen-val}。沿 317 | 着对应于 $x_2$ 的坐标轴，函数曲线朝下。这个方向是\gls*{hessian-matrix}的一个 318 | 具有负的\gls*{eigen-val}的\gls*{eigen-vec}。``鞍点''这个名称衍生自这个函数的 319 | 马鞍形状。这是一个函数有一个鞍点的典型例子。在超过一个的维度中，为了取得一个 320 | 鞍点，并不必需要有一个为 $0$ 的\gls*{eigen-val}：唯一必需的是既有正的又有负 321 | 的\gls*{eigen-vals}。我们能够把一个鞍点看做既是在一个横截面中的局部最大值又是 322 | 在其它横截面中的局部最小值的\gls*{eigen-vals}的符 323 | 号。\label{fig:saddle_point}} 324 | \end{figure} 325 | 326 | 在多个维度中，因为在每个方向上有不同的二阶导数，在单个点上能够有很多不同的二阶导 327 | 数。\gls*{hessian-matrix}的条件数衡量二阶导数的变化了多少。当 328 | \gls*{hessian-matrix}有一个很差的条件数，梯度下降表现得很差。这是因为在一个方向 329 | 上，导数增加地很快，同时在另一个方向上，它则缓慢减小。梯度下降并没有意识到导数中 330 | 的这个变化，所以它不知道它需要优先检查导数长时间里保持负值的方向。它也使得选择一 331 | 个好的步长变得困难。步长必须足够小，以避免超过最小值，并在具有较强正曲率的方向上 332 | 上升。这通常意味着在其他具有较小曲率的方向上，步长太小而不能产生显著的进展。参见 333 | 图~\ref{fig:curvature_in_hessian} 的一个例子。 334 | 335 | \begin{figure}[h] 336 | \centering 337 | \includegraphics{curvature_in_hessian} 338 | \caption{梯度下降未能利用包含在\gls*{hessian-matrix}中的曲率信息。这里我们使用 339 | 梯度下降来最小化一个二次函数 $f(\pmb{x})$，其\gls*{hessian-matrix}的条件数为 340 | $5$。这意味着曲率最大的方向比曲率最小的方向多 5 倍的曲率。在这例子中，最大曲 341 | 率位于方向 ${[1,1]}^{\top}$，而最小曲率位于 ${[1,-1]}^{\top}$ 方向。红色的线 342 | 表示梯度下降沿着的路径。这个很长的二次函数类似于一个长的峡谷。梯度下降重复地 343 | 把时间浪费在下降峡谷的侧壁，因为他们是最陡的特征。由于步长过大，它有一个冲过 344 | 函数底部的趋势，因此需要在下一次迭代是在对面的峡谷侧壁上下降。 345 | \gls*{hessian-matrix}的大的正\gls*{eigen-val}~——~对应于指向指这一方向的 346 | \gls*{eigen-vec}~——~表明该方向导数的急剧增加，所以一个基于 347 | \gls*{hessian-matrix}的优化算法可以预测最速方向实际上不是在这种环境中有用的 348 | 搜索方向。\label{fig:curvature_in_hessian}} 349 | \end{figure} 350 | 351 | \section{受约束的最优化} 352 | \label{sec:constrained_optimization} 353 | 354 | \section{示例：线性最小二乘法} 355 | \label{sec:example:linear_least_squares} 356 | -------------------------------------------------------------------------------- /contents/optimization.tex: -------------------------------------------------------------------------------- 1 | \chapter{训练深层模型的优化技术} 2 | \label{ch:optimization} 3 | -------------------------------------------------------------------------------- /contents/part_basics.tex: -------------------------------------------------------------------------------- 1 | % file: part_basics.tex 2 | % source: http://www.deeplearningbook.org/contents/part_basics.html 3 | 4 | \part{应用于本书的数学和机器学习基础} 5 | \label{part_basics} 6 | 7 | 本书的这一部分介绍理解\gls*{dl}所需要的基本的数学概念。我们从应用于本书的数学的 8 | 一般概念开始，这些数学允许我们定义多元函数，找到这些函数的最高和最低点，并量化置 9 | 信度。 10 | 11 | 接下来，我们描述\gls*{ml}的基本目标。我们描述如何通过指定一个代表某些置信度的模 12 | 型来完成这些目标，设计一个衡量这些置信度与现实有多符合的代价函数，并用一个训练算 13 | 法来最小化那个代价函数。 14 | 15 | 这个基本框架是各种各样\gls*{ml}算法的基础，包括非深度\gls*{ml}的方法。在本书随后 16 | 部分中，我们在这个框架内开发\gls*{dl}算法。 17 | -------------------------------------------------------------------------------- /contents/part_practical.tex: -------------------------------------------------------------------------------- 1 | \part{深度学习：现代实践} 2 | \label{part_practical} 3 | -------------------------------------------------------------------------------- /contents/part_research.tex: -------------------------------------------------------------------------------- 1 | \part{深度学习研究} 2 | \label{part_research} 3 | 4 | 本书此部分介绍了当前深度学习研究社区中有关深度学习更深的愿景及更加高级的方法. \\ 5 | 6 | 在本书前面的章节中，我们已经展示了如何去解决监督学习问题——在给定足够的映射样本的情况下，如何学习将一个向量映射到另一个向量. \\ 7 | 8 | 不是所有我们想要解决的问题都是落在这个类别中的. 我们可能希望去产生新的样本，或者确定某些点是新的样本，或者处理遗漏值利用大量的无标记样本或者相关的任务的样本. 当前工业应用的最新发展的不足是我们的学习算法需要大量监督数据来达到足够的精确度. 在这个部分，我们会讨论一些降低对已有模型必要的标记数据量和能够应用在多个任务上的尝试性工作. 达成这些目标通常需要某种形式的无监督学习和半监督学习.\\ 9 | 10 | 很多深度学习算法都是被设计成解决无监督学习问题的，但是相比深度学习在监督学习问题上已经取得的处处开花的成就，没有一个真正解决好这个问题. 本书此部分，我们给出已有的无监督学习方法和一些热门的有关如何在此领域取得进展的思考.\\ 11 | 12 | 无监督学习的困难之处在于需要建模的随机变量的维度太高. 这会导致两个不同的挑战：统计学挑战和计算挑战. \emph{统计学挑战}说的是泛化：我们需要的能够区分类别的配置的数量会与有意义的维度的数量呈指数级增长，并且这数字很快超过我们可能拥有的样本数量（或者受到计算资源的限制）. 而 \emph{计算挑战}则是和高维分布相关，很多算法学习或者使用一个训练好的模型（特别是基于估计一个显式的概率函数）会引入与维度呈指数级增长的难解的计算量.\\ 13 | 14 | 有了概率模型，计算挑战是来自进行难解推断或者就是规范化分布的需求.\\ 15 | 16 | \begin{enumerate} 17 | \item \textbf{难解推断}：推断主要会放在第 \ref{ch:inference} 章讨论. 推断就是包含了在一个刻画了变量 $a$，$b$ 和 $c$ 联合分布的模型下，给定另外的变量 $b$，猜测某些变量 $a$ 可能的值的问题. 为了计算这种条件概率，我们需要对变量 $c$ 的可能值进行求和并且计算一个对 $a$ 和 $c$ 的值求和的规范化常量. 18 | \item \textbf{难解规范化化常量（配分函数）}：这部分会在第 \ref{ch:partition} 章进行讨论. 规范化概率函数的常量在推断和学习中均会出现. 不幸的是，学习这样的模型通常需要计算配分函数关于模型参数的梯度. 这种计算通常和计算配分函数本身一样难解. 蒙特卡洛马尔科夫链（Monte Carlo Markov Chain，后简称 MCMC）方法（见第 \ref{ch:monte_carlo} 章）通常用来解决配分函数问题（计算本身或者其梯度）. 然而，MCMC 方法当模型分布的\gls*{mode}很多且分隔明显，特别是高维空间中时就遇到了麻烦（17.5 节）. 19 | \end{enumerate} 20 | 21 | 一种处理这些难解计算问题的方法就是近似，很多近似方法在本书这个部分进行讨论. 另一个这里也会介绍的有趣方法就是通过设计来避免这些难解计算，这些方法就是非常有意义的. 近几年几种生成式模型已经被研究者提出来了，出发点就是良好的设计避免难解计算. 目前生成式模型的研究方法的几种变化在第 \ref{ch:generative_models} 章讨论. \\ 22 | 23 | 第 \ref{part_research} 部分 对那些想要理解深度学习领域已有的观点的宽广，并且志在推进真正的人工智能领域的发展的研究者来说最为重要. 24 | 25 | -------------------------------------------------------------------------------- /contents/partition.tex: -------------------------------------------------------------------------------- 1 | \chapter{处理配分函数} 2 | \label{ch:partition} 3 | 4 | 在 16.2.2 节，我们看到了很多概率模型（通常是无向图模型）是由一个没有正规化的概率分布 $\tilde{p}(\mathbf{x};\theta)$ 定义的. 我们必须通过除以一个配分函数 $Z(\pmb{\theta})$ 来正规化 $\tilde{p}$ 才能得到一个合法的概率分布： 5 | 6 | \begin{equation} \label{eq:pyth} 7 | p(\mathbf{x};\pmb{\theta}) = \frac{1}{Z(\pmb{\theta})} \tilde{p}(\mathbf{x}; \pmb{\theta}). 8 | \end{equation} 9 | 10 | 配分函数对连续型变量是积分，而对离散型变量是对所有状态的非正规化概率进行求和： 11 | 12 | \begin{equation} \label{eq:pyth} 13 | \int \!\tilde{p}(\pmb{x})\, \mathrm{d}\pmb{x} 14 | \end{equation} 15 | 16 | 或者 17 | 18 | \begin{equation} \label{eq:pyth} 19 | \sum_{x} \tilde{p}(\pmb{x}). 20 | \end{equation} 21 | 22 | 这个操作对很多有趣的模型都是难解的. 23 | 24 | 如我们将在第 20 章中看到的，有些深度学习模型被设计成有可解的正规化常量，或者被设计成不需要包含计算 $p(\mathbf{x})$ 的. 然而，其他的模型需要直接面对难解的配分函数的挑战. 本章，我们会给出一些用来训练和评估那些有着难解配分函数的模型的技术. 25 | 26 | \section{对数似然梯度 log-likelihood gradient} 27 | \label{sec:llg} 28 | 29 | 让通过最大似然估计在学习无向的模型中尤其困难的原因是配分函数依赖于参数. 对数似然函数关于参数的梯度包含一个配分函数的梯度项： 30 | 31 | \begin{equation} \label{eq:pyth} 32 | \nabla_{\pmb{\theta}} \log p(\mathbf{x};\pmb{\theta}) = \nabla_{\pmb{\theta}} \log \tilde{p}(\mathbf{x};\pmb{\theta}) - \nabla_{\pmb{\theta}} \log Z(\pmb{\theta}) 33 | \end{equation} 34 | 35 | 这是一个著名的分解——将学习分成正负两个部分.\\ 36 | 37 | 对大多数有趣的无向图模型，负部（negative phase）是困难的. 没有隐含变量或者隐含变量间的交互很少的模型通常会有可解的正部（positive phase） 典型的包含一个直接简单的正部而非常困难的负部的模型是 RBM，它的隐含单元在给定可见单元的时候是彼此是条件独立的. 而正部困难的例子是，隐含元之间的交互特别复杂，这个在第 19 章会讲述. 本章聚焦在负部的难解性上.\\ 38 | 39 | 让我们仔细看看 $\log Z$ 的梯度： 40 | 41 | \begin{equation} \label{eq:pyth} 42 | \frac{\partial}{\partial \pmb{\theta}} \log Z 43 | \end{equation} 44 | \begin{equation} \label{eq:pyth} 45 | =\frac{\frac{\partial}{\partial \pmb{\theta}} Z}{Z} 46 | \end{equation} 47 | \begin{equation} \label{eq:pyth} 48 | =\frac{\frac{\partial}{\partial \pmb{\theta}} \sum_{\mathbf{x}} \tilde{p}(\mathbf{x})}{Z} 49 | \end{equation} 50 | \begin{equation} \label{eq:pyth} 51 | =\frac{\sum_{\mathbf{x} \frac{\partial}{\partial \pmb{\theta}}} \tilde{p}(\mathbf{x})}{Z} 52 | \end{equation} 53 | 54 | 对于那些对所有的 $\mathbf{x}$ 保证 $p(\mathbf{x}) > 0$ 的模型，我们可以为 $\tilde{p}(\mathbf{x})$ 替换 $\exp(\log \tilde{p}(\mathbf{x})$： 55 | \begin{equation} \label{eq:pyth} 56 | \frac{\sum_{\mathbf{x}} \frac{\partial}{\partial \pmb{\theta}} \exp(\log \tilde{p}(\mathbf{x}))}{Z} 57 | \end{equation} 58 | \begin{equation} \label{eq:pyth} 59 | =\frac{\sum_{\mathbf{x}} \exp(\log\tilde{p}(\mathbf{x})) \frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})}{Z} 60 | \end{equation} 61 | \begin{equation} \label{eq:pyth} 62 | =\frac{\sum_{\mathbf{x}} \tilde{p}(\mathbf{x}) \frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})}{Z} 63 | \end{equation} 64 | \begin{equation} \label{eq:pyth} 65 | =\sum_{x}p(\mathbf{x}) \frac{\partial}{\partial \pmb{\theta}} \log \tilde{p}(\mathbf{x}) 66 | \end{equation} 67 | \begin{equation} \label{eq:pyth} 68 | =\mathbf{E}_{x\sim p(\mathbf{x})} \frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x}). 69 | \end{equation} 70 | 71 | 这个推导对离散的 $\pmb{x}$ 进行求和，类似地也可以对连续的 $\pmb{x}$ 进行积分. 在连续版本的推到中，我们使用 Leibniz 法则在积分符号下进行微分，获得等式： 72 | \begin{equation} \label{eq:pyth} 73 | \frac{\partial}{\partial \pmb{\theta}} \int \!\tilde{p}(\mathbf{x}) \, \mathrm{d}\pmb{x} = \int \!\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\pmb{x}) \,\mathrm{d}\pmb{x}. 74 | \end{equation} 75 | 76 | 等式只有在 $\tilde{p}$ 和 $\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})$ 满足某种规范化条件时可用. 用测度论的术语，条件是： 77 | \begin{enumerate*}[label={\roman*)}] 78 | \item $\tilde{p}$ 必须是一个对每个 $\pmb{\theta}$ 值的 $\pmb{x}$ 的 Lebesgue-可积函数； 79 | \item $\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})$ 必须对所有的 $\pmb{\theta}$ 和几乎所有的 $\pmb{x}$ 存在 80 | \item 必须存在一个可积分函数 $R(\pmb{x})$ 控制住 $\frac{\partial}{\partial \pmb{\theta}} \tilde{p}(\mathbf{x})$（如对所有的 $\pmb{\theta}$ 和几乎所有的 $\pmb{x}$ 有 $|\frac{\partial}{\partial \pmb{\theta}}\tilde{p}(\mathbf{x})|\leq R(\pmb{x})$）. 81 | \end{enumerate*} 82 | 83 | 幸运的是，大多数机器学习模型满足这些条件.\\ 84 | 85 | 这个等式 86 | \begin{equation} \label{eq:pyth15} 87 | \nabla_{\pmb{\theta}} \log Z = \mathbb{E}_{\mathbf{x}\sim p(\mathbf{x})} \nabla_{\pmb{\theta}} \log \tilde{p}(\mathbf{x}) 88 | \end{equation} 89 | 是一系列 Monte Carlo 方法的基础，可以用来近似最大化那些有着难解的配分函数的模型的似然函数.\\ 90 | 91 | 学习无向模型的 Monte Carlo 方法给出了一个直觉框架，我们可以利用这样的框架来思考正部和负部. 在正部中，我们对那些从数据抽取的 $\pmb{x}$ 增加 $\log \tilde{p}(\mathbf{x})$. 在负部中，我们通过减少从模型分布中个采样的 $\log \tilde{p}(\mathbf{x})$ 来降低配分函数.\\ 92 | 93 | 在深度学习文献中，通常会用能量函数参数化 $\log \tilde{p}$（Eq. 16.7）. 在这种情况下，我们可以将正部解释为降低训练样本的能量，而负部则是提升从模型中采样的样本的能量，如图 18.1 所示. 94 | 95 | \section{随机最大似然和对比散度} 96 | 97 | 实现 \eqref{eq:pyth15} 的基本方式是每次需要计算梯度时从一个随机初始化状态的 Markov 链的集合中进行老化（burning）. 在使用随机梯度下降算法进行学习时，这个 Markov 链必须每个梯度步都已经老化. 这个想法就是算法~\ref{alg:mcmc} 98 | 中的训练过程. 内循环中的 Markov 链老化的计算代价让这个过程在计算上不可行，但是这个过程本身是其他实效的近似算法的起点. 99 | 100 | % \begin{algorithm}[H] 101 | % 设置 $\epsilon$，一个很小的正数作为步长. 102 | % 设置 $\k$，Gibbs 步数，足够长满足老化条件. 在一个小的图像块（image patch）上训练 RBM 可能需要 $100$. 103 | 104 | 105 | % \caption{用来最大化对数似然函数的 MCMC 算法，使用梯度下降来处理难解的配分函数} 106 | % \label{alg:algorithm1} 107 | % \end{algorithm} 108 | 109 | \begin{algorithm} 110 | \begin{algorithmic} 111 | \caption{用来最大化对数似然函数的 MCMC 算法，使用梯度下降来处理难解的配分函数} 112 | \label{alg:mcmc} 113 | \STATE 设置 $\epsilon$，一个很小的正数作为步长. 114 | \STATE 设置 $k$，Gibbs 步数，足够长满足老化条件. 在一个小的图像块（image patch）上训练 RBM 可能需要 $100$. 115 | \WHILE{未收敛} 116 | \STATE 从训练集中采样 $m$ 个样本 $\{x^{(1)},\dots,x^{(m)}\}$ 的一个\gls{minibatch}. 117 | \STATE $\mathbf{g} \leftarrow \frac{1}{m}\,\sum_{i = 1}^{m} \nabla_{\pmb{\theta}} \log\tilde{p}(x^{(i)};\pmb{\theta})$. 118 | \STATE 将随机值为对应 $m$ 个样本 $\{\tilde{\mathbf{x}}^{(1)},\dots,\tilde{\mathbf{x}}^{(m)}\}$ 初始化（如，从一个均匀分布或者正态分布，或者也可能是有匹配于模型边缘分布的分布）. 119 | \FOR{$i = 1$ to $k$} 120 | \FOR{$j = 1$ to $m$} 121 | \STATE $\tilde{\mathbf{x}}^{(j)} \leftarrow \mathrm{gibbs\_update}(\tilde{\mathbf{x}}^{(j)})$ 122 | \ENDFOR 123 | \ENDFOR 124 | \STATE $\mathbf{g} \leftarrow \frac{1}{m}\,\sum_{i = 1}^{m} \nabla_{\pmb{\theta}} \log\tilde{p}(x^{(i)};\pmb{\theta})$. 125 | \STATE $\pmb{\theta} \leftarrow \pmb{\theta} + \epsilon \mathbf{g}$. 126 | \ENDWHILE 127 | 128 | \end{algorithmic} 129 | \end{algorithm} 130 | 131 | 我们可以将最大似然 MCMC 方法看成是尝试达到两个力量的平衡，一个力量在数据出现时将模型分布上推，而另一个则在模型的样本出现时下推模型分布. 132 | 图~\ref{fig:18.1} 133 | 134 | % \begin{figure} 135 | % \centering 136 | % \includegraphics[width=1.0\textwidth]{figure18-1} 137 | % \caption{算法~\ref{alg:mcmc} 的正部和负部. 左图，在正部中，我们从数据分布中采样，上推他们的未规范化概率. 可能在数据中的点被更多地上推. 右图，在负部中，我们从模型的概率分布采样，下推他们的未规范化概率. 这样会抵制正部的倾向于在每个处都给未规范化概率加上一个大的常量. 当数据分布和模型分布等同时，正部和负部分别有同样的机会上推和下推. 这种情形出现时，就不再回产生梯度（期望形式），训练必须终止.} 138 | % \label{fig:18.1} 139 | % \end{figure} 140 | 141 | \begin{figure}[htp] 142 | \centering \includegraphics[width=1.0\textwidth]{figure18-1} 143 | \caption{算法~\ref{alg:mcmc} 的正部和负部. 左图，在正部中，我们从数据分布中采样，上推他们的未规范化概率. 可能在数据中的点被更多地上推. 右图，在负部中，我们从模型的概率分布采样，下推他们的未规范化概率. 这样会抵制正部的倾向于在每个处都给未规范化概率加上一个大的常量. 当数据分布和模型分布等同时，正部和负部分别有同样的机会上推和下推. 这种情形出现时，就不再回产生梯度（期望形式），训练必须终止.} 144 | \label{fig:18.1} 145 | \end{figure} 146 | 147 | 148 | 149 | -------------------------------------------------------------------------------- /contents/prob.tex: -------------------------------------------------------------------------------- 1 | \chapter{概率论和信息论} 2 | \label{ch:prob} 3 | -------------------------------------------------------------------------------- /contents/regularization.tex: -------------------------------------------------------------------------------- 1 | \chapter{深度学习的规范化技术} 2 | \label{ch:regularization} 3 | -------------------------------------------------------------------------------- /contents/representation.tex: -------------------------------------------------------------------------------- 1 | \chapter{表示学习} 2 | \label{ch:representation} 3 | -------------------------------------------------------------------------------- /contents/rnn.tex: -------------------------------------------------------------------------------- 1 | \chapter{序列建模：循环和递归网络} 2 | \label{ch:rnn} 3 | -------------------------------------------------------------------------------- /contents/title.tex: -------------------------------------------------------------------------------- 1 | % file: title.tex 2 | 3 | \begin{titlepage} 4 | \begin{center} 5 | \hfill\\ 6 | \vspace{1cm} 7 | % title of this document 8 | {\fontsize{36pt}{40pt}\NotoSansSCBold{} 深度学习}\\ 9 | \vspace{1em} 10 | {\LARGE\serif \href{http://www.deeplearningbook.org/}{Deep Learning}}\\ 11 | \vspace{1cm} 12 | %\includegraphics{cayley}\\ 13 | \vspace{1cm} 14 | 15 | {\large\serif 16 | \begin{tabular}{c} 17 | Ian Goodfellow \\ 18 | Yoshua Bengio \\ 19 | Aaron Courville 20 | \end{tabular} 21 | } 22 | 23 | \vfill 24 | {\large \today}\\ 25 | \vspace{1em} 26 | {\large Draft} 27 | \end{center} 28 | \end{titlepage} 29 | -------------------------------------------------------------------------------- /dlbook.tex: -------------------------------------------------------------------------------- 1 | %!TEX TS-program = xelatex 2 | %!TEX encoding = UTF-8 Unicode 3 | 4 | \documentclass[11pt,a4paper,oneside]{book} 5 | \usepackage[margin=2.5cm]{geometry} 6 | 7 | % ------------------------------------------------------------------------------ 8 | % customize the headers with fancyhdr package 9 | % ------------------------------------------------------------------------------ 10 | \usepackage{fancyhdr} 11 | \fancyhf{} 12 | \fancyhead[LE]{\leftmark} 13 | \fancyhead[RO]{\nouppercase{\rightmark}} 14 | \fancyfoot[LE,RO]{\thepage} 15 | \pagestyle{fancy} 16 | 17 | % ------------------------------------------------------------------------------ 18 | % Index 19 | % ------------------------------------------------------------------------------ 20 | \usepackage{makeidx} 21 | \makeindex 22 | 23 | % ------------------------------------------------------------------------------ 24 | % Hyperlinks 25 | % ------------------------------------------------------------------------------ 26 | \usepackage[colorlinks=true,linkcolor=blue]{hyperref} 27 | \usepackage[all]{hypcap} % Be sure to call this package after loading hyperref. 28 | 29 | % ------------------------------------------------------------------------------ 30 | % Glossaries, must be after hyperref 31 | % ------------------------------------------------------------------------------ 32 | \usepackage[xindy,toc]{glossaries} 33 | \makeglossaries{} 34 | 35 | % ------------------------------------------------------------------------------ 36 | % load tocbibind to add contents,list of figures, list of tables and 37 | % bibliography into the toc 38 | % ------------------------------------------------------------------------------ 39 | % \usepackage[utf8]{inputenc} 40 | % \usepackage[english]{babel} 41 | \usepackage[ 42 | backend=bibtex, 43 | natbib, 44 | style=authoryear, 45 | citestyle=authoryear, 46 | maxbibnames=99, 47 | maxcitenames=1 48 | ]{biblatex} 49 | \addbibresource{dlbook-complete.bib} 50 | 51 | % make the 'et al.' italic 52 | \DefineBibliographyStrings{english}{% 53 | andothers = {\it et\addabbrvspace al\adddot} 54 | } 55 | 56 | % A workaround to fix a known bug in biblatex, see http://tex.stackexchange.com/questions/311426/bibliography-error-use-of-blxbblverbaddi-doesnt-match-its-definition-ve 57 | \makeatletter 58 | \def\blx@maxline{77} 59 | \makeatother 60 | 61 | % \usepackage{natbib} 62 | \usepackage{tocbibind} 63 | 64 | % ------------------------------------------------------------------------------ 65 | % Needed to level up the bibliography in the toc 66 | % ------------------------------------------------------------------------------ 67 | \usepackage{bookmark} 68 | 69 | \usepackage[figurename=图.]{caption} 70 | 71 | % ------------------------------------------------------------------------------ 72 | % Needed to load images 73 | % ------------------------------------------------------------------------------ 74 | \usepackage{graphicx} 75 | \graphicspath{{./figures/}} % where to look for images 76 | 77 | % ------------------------------------------------------------------------------ 78 | % for long and nice table 79 | % ------------------------------------------------------------------------------ 80 | \usepackage{longtable} 81 | \usepackage{booktabs} 82 | \usepackage{ltxtable} 83 | 84 | % for compact item list 85 | \usepackage{paralist} 86 | % \usepackage{enumitem} 87 | \usepackage[inline]{enumitem} 88 | % for algorithm 89 | \usepackage[chapter]{algorithm} 90 | \usepackage{algorithmic} 91 | % \usepackage{algpseudocode} 92 | 93 | % \renewcommand{\thealgorithm}{\arabic{chapter}.\arabic{algorithm}} 94 | 95 | % ------------------------------------------------------------------------------ 96 | % Math - Warning: before cjkfonts (xeCJK) and other package loads fontspec 97 | % ------------------------------------------------------------------------------ 98 | \usepackage{amsmath} 99 | \usepackage{amsfonts} 100 | \usepackage{amssymb} 101 | \numberwithin{equation}{chapter} 102 | 103 | % font selection for mathematics with XeLaTeX, MUST after amsfonts 104 | \usepackage{mathspec} 105 | % \setmathsfont(Digits,Latin,Greek)[Numbers={Lining,Proportional}]{Minion Pro} 106 | 107 | % There's no italic sans-serif math font by default, but it's needed in this book 108 | % follow: http://tex.stackexchange.com/questions/77640/bold-italic-and-sans-serif-math-symbols 109 | % to define a \mathsfit{} macro 110 | \DeclareMathAlphabet{\mathsfit}{\encodingdefault}{\sfdefault}{m}{sl} 111 | \SetMathAlphabet{\mathsfit}{bold}{\encodingdefault}{\sfdefault}{bx}{sl} 112 | 113 | % ------------------------------------------------------------------------------ 114 | % Tikz 115 | % ------------------------------------------------------------------------------ 116 | 117 | \usepackage{tikz} 118 | \usetikzlibrary{calc,positioning,arrows.meta,shapes.geometric,shapes.misc } 119 | 120 | % ------------------------------------------------------------------------------ 121 | % Localization setting 122 | % ------------------------------------------------------------------------------ 123 | 124 | % load cjkfonts package and set Noto Sans SC as the default CJK fonts: 125 | \usepackage[default,mdseries=Light,bfseries=Medium]{cjkfonts} 126 | 127 | \usepackage{titlesec} 128 | 129 | \titleformat{\part}[display] 130 | {\centering\bfseries\Huge}% 131 | {\Huge 第 \thepart{} 部分}% 132 | {12 pt}% 133 | {\bfseries\Huge}% 134 | 135 | \titleformat{\chapter}[display] 136 | {\bfseries\huge}% 137 | {\huge 第 \thechapter{} 章}% 138 | {10 pt}% 139 | {\bfseries\huge}% 140 | 141 | \renewcommand{\contentsname}{目录} 142 | \renewcommand{\indexname}{索引} 143 | \renewcommand{\figurename}{图} 144 | \renewcommand{\tablename}{表} 145 | 146 | % Redefine \emph to be both bold and italic, better in chinese document 147 | %\let\emph\relax 148 | %\DeclareTextFontCommand{\emph}{\bfseries\em} % bold and italic 149 | %\DeclareTextFontCommand{\emph}{\bfseries} % just bold 150 | 151 | \usepackage{indentfirst} 152 | 153 | % ------------------------------------------------------------------------------ 154 | % Western fonts setting 155 | % ------------------------------------------------------------------------------ 156 | 157 | % Set Roboto and Source Code Pro, which are installed with TexLive, for western 158 | % fonts: 159 | 160 | % \usepackage[no-math]{fontspec} 161 | 162 | \newcommand{\robotodir}[0]{fonts/} 163 | \newcommand{\sourcecodeprodir}[0]{fonts/} 164 | \newcommand{\sourceserifprodir}[0]{fonts/} 165 | 166 | \newcommand{\robotomd}[0]{Light} 167 | \newcommand{\robotobf}[0]{Medium} 168 | \newcommand{\robotoit}[0]{LightItalic} 169 | \newcommand{\robotobi}[0]{MediumItalic} 170 | \newcommand{\codepromd}[0]{Light} 171 | \newcommand{\codeprobf}[0]{Medium} 172 | \newcommand{\codeproit}[0]{LightIt} 173 | \newcommand{\codeprobi}[0]{MediumIt} 174 | \newcommand{\serifpromd}[0]{Light} 175 | \newcommand{\serifprobf}[0]{Semibold} 176 | 177 | \newfontfamily\Roboto{Roboto}[ 178 | Extension=.ttf, 179 | Path=\robotodir, 180 | UprightFont=*-Regular, 181 | BoldFont=*-Bold, 182 | ItalicFont=*-Italic, 183 | BoldItalicFont=*-BoldItalic] 184 | 185 | \newfontfamily\SourceCodePro{SourceCodePro}[ 186 | Extension=.otf, 187 | Path=\sourcecodeprodir, 188 | UprightFont=*-\codepromd, 189 | BoldFont=*-\codeprobf, 190 | ItalicFont=*-\codeproit, 191 | BoldItalicFont=*-\codeprobi] 192 | 193 | \newfontfamily\SourceSerifPro{SourceSerifPro}[ 194 | Extension=.otf, 195 | Path=\sourceserifprodir, 196 | UprightFont=*-\serifpromd, 197 | BoldFont=*-\serifprobf] 198 | 199 | \newcommand{\serif}[0]{\SourceSerifPro} 200 | 201 | \newfontfamily\RobotoThin{Roboto}[ 202 | Extension=.ttf, 203 | Path=\robotodir, 204 | UprightFont=*-Thin, 205 | ItalicFont=*-ThinItalic] 206 | 207 | \newfontfamily\RobotoLight{Roboto}[ 208 | Extension=.ttf, 209 | Path=\robotodir, 210 | UprightFont=*-Light, 211 | ItalicFont=*-LightItalic] 212 | 213 | \newfontfamily\RobotoRegular{Roboto}[ 214 | Extension=.ttf, 215 | Path=\robotodir, 216 | UprightFont=*-Regular, 217 | ItalicFont=*-Italic] 218 | 219 | \newfontfamily\RobotoMedium{Roboto}[ 220 | Extension=.ttf, 221 | Path=\robotodir, 222 | UprightFont=*-Medium, 223 | ItalicFont=*-MediumItalic] 224 | 225 | \newfontfamily\RobotoBold{Roboto}[ 226 | Extension=.ttf, 227 | Path=\robotodir, 228 | UprightFont=*-Bold, 229 | ItalicFont=*-BoldItalic] 230 | 231 | \newfontfamily\RobotoBlack{Roboto}[ 232 | Extension=.ttf, 233 | Path=\robotodir, 234 | UprightFont=*-Black, 235 | ItalicFont=*-BlackItalic] 236 | 237 | \setmainfont{Roboto}[ 238 | Extension=.ttf, 239 | Path=\robotodir, 240 | UprightFont=*-\robotomd, 241 | BoldFont=*-\robotobf, 242 | ItalicFont=*-\robotoit, 243 | BoldItalicFont=*-\robotobi] 244 | 245 | \setsansfont{Roboto}[ 246 | Extension=.ttf, 247 | Path=\robotodir, 248 | UprightFont=*-\robotomd, 249 | BoldFont=*-\robotobf, 250 | ItalicFont=*-\robotoit, 251 | BoldItalicFont=*-\robotobi] 252 | 253 | \setmonofont{SourceCodePro}[ 254 | Extension=.otf, 255 | Path=\sourcecodeprodir, 256 | UprightFont=*-\codepromd, 257 | BoldFont=*-\codeprobf, 258 | ItalicFont=*-\codeproit, 259 | BoldItalicFont=*-\codeprobi] 260 | 261 | % ------------------------------------------------------------------------------ 262 | % Line space 263 | % ------------------------------------------------------------------------------ 264 | \usepackage{setspace} 265 | \onehalfspacing{} 266 | 267 | % ------------------------------------------------------------------------------ 268 | % Load glossaries 269 | % ------------------------------------------------------------------------------ 270 | \input{contents/glossaries} 271 | 272 | % ------------------------------------------------------------------------------ 273 | % The document body 274 | % ------------------------------------------------------------------------------ 275 | 276 | \begin{document} 277 | 278 | \input{contents/title} 279 | 280 | \frontmatter 281 | 282 | %\maketitle 283 | 284 | \tableofcontents 285 | %\listoffigures 286 | %\listoftables 287 | 288 | \pagebreak 289 | 290 | \input{contents/acknowledgements} 291 | \input{contents/notation} 292 | 293 | \mainmatter{} 294 | 295 | \input{contents/intro} 296 | \input{contents/part_basics} 297 | \input{contents/linear_algebra} 298 | \input{contents/prob} 299 | \input{contents/numerical} 300 | \input{contents/ml} 301 | \input{contents/part_practical} 302 | \input{contents/mlp} 303 | \input{contents/regularization} 304 | \input{contents/optimization} 305 | \input{contents/convnets} 306 | \input{contents/rnn} 307 | \input{contents/guidelines} 308 | \input{contents/applications} 309 | \input{contents/part_research} 310 | \input{contents/linear_factors} 311 | \input{contents/autoencoders} 312 | \input{contents/representation} 313 | \input{contents/graphical_models} 314 | \input{contents/monte_carlo} 315 | \input{contents/partition} 316 | \input{contents/inference} 317 | \input{contents/generative_models} 318 | 319 | % \appendix 320 | % appendix chapters here 321 | 322 | \backmatter{} 323 | 324 | \bookmarksetup{startatroot} 325 | 326 | \printbibliography[ 327 | heading=bibintoc, 328 | title={参考文献} 329 | ] 330 | \printindex 331 | \printglossary[title={术语表}] 332 | 333 | \end{document} 334 | -------------------------------------------------------------------------------- /figures/approximate_minimization.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/approximate_minimization.pdf -------------------------------------------------------------------------------- /figures/computational_graphs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/computational_graphs.pdf -------------------------------------------------------------------------------- /figures/critical_points.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/critical_points.pdf -------------------------------------------------------------------------------- /figures/curvature_in_hessian.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/curvature_in_hessian.pdf -------------------------------------------------------------------------------- /figures/different_ai_disciplines.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/different_ai_disciplines.pdf -------------------------------------------------------------------------------- /figures/different_representations.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/different_representations.pdf -------------------------------------------------------------------------------- /figures/eigen_effect.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/eigen_effect.pdf -------------------------------------------------------------------------------- /figures/figure-18.1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/figure-18.1.jpg -------------------------------------------------------------------------------- /figures/figure18-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/figure18-1.png -------------------------------------------------------------------------------- /figures/gradient_descent.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/gradient_descent.pdf -------------------------------------------------------------------------------- /figures/identity_matrix.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/identity_matrix.pdf -------------------------------------------------------------------------------- /figures/illustration_of_a_deep_learning_model.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/illustration_of_a_deep_learning_model.pdf -------------------------------------------------------------------------------- /figures/saddle_point.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/saddle_point.pdf -------------------------------------------------------------------------------- /figures/second_derivative.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/second_derivative.pdf -------------------------------------------------------------------------------- /figures/transpose_of_matrix.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/transpose_of_matrix.pdf -------------------------------------------------------------------------------- /figures/venn_diagram.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tigerneil/dlbook-zh-cn/23c279d57ea0617da87f786805c37402ef93a303/figures/venn_diagram.pdf --------------------------------------------------------------------------------