index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Chanrom - Logging life</title>
    <link>http://chanrom.github.io/</link>
    <description>Recent content on Chanrom - Logging life</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Sun, 20 Aug 2017 21:38:52 +0800</lastBuildDate>
    
        <atom:link href="http://chanrom.github.io/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>About</title>
      <link>http://chanrom.github.io/about/</link>
      <pubDate>Sun, 20 Aug 2017 21:38:52 +0800</pubDate>
      
      <guid>http://chanrom.github.io/about/</guid>
      
        <description>&lt;p&gt;Hugo is a static site engine written in Go.&lt;/p&gt;

&lt;p&gt;It makes use of a variety of open source projects including:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/spf13/cobra&#34;&gt;Cobra&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/spf13/viper&#34;&gt;Viper&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/spf13/jWalterWeatherman&#34;&gt;J Walter Weatherman&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/spf13/cast&#34;&gt;Cast&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Learn more and contribute on &lt;a href=&#34;https://github.com/gohugoio&#34;&gt;GitHub&lt;/a&gt;.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Emacs</title>
      <link>http://chanrom.github.io/post/mimic/emacs/</link>
      <pubDate>Sun, 19 Aug 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/mimic/emacs/</guid>
      
        <description>

&lt;h1 id=&#34;部分参考如下网站&#34;&gt;部分参考如下网站&lt;/h1&gt;

&lt;p&gt;&lt;a href=&#34;https://www.cnblogs.com/kunyuanjushi/p/5951404.html&#34;&gt;Emacs常用快捷键&lt;/a&gt;&lt;/p&gt;

&lt;h1 id=&#34;基本命令&#34;&gt;基本命令&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt;C-x C-f     打开/新建文件
C-x C-s     保存当前缓冲区
C-x C-w     当前缓冲区另存为
C-x b       切换Buffer
C-x C-b     显示Buffer列表
C-x k       关闭当前Buffer
C-x C-v     关闭当前Buffer并打开新文件
C-x C-c     关闭Emacs
C-c C-z     终止shell中的进程
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;窗口命令&#34;&gt;窗口命令&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt;C-x 2       水平分割窗格
C-x 3       垂直分割窗格
C-x 0      关闭当前窗口
C-x o      切换窗口
C-x 1       关闭其他窗口
C-x 5 2   新建窗口
C-x 5 f    新窗口中打开文件
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;光标移动命令&#34;&gt;光标移动命令&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt;C-x 2       水平分割窗格
C-x 3       垂直分割窗格
C-x 0      关闭当前窗口
C-x o      切换窗口
C-x 1       关闭其他窗口
C-x 5 2   新建窗口
C-x 5 f    新窗口中打开文件
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;编辑命令&#34;&gt;编辑命令&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt;C-v              向前翻页
M-v              向后翻页
M-r              将光标移动到屏幕中间那行
C-a              移到行首
M-a              移到句首，从行首到句首之间可能有空格
C-e              移到行尾
M-e              移到句尾
M-{              向上移动一段
M-}              向下移动一段
C-right              向前移动一个单词
C-left              向后移动一个单词
C-up              向前移动一段
C-down              向后移动一段
M-&amp;lt;              移到整个文本开头
M-&amp;gt;              移到整个文本末尾
M-x goto-line              移动到某一行
C-l              重绘屏幕，效果就是当前编辑行移动窗口中央
C-Space         设置开始标记
C-@                设置开始标记(C-space可能被操作系统拦截)
M-w                复制标记区内容
C-y                  帖粘
M-u                使光标处的单词大写
M-l                 使光标处的单词小写
M-c                使光标处单词首字母大写
C-k                  删除一行
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;搜索-替换命令&#34;&gt;搜索/替换命令&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt;C-s          向下搜索
C-r          向上搜索
M-x replace-string 替换（替换光标之后的内容）
M-x replace-regexp 正则替换（替换光标之后的内容）
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;帮助&#34;&gt;帮助&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt;C-h ?              查看帮助信息
C-h f              查看一个函数
C-h v              查看一个变量
C-h k              查看一个键绑定 (C－h c 也是查看键绑定，但是信息较简略)
C-h C-f              查看一个函数的info，非常有用
C-h i              看Info
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;其他&#34;&gt;其他&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt;C-M-\              对选中区域，按照某种格式(比如C程序)进行格式化
C-x h              全部选中
M-!              执行外部shell命令
M-x shell              模拟shell的buffer
M-x term              模拟terminal, C-c k 关闭terminal
C-x C-q              修改buffer的只读属性
&lt;/code&gt;&lt;/pre&gt;
</description>
      
    </item>
    
    <item>
      <title>NLP一些经典算法</title>
      <link>http://chanrom.github.io/post/nlp/basic/</link>
      <pubDate>Thu, 17 May 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/nlp/basic/</guid>
      
        <description>

&lt;h1 id=&#34;tf-idf&#34;&gt;TF-IDF&lt;/h1&gt;

&lt;h2 id=&#34;简介&#34;&gt;简介&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;TF-IDF&lt;/code&gt;，指的是词频-逆文档频率（&lt;code&gt;Term Frequency-Inverse Document Frequency&lt;/code&gt;），一种用于文档检索的加权计算方法，常用于文档的向量表示。&lt;code&gt;TF-IDF&lt;/code&gt;可表示某个词在当前文档的重要程度，具体地，词的重要性和它在文档中出现的次数成正比，但是和它在整个语料库出现的次数成反比。通俗的说就是，一个词语在一篇文档中出现的次数越多而在所有文档出现的次数越少，就越能代表这个文档。&lt;/p&gt;

&lt;h2 id=&#34;定义&#34;&gt;定义&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;TF-IDF&lt;/code&gt;的定义如下：
$$
TFIDF_{i,j} = \frac{N_{i,j}}{N_{\cdot j}} \log (\frac{D}{D_i})
$$
其中\( N_{i,j} \) 表示词\( i \) 出现在文档\( j \)的次数；&lt;/p&gt;

&lt;p&gt;\( N_{\cdot, j} \) 表示文档\( j \)一共有多少词；&lt;/p&gt;

&lt;p&gt;\( D \) 表示文档的总数；&lt;/p&gt;

&lt;p&gt;\( D_{i} \) 表示有多少文档出现过词\( i \)。&lt;/p&gt;

&lt;p&gt;注意，以上提到的词一般先经过了无用词（&lt;code&gt;stopwords&lt;/code&gt;）的过滤。&lt;/p&gt;

&lt;h1 id=&#34;lsa&#34;&gt;LSA&lt;/h1&gt;

&lt;h2 id=&#34;简介-1&#34;&gt;简介&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;LSA&lt;/code&gt;（潜在语义分析）目的是解决通过搜索词（&lt;code&gt;search words&lt;/code&gt;）定位出相关的文档的问题。&lt;code&gt;LSA&lt;/code&gt;的基本原理是将文档和单词都映射到同一个语义空间（&lt;code&gt;concept space&lt;/code&gt;）中，并在该空间进行对比分析。&lt;/p&gt;

&lt;h2 id=&#34;定义-1&#34;&gt;定义&lt;/h2&gt;

&lt;p&gt;首先需要构建词-文档的矩阵 \(A\)，\(A\) 中的每个元素 \(A_{i j}\) 表示搜索词 \(w_i\) 在文档 \(d_j\) 出现的次数（一般又转换为&lt;code&gt;TF-IDF&lt;/code&gt;并作平滑处理）。&lt;/p&gt;

&lt;p&gt;接着对 \(A\) 做奇异值分解：
$$
A = U S V^T
$$
\(U\) 为一个 \(R^{t \times n}\) 的正交矩阵，每行代表一个词的表示，其含义为该词在语义空间的每个维度上中重要程度；&lt;/p&gt;

&lt;p&gt;\(V\) 为一个 \(R^{d \times n}\) 的正交矩阵，每行代表一个文档的表示，其含义为该文档在语义空间的每个维度上中重要程度；&lt;/p&gt;

&lt;p&gt;\(S\) 为一个 \(R^{n \times n}\) 的奇异矩阵，每个元素刻画了词和文档映射到语义空间后二者的相关度。&lt;/p&gt;

&lt;h2 id=&#34;优缺点&#34;&gt;优缺点&lt;/h2&gt;

&lt;p&gt;优点：&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;低维的向量表示可以缓解多词一义的情况（一词多义应该也可以有一点的作用，只是很有限）&lt;/li&gt;
&lt;li&gt;降维可以去除部分噪音，特征的表示更加鲁棒&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;缺点：&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;貌似因为一个词就是一个表示，不能很好的处理一词多义的情况&lt;/li&gt;
&lt;li&gt;SVD分解的复杂度很高&lt;/li&gt;
&lt;li&gt;物理解释偏弱&lt;/li&gt;
&lt;/ul&gt;

&lt;h1 id=&#34;plsa&#34;&gt;pLSA&lt;/h1&gt;

&lt;h2 id=&#34;介绍&#34;&gt;介绍&lt;/h2&gt;

&lt;p&gt;pLSA是在LSA的基础上提出的，一般就可以称之为主题模型。pLSA在模型中引入了一个隐变量：主题变量z，进一步刻画了文档生成的过程。在介绍pLSA之前，先定义基本的符号：&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;\( w \) 表示词，\( V\) 表示所有单词的个数，也就是词表大小（在语料库中统计，固定值）&lt;/li&gt;
&lt;li&gt;\( z\) 表示主题，\( K\) 代表主题的个数（预先设定，固定值）&lt;/li&gt;
&lt;li&gt;\( D = (d_1, d_2, &amp;hellip;, d_M)\)，其中 \( M\) 代表语料库中文档数目&lt;/li&gt;
&lt;li&gt;\( d = (w_1, w_2, &amp;hellip;, w_N)\)，其中 \( N\) 代表该文档内的词的数目&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;pLSA定义了语料库的生成过程（如图所示）：&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;对于每一篇文档 \( d \)

&lt;ul&gt;
&lt;li&gt;对于该文档的每个位置&lt;/li&gt;
&lt;li&gt;选择一个主题 \( z \)&lt;/li&gt;
&lt;li&gt;根据主题选择词 \( w\)&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p align=&#34;center&#34;&gt; 
&lt;img src=&#34;http://chanrom.github.io/pLSA.jpeg&#34;&gt;
&lt;/p&gt;

&lt;h2 id=&#34;定义-2&#34;&gt;定义&lt;/h2&gt;

&lt;p&gt;在形式化定义如上的生成过程之前，我们先定义一些变量：&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;\( p(d_i) \) 表示语料库中某篇文档被选中的概率&lt;/li&gt;
&lt;li&gt;\( p(w_j | d_i)\) 表示给定文档 \( d_i\) 时，词 \( w_j\) 出现的概率&lt;/li&gt;
&lt;li&gt;\( p(z_k | d_i)\) 表示给定文档 \( d_i\) 时，主题 \( z_k\) 出现的概率&lt;/li&gt;
&lt;li&gt;\( p(w_j | z_k)\) 表示主题 \( z_k\) 时，词 \( w_j\) 出现的概率&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;重写以上的生成过程：&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;按照概率 \( p(d) \) 选择一篇文档 \( d_i \) （一般计为等概率的）&lt;/li&gt;
&lt;li&gt;按照文档-主题分布 \( p(z | d_i)\) 选择某个主题 \( z_k \)&lt;/li&gt;
&lt;li&gt;按照主题-词分布 \( p(w | z_k)\) 选择某个词 \( w_j \)&lt;/li&gt;
&lt;li&gt;根据 \( M \) 和 \( N \) 重复以上过程&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&#34;求解&#34;&gt;求解&lt;/h2&gt;

&lt;p&gt;上一小节我们描述了pLSA的生成过程。通常来说我们拿到的仅仅只有语料库，我们更希望获得的是模型潜在的主题信息，这样就可以使用主题信息去刻画文本和词的关系。由以上公式的定义可知，\( p(w_j | d_i)\) 是已知的（参看TF-IDF的计算方法），我们可以根据大量的已知的文档-词的信息推出文档-主题以及主题-词的信息：&lt;/p&gt;

&lt;p&gt;$$
p(w_j| d_i) = \sum_{k=1}^K p(w_j|z_k) p(z_k|d_i)
$$&lt;/p&gt;

&lt;p&gt;因此某文档中某个词的生成概率为:&lt;/p&gt;

&lt;p&gt;$$
p(w_j, d_i) = p(d_i) p(w_j| d_i)&lt;br /&gt;
 = p(d_i) \sum_{k=1}^K p(w_j|z_k) p(z_k|d_i)
$$
\(p(d_i)\)可以事先计算出来，而 \( p(w_j|z_k)\) 和 \( p(z_k|d_i)\) 是未知的。因此为了得到主题的信息，必须估计 \( p(w_j|z_k)\) 和 \( p(z_k|d_i)\) 的参数。因为模型含有隐变量，考虑使用EM算法。&lt;/p&gt;

&lt;h2 id=&#34;em参数估计&#34;&gt;EM参数估计&lt;/h2&gt;

&lt;p&gt;在介绍EM参数估计之前，我们先列出模型的参数并一一解释。&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;假定 \( p(w_j|z_k)\) 服从多项式分布，该分布的参数 \( \phi_k \) 表示的是主题 \( z_k \) 在词表（一共\( V \) 个词）上面的一个“分布”，即每个词 \( w_j \) 在该参数里都对应一个元素 \( \phi_{k, j} \)，代表了 \( w_j \) 出现在主题 \( z_k \) 上的概率：&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;$$
 p(w_j|z_k)= \phi_{k, j} ，\sum_{j = 1}^V \phi_{k, j} = 1
$$&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;假定 \( p(z_k|d_i)\) 服从多项式分布，该分布的参数 \( \theta_i \) 表示的是文本 \( d_i \) 在主题（一共 \( K \) 个主题上面的一个“分布”，即每个主题 \( z_k \) 在该参数里都对应一个元素 \( \theta_{i, k} \)，代表了主题 \( z_k \) 出现在文档 \( d_i \) 上的概率：&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;$$
 p(z_k|d_i)= \theta_{i, k} ，\sum_{k = 1}^K \theta_{i, k} = 1
$$&lt;/p&gt;

&lt;p&gt;因此我们要最终求解的两个参数矩阵：&lt;/p&gt;

&lt;p&gt;$$
\Phi = [\phi_1, &amp;hellip;, \phi_K]
$$&lt;/p&gt;

&lt;p&gt;$$
\Theta = [\theta_1, .., \theta_M]
$$&lt;/p&gt;

&lt;p&gt;由于词和词的生成是独立的，文档和文档的生成也是独立的，因此整个语料库的生成词的概率为：&lt;/p&gt;

&lt;p&gt;$$
p(W | D) = \prod_{i=1}^M \prod_{j=1}^N p(w_j, d_i) ^{n(d_i, w_j)}
$$
其中，\( {n(d_i, w_j)} \) 表示词 \( w_j \) 在文档 \( d_i \) 出现的次数。于是我们可以得到对数似然函数：&lt;/p&gt;

&lt;p&gt;$$
l(\Phi, \Theta) = \sum_{i=1}^M \sum_{j=1}^n n(d_i, w_j) \log p(w_j, d_i)
$$
$$
~~~~~~~~~~~~~~ = \sum_{i=1}^M \sum_{j=1}^n n(d_i, w_j) \log p(w_j, d_i)
$$&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://blog.csdn.net/pipisorry/article/details/42560693&#34;&gt;继续请参看&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://people.cs.pitt.edu/~milos/courses/cs3750/lectures/class11.pdf&#34;&gt;2&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;http://vdisk.weibo.com/s/bjfcErv7QQc&#34;&gt;3&lt;/a&gt;&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>参数估计</title>
      <link>http://chanrom.github.io/post/nlp/estimation/</link>
      <pubDate>Thu, 17 May 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/nlp/estimation/</guid>
      
        <description>

&lt;h1 id=&#34;参数估计方法&#34;&gt;参数估计方法&lt;/h1&gt;

&lt;h2 id=&#34;极大似然估计&#34;&gt;极大似然估计&lt;/h2&gt;

&lt;h2 id=&#34;最大后验估计&#34;&gt;最大后验估计&lt;/h2&gt;

&lt;h2 id=&#34;贝叶斯估计&#34;&gt;贝叶斯估计&lt;/h2&gt;
</description>
      
    </item>
    
    <item>
      <title>Backtracking</title>
      <link>http://chanrom.github.io/post/leetcode/backtracking/</link>
      <pubDate>Fri, 11 May 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/leetcode/backtracking/</guid>
      
        <description>

&lt;h1 id=&#34;回溯&#34;&gt;回溯&lt;/h1&gt;

&lt;p&gt;看题目看的我头晕，这种嵌套的实在是烧脑子啊。
&lt;a href=&#34;https://leetcode.com/problems/combination-sum/discuss/16502/A-general-approach-to-backtracking-questions-in-Java-Subsets-Permutations-Combination-Sum-Palindrome-Partitioning&#34;&gt;回溯统一解法&lt;/a&gt;)
&lt;a href=&#34;https://segmentfault.com/a/1190000006121957&#34;&gt;回溯全集&lt;/a&gt;&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Batch Normalization</title>
      <link>http://chanrom.github.io/post/dnn/batchnorm/</link>
      <pubDate>Thu, 10 May 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/dnn/batchnorm/</guid>
      
        <description>

&lt;h1 id=&#34;介绍&#34;&gt;介绍&lt;/h1&gt;

&lt;p&gt;&lt;code&gt;Batch Normalization&lt;/code&gt;是很多深层网络会使用的一种训练&lt;code&gt;trick&lt;/code&gt;，这篇博客主要想从谷歌的原始论文和一些大牛的博客出发，重新阐述一下这个训练深层网络的“大杀器”。&lt;/p&gt;

&lt;h1 id=&#34;the-insights&#34;&gt;The Insights&lt;/h1&gt;

&lt;p&gt;我们知道深度学习在图像、语言和文本等领域都取得了很大的进步。在这当中，随机梯度下降（&lt;code&gt;SGD&lt;/code&gt;）作为一种有效的训练深层网络的方法而被很多人所熟知。在&lt;code&gt;SGD&lt;/code&gt;的基础之上的一些改进优化算法，如&lt;code&gt;Adam&lt;/code&gt;、&lt;code&gt;Adagrad&lt;/code&gt;和&lt;code&gt;NAdam&lt;/code&gt;等通常都能将深层网络训练到最佳的性能。&lt;/p&gt;

&lt;p&gt;举个例子，假设我们要使用&lt;code&gt;SGD&lt;/code&gt;来优化一个含有参数 \( \Theta \) 的网络：
$$
\Theta = argmin_{\Theta} \frac{1}{N} \sum_{i=1}^N l(x_i, \Theta),
$$
每个&lt;code&gt;step&lt;/code&gt;使用梯度下降来更新一次 \( \Theta \)，最后得到最优的值。每个&lt;code&gt;step&lt;/code&gt;可以使用整个数据集来计算一次梯度，也可以使用一个样本来计算一次梯度，但这两种方法都有各自的缺点，所以一般使用的是批处理（&lt;code&gt;mini-batch&lt;/code&gt;）随机梯度下降。&lt;strong&gt;其优点在于&lt;/strong&gt;：1) \( m \) 个样本的梯度近似于整个数据集的梯度，相对来说梯度比较稳定，并且随着\( m \) 的增大，这种稳定性更好；2) 相比于利用单个样本去计算梯度，批处理的方式更高效。数学上看，&lt;code&gt;mini-batch&lt;/code&gt;的方式每次使用 \( m \) 个样本计算一次梯度，其梯度为：
$$
\frac{1}{m} \frac{\partial l(x_i, \Theta)}{\partial \Theta}.
$$&lt;/p&gt;

&lt;p&gt;虽然随机梯度下降的方法简单高效，使得训练很深的网络也不在话下，但是想要使得深层网络获得更佳的性能却仍然不是一件容易的事情。实际上，想要深层网络训练的好，模型超参数、学习速率和模型参数的初始化方法的选择都至关重要。这些因素在网络变得更深的时候显得格外重要，因为底层网络参数一丁点的改变都将影响高层网络的输入。&lt;/p&gt;

&lt;p&gt;在领域适应（&lt;code&gt;domain adaptation&lt;/code&gt;）的研究当中，一个本质的问题就是某个学习系统的输入分布不是固定不变的（如训练样本的分布和测试样本的分布不一致会导致分类器的性能降低），这种情况称之为&lt;code&gt;covariate shift&lt;/code&gt;。&lt;code&gt;Covariate shift&lt;/code&gt;导致学习系统需要有额外的能力去适应输入分布的变化。结合之前提到的深层网络的训练问题，如果我们把一个深层网络的每一层全部分开来看，&lt;code&gt;covariate shift&lt;/code&gt;的问题同样存在。假设某个网络有这样一个计算过程：
$$
l = F_2(F_1(u, \Theta_1), \Theta_2),
$$
\( F \) 指任意的函数变换。当我们学习参数\( \Theta_2\) 的时候，可以将 \( F_2 \) 的输入看做是 \( v = F_1(u, \Theta_1) \)：
$$
l = F_2(v, \Theta).
$$
这样，一次梯度下降可以用如下计算方式：
$$
\Theta_2 \leftarrow \Theta_2 - \frac{\alpha}{m} \sum_{i = 1}^m \frac{\partial F_2(v_i, \Theta_2)}{\partial \Theta_2}
$$
所以从上面的角度看待深层网络的训练时我们发现，如果输入 \( v \) 的分布是固定不变的，那么训练含有参数 \(\Theta_2 \) 的高层网络就会变得更加容易，也能训练的更好：在训练的过程中，\(\Theta_2 \) 不需要调整自己去“补偿”因为输入分布变化所带来的不利影响。&lt;/p&gt;

&lt;p&gt;前面我们了解到深度网络某一层的输入保持固定不变的分布形式对该层的训练是非常有利的，实际上输入保持固定不变的分布还能为除该层之外的子网络带来益处。考虑深层网络的某一层使用的是&lt;code&gt;sigmoid&lt;/code&gt;激活函数：
$$
z = g(W v + b),
$$
其中 \( v \) 是该层的输入，其他为参数。\(g \) 是&lt;code&gt;sigmoid&lt;/code&gt;函数。随着 \(|x|\) 的增大，\( g^\prime(x) \) 都是趋近于0的。这就意味着如果\( x = W v + b \) 中某一维度的绝对值如果不能比较小的话，能够传给输入 \( v \) 的梯度就会&lt;code&gt;vanish&lt;/code&gt;，进而训练就会变得很慢。但是呢，因为深层网络层数很多，这往往是不可避免的：在不断训练的过程中，梯度要么很大要么很小，所以到头来 \(x \) 还是慢慢进入到非线性函数的&lt;code&gt;saturated regime&lt;/code&gt;，使得几乎没有梯度能够往底层的网络传播（&lt;code&gt;ReLU&lt;/code&gt;）的设计就是为了缓解非线性激活函数梯度消失的这个问题）。那如果我们使得输入始终稳定为一个较稳定的分布，那么是不是有可能在训练的过程中降低激活函数陷入&lt;code&gt;saturated regime&lt;/code&gt;的可能性，使得训练加快呢？&lt;/p&gt;

&lt;p&gt;基于以上两点&lt;code&gt;insights&lt;/code&gt;，一种可以消除深层网络里&lt;code&gt;Internal Covatiate Shift&lt;/code&gt;的机制被提出，那就是&lt;code&gt;Batch Normalization&lt;/code&gt;。&lt;code&gt;Batch normalization&lt;/code&gt;不仅可以加速网络的训练，而且降低了梯度对量级很小的网络参数以及参数初始化的敏感度。有了&lt;code&gt;Batch normalization&lt;/code&gt;之后，我们可以为网络设定一个更高的学习速率。&lt;/p&gt;

&lt;h1 id=&#34;internal-covariate-shift&#34;&gt;Internal Covariate Shift&lt;/h1&gt;
</description>
      
    </item>
    
    <item>
      <title>Leetcode总结</title>
      <link>http://chanrom.github.io/post/leetcode/leetcode/</link>
      <pubDate>Sat, 28 Apr 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/leetcode/leetcode/</guid>
      
        <description>

&lt;h1 id=&#34;leetcode&#34;&gt;Leetcode&lt;/h1&gt;

&lt;p&gt;一直知道自己的算法能力偏弱，但是却没有时间针对性地练习过相关的能力。趁着自己有想找一份暑期实习的计划下开始刷Leetcode，刚开始时，即使是easy的题目也解的比较费力，在刷到100题的时候，解easy题的速度明显快了很多。但是在面对medium难度的题依然要花很长的时间才可以AC。本着融会贯通、不停进步的思想，我将在这个博客记录、总结一下遇到的题目，以便自己以及有兴趣一起学习的同学参考。&lt;/p&gt;

&lt;p&gt;目前网络上的Leetcode解题思路不计其数，我们可以随手搜到。但是我想只有在自己脑中形成一个知识体系，才可能在所遇到的新问题得到突破。因此这篇博客会尽量地分门别类地总结类似的题目。&lt;/p&gt;

&lt;h1 id=&#34;二叉树的遍历&#34;&gt;二叉树的遍历&lt;/h1&gt;

&lt;p&gt;二叉树的遍历需要熟悉：前序遍历、中序遍历、后序遍历以及层次遍历，包括递归的实现和循环的实现。以下分别给出各个算法的Python实现。&lt;/p&gt;

&lt;h2 id=&#34;前序遍历-递归&#34;&gt;前序遍历-递归&lt;/h2&gt;

&lt;p&gt;递归的实现很简单：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def preorderTraversal(self, root):
        res = []
        def pre(root):
            if not root:
                return 
            res.append(root.val)
            pre(root.left)
            pre(root.right)
        pre(root)
        return res
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;前序遍历-循环&#34;&gt;前序遍历-循环&lt;/h2&gt;

&lt;p&gt;相比递归实现，循环实现具有更高的效率，其实现需要借助栈来实现：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def preorderTraversal(self, root):
        stack = []
        res = []
        while (root or len(stack) != 0): # 注意这个终止条件
            if root:
                res.append(root.val)
                stack.append(root)
                root = root.left
            else:
                root = stack[len(stack) - 1]
                stack.pop()
                root = root.right
        return res
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;中序遍历-递归&#34;&gt;中序遍历-递归&lt;/h2&gt;

&lt;p&gt;基本同上：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def inorderTraversal(self, root):
        res = []
        def pre(root):
            if not root:
                return 
            pre(root.left)
            res.append(root.val)
            pre(root.right)
        pre(root)
        return res
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;中序遍历-循环&#34;&gt;中序遍历-循环&lt;/h2&gt;

&lt;p&gt;中序遍历的循环实现和前序遍历很类似，无非就是（出栈）打印的时机不一样。在代码里的体现就是&lt;code&gt;res.append(root.val)&lt;/code&gt;：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def inorderTraversal(self, root):
        stack = []
        res = []
        while (root or len(stack) != 0): # 注意这个终止条件
            if root:
                stack.append(root)
                root = root.left
            else:
                root = stack[len(stack) - 1]
                res.append(root.val)
                stack.pop()
                root = root.right
        return res
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;后序遍历-递归&#34;&gt;后序遍历-递归&lt;/h2&gt;

&lt;p&gt;递归很简单，直接给出代码：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def postorderTraversal(self, root):
        res = []
        def pre(root):
            if not root:
                return 
            pre(root.left)
            pre(root.right)
            res.append(root.val)
        pre(root)
        return res
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;后序遍历-循环&#34;&gt;后序遍历-循环&lt;/h2&gt;

&lt;p&gt;相比前两个而言，后序遍历会比较复杂一点，因为在后序遍历中，必须最后打印根节点的值，也就是说必须先打印左子树和右子树的值。在具体的实现当中，我们可以使用一个&lt;code&gt;last&lt;/code&gt;指针，表示在上一时刻访问多的节点。当某个节点没有左右子节点或者右子节点已经访问过了（此时左子节点肯定也访问过了），这个节点的值才可以被打印出来。以下代码：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def postorderTraversal(self, root):
        stack = []
        res = []
        last = None
        while (root or len(stack) != 0): # 注意这个终止条件
            while root: # 一直往左下搜索，使节点入栈
                stack.append(root)
                root = root.left
            root = stack[len(stack) - 1] # 开始分析栈内节点
            if (root.right and root.right != last): # 如果当前节点有右子节点并且没被访问过，又要开始对右子树的访问
                root = root.right
            else: # 不是以上情况的时候就可以输出当前根节点了
                res.append(root.val)
                stack.pop()
                last = root # 记录
                root = None # 保证下一次处理栈顶元素
        return res
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;层序遍历-循环&#34;&gt;层序遍历-循环&lt;/h2&gt;

&lt;p&gt;第一种层序遍历要求的打印顺序是：根节点先打印叶子节点最后打印的。思路是每遍历完当前层所有的节点的时候，将当前层内节点拥有的子节点装入列表，以备下一步再开始之前的步骤：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def levelOrder(self, root):
        if not root:
            return []
        ans, level = [], [root]
        while level:
            ans.append([node.val for node in level])
            temp = []
            for node in level:
                temp.extend([node.left, node.right])
            level = [leaf for leaf in temp if leaf]
        return ans
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;层序遍历2-循环&#34;&gt;层序遍历2-循环&lt;/h2&gt;

&lt;p&gt;第一种层序遍历要求的打印顺序是和之前相反，但这个在Python中不是大问题，直接一条命令就可以&lt;code&gt;res[::-1]&lt;/code&gt;&lt;/p&gt;

&lt;h1 id=&#34;字符串翻转&#34;&gt;字符串翻转&lt;/h1&gt;

&lt;p&gt;字符串的翻转涉及到比较多的题目，比如，从最简单的字符串翻转的概念题到涉及回文串的题。总结一下这类题目对“启后”——在将来的面试中解决新的题目——还是很有帮助的。这里介绍几个这样的题目。&lt;/p&gt;

&lt;h2 id=&#34;翻转字符串&#34;&gt;翻转字符串&lt;/h2&gt;

&lt;p&gt;把一个字符串最左侧的若干字符截取下来，保持其顺序，放到原字符串截断后留下的子串前面，这个称之为翻转字符串。举个例子，如果&lt;code&gt;A=&amp;quot;abcde&amp;quot;&lt;/code&gt;，那么&lt;code&gt;B=&amp;quot;deabc&amp;quot;&lt;/code&gt;是&lt;code&gt;A&lt;/code&gt;的一个翻转。如果判断一个字符串是不是另外一字符串的翻转呢？解题的思路就是，如果&lt;code&gt;B&lt;/code&gt;是&lt;code&gt;A&lt;/code&gt;的一个翻转字符串的话，&lt;code&gt;A&lt;/code&gt;必须要在&lt;code&gt;(B + B)[1:-1]&lt;/code&gt;中能找到，去掉最后和最前的字符是为了保证&lt;code&gt;A=&amp;quot;aaaa&amp;quot;&lt;/code&gt;，&lt;code&gt;B=&amp;quot;aa&amp;quot;&lt;/code&gt;的情况是不符合要求的。代码如下：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def rotateString(self, A, B):
        if len(A) == 0 and len(B) == 0:
            return True
        if len(A) == 0:
            return False
        s = (B + B)[1:-1]
        if A not in s:
            return False
        else:
            return True
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;排列组合&#34;&gt;排列组合&lt;/h1&gt;

&lt;p&gt;我这里的排列组合其实指的很宽泛，只要是涉及到计算若干个字符的排列组合、有效排列组合等等都可以归为这一类。把这些题目放到一起，以便总结。&lt;/p&gt;

&lt;h2 id=&#34;括号生成&#34;&gt;括号生成&lt;/h2&gt;

&lt;p&gt;给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。例如，给出 n = 3，生成结果为：&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;[
  &amp;quot;((()))&amp;quot;,
  &amp;quot;(()())&amp;quot;,
  &amp;quot;(())()&amp;quot;,
  &amp;quot;()(())&amp;quot;,
  &amp;quot;()()()&amp;quot;
]
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;我自己想到的方法是通过变换字符串中的&lt;code&gt;)(&lt;/code&gt;这种组合。举例来说，串&lt;code&gt;()()()&lt;/code&gt;的第一个&lt;code&gt;)(&lt;/code&gt;变换成&lt;code&gt;()&lt;/code&gt;则可以变成一个有效的括号串。&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def generateParenthesis(self, N):
        valid_str = set([&#39;()&#39;*n])
        stack = [&#39;()&#39;*n]
        while len(stack) != 0:
            top = stack[len(stack) - 1]
            stack.pop()
            top = [c for c in top]
            for i in xrange(1, len(top) - 1):
                if top[i] == &#39;)&#39; and top[i + 1] == &#39;(&#39;:
                    tmp = top[:]
                    tmp[i], tmp[i + 1] = tmp[i + 1], tmp[i]
                    if &#39;&#39;.join(tmp) not in valid_str:  
                        valid_str.add(&#39;&#39;.join(tmp))
                        stack.append(&#39;&#39;.join(tmp))
        return list(valid_str)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;网上很多解法，通常是利用递归进行广度搜索：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def generateParenthesis(self, N):
        ans = []
        def backtrack(S = &#39;&#39;, left = 0, right = 0):
            if len(S) == 2 * N:
                ans.append(S)
                return
            if left &amp;lt; N:
                backtrack(S+&#39;(&#39;, left+1, right)
            if right &amp;lt; left:
                backtrack(S+&#39;)&#39;, left, right+1)
        backtrack()
        return ans
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;两个指针&#34;&gt;两个指针&lt;/h1&gt;

&lt;p&gt;使用两个指针可以解决不少的问题，特别是有关数组的题目上，这里从易到难介绍几道题目(从二分搜索到复杂一点的二分搜索33，34)。&lt;/p&gt;

&lt;h1 id=&#34;链表问题&#34;&gt;链表问题&lt;/h1&gt;

&lt;p&gt;链表问题好像在面试中考察的不多，但是相关的题目却比较有技巧性，以下简单的做一些分析。&lt;/p&gt;

&lt;h2 id=&#34;两个链表的第一个公共节点&#34;&gt;两个链表的第一个公共节点&lt;/h2&gt;

&lt;p&gt;如果说可以借助其他数据结构的话，这道题目比较好解，比如借助栈来存储两个链表的元素，然后再从栈顶开始一一比对。如果不能借助其他数据结构呢（即空间复杂度为&lt;code&gt;O(1)&lt;/code&gt;）？退一步考虑，如果两个链表有交点，那必要条件是从两个链表的末尾开始就相同，然后再往前的某个地方分开。因此，如果我们“对齐”两个链表的长度，从前往后扫描，如果在结束之前有相同节点，说明找到了第一个交点。&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;  def getIntersectionNode(self, headA, headB):
        if not headA or not headB:
            return None
        
        def count(p):
            m = 0
            while p:
                m += 1
                p = p.next
            return m

        ma = count(headA)
        mb = count(headB)
        
        if ma &amp;lt; mb:
            ma, mb = mb, ma
            headA, headB = headB, headA

        n = ma - mb
        while n &amp;gt; 0:
            headA = headA.next
            n = n - 1
        while mb &amp;gt; 0:
            if headA == headB:
                return headA
            mb -= 1
            headA = headA.next
            headB = headB.next
        return None
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;反转链表&#34;&gt;反转链表&lt;/h2&gt;

&lt;p&gt;有两种方法，非递归和递归的方法。&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def reverseList(self, head):
        # 递归
        if not head:
            return 
        if not head.next:
            return head
        root = self.reverseList(head.next)
        head.next.next = head
        head.next = None
        return root

        # 以下为非递归
        # cur = head
        # prev = None
        # while cur:
        #     after = cur.next
        #     cur.next = prev
        #     prev = cur
        #     cur = after
        # return prev
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;链表中倒数第k个节点&#34;&gt;链表中倒数第K个节点&lt;/h2&gt;

&lt;p&gt;使用两个指针，第一个指针先走K个节点，然后第二个指针才开始和第一个指针一起走。当第一个指针到达链表尾端，第二个指针指向的节点就是倒数第K个节点。&lt;/p&gt;

&lt;h2 id=&#34;判断一个单向链表是否形成了环形结构&#34;&gt;判断一个单向链表是否形成了环形结构。&lt;/h2&gt;

&lt;p&gt;也是定义两个指针，一个快指针一次走一步，一个慢指针一次走两步，如果快指针追赶到了慢指针说明有环，若快指针变成NULL则无环。&lt;/p&gt;

&lt;h1 id=&#34;快速排序&#34;&gt;快速排序&lt;/h1&gt;

&lt;p&gt;快速排序是很基本的一种排序算法，在面试中经常被问道，而且很多题目也是基于快速排序的一个变形。这里给出一个基本的实现：
网上很多解法，通常是利用递归进行广度搜索：&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;    def partition(a, l, r):
        flag = a[r]
        j = l - 1
        for i in range(l, r):
            if a[i] &amp;lt;= flag:
                j += 1
                a[i], a[j] = a[j], a[i]
        a[j + 1], a[r] = a[r], a[j + 1]
        return j + 1
    def Quicksort(a, l, r):
        if l &amp;lt; r:
            q = partition(a, l, r)
            Quicksort(a, l, q - 1)
            Quicksort(a, q + 1, r)
&lt;/code&gt;&lt;/pre&gt;
</description>
      
    </item>
    
    <item>
      <title>Markdown</title>
      <link>http://chanrom.github.io/post/mimic/markdown/</link>
      <pubDate>Sat, 28 Apr 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/mimic/markdown/</guid>
      
        <description>

&lt;h1 id=&#34;参考网站&#34;&gt;参考网站&lt;/h1&gt;

&lt;p&gt;&lt;a href=&#34;https://segmentfault.com/markdown&#34;&gt;Markdown 编辑器语法指南&lt;/a&gt;&lt;/p&gt;

&lt;h1 id=&#34;代码高亮&#34;&gt;代码高亮&lt;/h1&gt;

&lt;pre&gt;&lt;code class=&#34;language-python&#34;&gt;python sdf
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;标题&#34;&gt;标题&lt;/h1&gt;

&lt;pre&gt;&lt;code class=&#34;language-markdown&#34;&gt;# 标题
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;标题1&#34;&gt;标题1&lt;/h1&gt;

&lt;pre&gt;&lt;code class=&#34;language-markdown&#34;&gt;标题1
======
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;标题2&#34;&gt;标题2&lt;/h2&gt;

&lt;pre&gt;&lt;code class=&#34;language-markdown&#34;&gt;标题2
-----
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;大标题&#34;&gt;大标题&lt;/h2&gt;

&lt;pre&gt;&lt;code class=&#34;language-markdown&#34;&gt;## 大标题 ##
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;小标题&#34;&gt;小标题&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-markdown&#34;&gt;### 小标题 ###
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;粗体&#34;&gt;粗体&lt;/h1&gt;

&lt;p&gt;&lt;em&gt;斜体文本&lt;/em&gt;    &lt;em&gt;斜体文本&lt;/em&gt;
&lt;strong&gt;粗体文本&lt;/strong&gt;    &lt;strong&gt;粗体文本&lt;/strong&gt;
&lt;strong&gt;&lt;em&gt;粗斜体文本&lt;/em&gt;&lt;/strong&gt;    &lt;strong&gt;&lt;em&gt;粗斜体文本&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-markdown&#34;&gt;*斜体文本*    _斜体文本_
**粗体文本**    __粗体文本__
***粗斜体文本***    ___粗斜体文本___
&lt;/code&gt;&lt;/pre&gt;
</description>
      
    </item>
    
    <item>
      <title>使用Github搭建Hugo博客站</title>
      <link>http://chanrom.github.io/post/mimic/how-to/</link>
      <pubDate>Wed, 18 Apr 2018 00:00:00 +0000</pubDate>
      
      <guid>http://chanrom.github.io/post/mimic/how-to/</guid>
      
        <description>

&lt;h1 id=&#34;为什么要搭建个人博客&#34;&gt;为什么要搭建个人博客&lt;/h1&gt;

&lt;p&gt;我们在网络上获取别人的经验和知识的时候，通常呈现出来的都是一篇篇页面精致、内容专业的博客，令人耳目一新。有自己的博客，可以分享自己对一些事情、或者专业论文的看法，提高自己的知名度，使得我们在无穷无尽的因特网上有一个向世界展现自己的途径。&lt;/p&gt;

&lt;h1 id=&#34;准备工作&#34;&gt;准备工作&lt;/h1&gt;

&lt;p&gt;使用Github+Hugo建立个人博客之前，我们可能具备以下一些基础知识和工作：&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Git命令&lt;/li&gt;
&lt;li&gt;Github账号&lt;/li&gt;
&lt;/ul&gt;

&lt;h1 id=&#34;参考&#34;&gt;参考&lt;/h1&gt;

&lt;p&gt;目前主要参考的建站博客是&lt;a href=&#34;https://keysaim.github.io/post/blog/deploy-hugo-blog-in-github.io/&#34;&gt;keysaim&lt;/a&gt;，完全按照这个博客的做法就可以搭建成功。&lt;/p&gt;

&lt;h1 id=&#34;结语&#34;&gt;结语&lt;/h1&gt;

&lt;p&gt;大家有兴趣可以自己尝试做一个个人博客！&lt;/p&gt;
</description>
      
    </item>
    
  </channel>
</rss>