<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>CJW</title>
    <description>个人博客，主要是记录自己掌握的一些deeplearning 和machine learning 的知识</description>
    <link>https://chengjunwen.github.io/</link>
    <atom:link href="https://chengjunwen.github.io/feed.xml" rel="self" type="application/rss+xml"/>
    <pubDate>Thu, 31 Aug 2017 02:16:30 +0000</pubDate>
    <lastBuildDate>Thu, 31 Aug 2017 02:16:30 +0000</lastBuildDate>
    <generator>Jekyll v3.5.2</generator>
    
      <item>
        <title>各种机器学习方法简单介绍和比较</title>
        <description>(基本上都是从各个博客总结而来)
&lt;h3 id=&quot;各种机器学习算法比较&quot;&gt;各种机器学习算法比较&lt;/h3&gt;

&lt;strong&gt;判别方法&lt;/strong&gt;：由数据直接学习决策函数Y=f(X)或者条件概率分布P(Y|X)作为预测的模型，即判别模型。基本思想是有限样本条件下建立判别函数，不考虑样本的产生模型，直接研究预测模型。典型的判别模型包括k近邻，感知级，决策树，支持向量机等。

&lt;strong&gt;生成方法&lt;/strong&gt;：由数据学习联合概率密度分布P(X,Y)，然后求出条件概率分布P(Y|X)作为预测的模型，即生成模型：P(Y|X)= P(X,Y)/ P(X)

&lt;ul&gt;
  &lt;li&gt;偏差：描述的是预测值（估计值）的期望E’与真实值Y之间的差距。偏差越大，越偏离真实数据。&lt;/li&gt;
  &lt;li&gt;方差：描述的是预测值P的变化范围，离散程度，是预测值的方差，也就是离其期望值E的距离。方差越大，数据的分布越分散。&lt;/li&gt;
&lt;/ul&gt;

对于小训练集，高偏差/低方差的分类器（例如，朴素贝叶斯NB）要比低偏差/高方差大分类的&lt;strong&gt;优势大&lt;/strong&gt;（例如，KNN），因为后者会发生过拟合（overfiting）。然而，随着你训练集的增长，模型对于原数据的预测能力就越好，偏差就会降低，此时低偏差/高方差的分类器就会渐渐的表现其优势（因为它们有较低的渐近误差），而高偏差分类器这时已经不足以提供准确的模型了。当然，你也可以认为这是生成模型（如NB）与判别模型（如KNN）的一个区别

在统计学习框架下，大家刻画模型复杂度的时候，有这么个观点，认为Error = Bias + Variance。这里的Error大概可以理解为模型的预测错误率，是有两部分组成的，一部分是由于模型太简单而带来的估计不准确的部分（Bias），另一部分是由于模型太复杂而带来的更大的变化空间和不确定性（Variance）。模型越复杂，方差越大，偏差越小

</description>
        <pubDate>Sat, 15 Apr 2017 08:02:21 +0000</pubDate>
        <link>https://chengjunwen.github.io/2017/04/15/machine_learning_algorithms/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2017/04/15/machine_learning_algorithms/</guid>
        
        
        <category>算法</category>
        
      </item>
    
      <item>
        <title>VAE变分自编码器</title>
        <description>&lt;script type=&quot;text/javascript&quot; src=&quot;http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default&quot;&gt;&lt;/script&gt;

&lt;h3 id=&quot;变分自编码variant-autoencodervae&quot;&gt;变分自编码(variant autoencoder,VAE)&lt;/h3&gt;

VAE 其实是 autoencoder的一个变种
首先介绍一下什么是自编码器(autoencoder)：

&lt;h4 id=&quot;自编码器autoencoder&quot;&gt;自编码器（autoencoder）&lt;/h4&gt;

&lt;a href=&quot;https://github.com/chengjunwen/tensorflow_practice/blob/master/VariantAutoEncoder.py&quot;&gt;VAE 基于tensorflow的实现&lt;/a&gt;&lt;br /&gt;
如下图：
&lt;img src=&quot;/images/vae/autoencoder_schema.jpg&quot; alt=&quot;autoencoder_schema.jpg&quot; /&gt;&lt;br /&gt;
 自编码器由两部分组成： encoder 和decoder， encoder对输入数据(x)进行编码得到隐藏层的表达，decoder则对隐藏层的表达进行解码来重构和输入一样节点数大小的输出(y)， 模型优化时的目标函数则是x和y之间的重构误差。encoder和decoder可以是 MLP，CNN，RNN等的任意一种结构。&lt;br /&gt;
重构误差的目标函数： 
&lt;script type=&quot;math/tex&quot;&gt;loss = (\sum_{i=1}^n(y-x)^2)/n&lt;/script&gt;
重构误差也可以用交叉熵

一般 autoencoder可以用来做数据降维、数据压缩、数据去噪等，传统的深度学习方法也会用autoencoder对CNN网络进行逐层的预训  练。当然，最重要的是，auoencoder还可以用作无监督学习来学习数据的特征表达（其实，autoencoder并不是完全的无监督，更象是一种自监督学习）

&lt;h4 id=&quot;变分自编码器vae的基本原理&quot;&gt;变分自编码器(VAE)的基本原理&lt;/h4&gt;

  从上面 autoencoder的原理可以看出， autoencoder是直接去学习的输入数据的隐藏层表达，但VAE则不是如此。
 假定认为输入数据的数据集D(显变量)是受到一组隐变量 z 的控制，数据集的分布完全由这组隐变量操控，而这组隐变量之间&lt;strong&gt;相互独立而且服从高斯分布&lt;/strong&gt;。 VAE让 encoder 取学习输入数据的隐变量模型，也就是去学习这组隐变量的高斯概率分布的参数：z_mean,z_log_var,分别表示隐变量高斯分布的均值(&lt;script type=&quot;math/tex&quot;&gt;\mu&lt;/script&gt;)和方差(&lt;script type=&quot;math/tex&quot;&gt;\sigma&lt;/script&gt;)的log值)，而隐变量 z 则就可以从这组分布参数中采样得到： &lt;script type=&quot;math/tex&quot;&gt;z \sim N(\mu,\sigma)&lt;/script&gt;, 再通过 decoder 对z隐变量进行解码来重构输入。&lt;br /&gt;
 但实际中，VAE模型并没有真正的用&lt;script type=&quot;math/tex&quot;&gt;z \sim N(\mu,\sigma)&lt;/script&gt;来采样得到z变量， 因为这样采样之后，没有办法对&lt;script type=&quot;math/tex&quot;&gt;(\mu,\sigma)&lt;/script&gt;进行求导，也就没有办法用梯度下降算法对目标函数进行优化。VAE采用一个叫reparemerization的trick：先采样一个标准高斯分布(正态分布): &lt;script type=&quot;math/tex&quot;&gt;\epsilon \sim  N(0,1)&lt;/script&gt;, 然后&lt;script type=&quot;math/tex&quot;&gt;z=\mu+\epsilon * \sigma&lt;/script&gt;,这样得到的z就是服从&lt;script type=&quot;math/tex&quot;&gt;z \sim N(\mu,\sigma)&lt;/script&gt;，同时也可以正常的对&lt;script type=&quot;math/tex&quot;&gt;(\mu,\sigma)&lt;/script&gt;进行求导了。

模型框架如下所示：&lt;br /&gt;
&lt;img src=&quot;/images/vae/基本流程图.png&quot; alt=&quot;基本流程图.png&quot; /&gt;

从图可以看出， VAE主要分成以下三大模块：encoder，sample，decoder

&lt;strong&gt;1. encoder&lt;/strong&gt;：
学习隐变量的概率分布参数&lt;br /&gt;
伪码如下：

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;def encoder(self, input, n_hidden, m):
    n_in = int(input.get_shape()[1])
    shape=[n_in, n_hidden]
    w = tf.Variable(tf.truncated_normal( shape, stddev=0.001))
    b = tf.Variable(tf.zeros([hidden]))
    hidden= tf.nn.relu(tf.matmul(input,w)+b)
    
    shape = [n_hidden, m]
    w_var = tf.Variable(tf.truncated_normal( shape, stddev = 0.001))
    b_var = tf.Variable(tf.zeros([m]))
    w_mean = tf.Variable(tf.truncated_normal( shape, stddev=0.001))
    b_mean = tf.Variable(tf.zeros([m]))

    z_var = tf.matmul(hidden,w_var) + b_var
    z_mean = tf.matmul(hidden,w_mean) + b_mean
    return (z_mean, z_var)
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;strong&gt;2. sample&lt;/strong&gt;：
采样一个标准高斯分布，并通过encoder学习到的参数，生成 z

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;def sample_z(self, z_mean, z_var, std=1.0):

    epsilon = tf.random_normal(z_var.get_shape(),mean=0, stddev=std)
    z = tf.mul(tf.exp(0.5*z_var) , epsilon) + z_mean
    return z
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;strong&gt;3. decoder&lt;/strong&gt;：
通过z来重构输入x得到y，

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;def decoder(self, input, n_hidden, n):

    n_in = int(input.get_shape()[1])
    shape=[n_in,  n_hidden]
    w1 = tf.Variable(tf.truncated_normal( shape, stddev=0.001 ))
    b1 = tf.Variable(tf.zeros([n_hidden]))
    hidden= tf.nn.relu(tf.matmul(input,w1)+b1)
    shape=[n_hidden,  n]
    w2 = tf.Variable(tf.truncated_normal( shape, stddev=0.001 ))
    b2 = tf.Variable(tf.zeros([n]))
    y= tf.nn.sigmoid(tf.matmul(hidden,w)2+b2)
    return y
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

关于&lt;strong&gt;目标函数&lt;/strong&gt;，目标函数由两部分组成： x ，y的重构函数以及 z 变量的 KL 散度；

重构函数： &lt;br /&gt;
&lt;script type=&quot;math/tex&quot;&gt;reconstruct\_loss = (\sum\_{i=1}^N(y-x)^2)/N&lt;/script&gt;
KL 散度: &lt;br /&gt;
&lt;script type=&quot;math/tex&quot;&gt;KL\_loss=-0.5(1+log{\sigma}^2 - {\mu}^2 - {\sigma^2}) = -0.5(1+log{\sigma}^2 - {\mu}^2 - exp({log{\sigma^2}}))&lt;/script&gt;

总的目标函数： &lt;script type=&quot;math/tex&quot;&gt;loss = reconstruct\_loss + KL\_loss&lt;/script&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;def loss(self, x, y, z_mean,z_var):
    entropy = tf.nn.sigmoid_cross_entropy_with_logits(x,y)
    loss =  tf.reduce_sum(entropy,1)
    kl_loss = -0.5*tf.reduce_sum(1+z_var - tf.square(z_mean)-tf.exp(z_var) ,1)
    all_loss = tf.reduce_mean(loss + kl_loss)
    return all_loss
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

实验结果：

第一行是手写体的原数据图&lt;br /&gt;
第二行是VAE重构的结果：

&lt;img src=&quot;/images/vae/figure.png&quot; alt=&quot;result&quot; /&gt;

</description>
        <pubDate>Mon, 02 Jan 2017 08:29:33 +0000</pubDate>
        <link>https://chengjunwen.github.io/2017/01/02/VAE/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2017/01/02/VAE/</guid>
        
        
        <category>DeepLearning</category>
        
      </item>
    
      <item>
        <title>汇编之Data Movement Instructions</title>
        <description>&lt;h4 id=&quot;1-汇编的数据类型&quot;&gt;1. 汇编的数据类型&lt;/h4&gt;

 在汇编的指令里，最常用的就是copy data 的指令，可以将汇编的所有指令汇总成 instruction classes， 每个class里的所有指令做的数据类型不同的同一种操作。比如 mov ，基于不同的数据类型，有不同的指令。首先，关于64位系统里的汇编的数据类型与C++ 对照如下：
&lt;img src=&quot;/images/computersystem/datatype.png&quot; wight=&quot;500&quot; height=&quot;250&quot; /&gt;

&lt;h4 id=&quot;2-data-movement-instruction&quot;&gt;2. data movement instruction&lt;/h4&gt;

将数据从一个location(源地址) copy到另一个 location(目的地址)，称之为 move，

&lt;ol&gt;
  &lt;li&gt;源地址， 可以是 immediate(常数)，register，memory&lt;/li&gt;
  &lt;li&gt;目的地址， 可以是 register， memory&lt;/li&gt;
&lt;/ol&gt;

不过 ，在 x86-64的系统里禁止从 memory到memory的mov。

&lt;h5 id=&quot;21-mov&quot;&gt;2.1 MOV&lt;/h5&gt;

基于不同的数据类型， MOV 指令集有以下几个指令：
&lt;img src=&quot;/images/computersystem/mov.png&quot; wight=&quot;500&quot; height=&quot;200&quot; /&gt;

关于以上的mov指令，有一个需要注意的是 movl指令， 当目的地址是 register时，movl会register的高位的4个byte置 0 。(源数据 4个byte， register是 8个byte)。不过，对于movb，movw，即使目的地址是register，并不会将高位置 0 ，而是保留原值。举个小例子如下:
&lt;img src=&quot;/images/computersystem/movexample.png&quot; wight=&quot;400&quot; height=&quot;150&quot; /&gt;

上图里的数据是16进制表示的，可以发现 ，对于 1-3行的mov指令，高位的字节是保留原字节的，但是第 4 行的 movl指令将高位的4 个byte置 0 了。
对于MOV指令集 ，除了以上提到的，还有两大类，MOVZ和MOVS

&lt;ol&gt;
  &lt;li&gt;MOVZ， 补零扩展的 MOV。&lt;/li&gt;
  &lt;li&gt;MOVS， 符号位扩展的 MOV。&lt;/li&gt;
&lt;/ol&gt;

&lt;h5 id=&quot;22-movz&quot;&gt;2.2 MOVZ&lt;/h5&gt;

关于 MOVZ的指令集如下所示，
&lt;img src=&quot;/images/computersystem/movz.png&quot; wight=&quot;500&quot; height=&quot;200&quot; /&gt;

可以发现，这个指令集里没有从 double word 到 quad word 的mov，逻辑上可以写成movzlq指令，其实是因为这个指令其实和movl一样，都是高位 4 byte为0.

&lt;h5 id=&quot;23-movs&quot;&gt;2.3 MOVS&lt;/h5&gt;

MOVS 是指符号位扩展，也就是将空缺的高位补成符号位。关于 MOVS的指令集如下所示，
&lt;img src=&quot;/images/computersystem/movs.png&quot; wight=&quot;500&quot; height=&quot;270&quot; /&gt;

和MOVZ相比，MOVS里就有 movslq指令。另外，MOVS里还有一个指令 cltq，其实这个指令并不是一个真正的mov指令， 而是对 32位的寄存器 %eax符号位拓展成 64位的寄存器 %rax，所以这个指令的源地址和目的地址分别固定为 %eax 和 %rax。这个指令的效果和 &lt;script type=&quot;math/tex&quot;&gt;$ movslq \ \%eax,\%rax&lt;/script&gt;$ 相同

&lt;h5 id=&quot;24-push-and-pop-stack-data&quot;&gt;2.4 push and pop stack data&lt;/h5&gt;

程序运行时，会有一个 stack内存用来存储数据，这个栈是向下增长的，也就是说栈顶是低地址。程序对于栈入栈出栈的操作指令也是一种 MOV 指令：

&lt;ol&gt;
  &lt;li&gt;pushq S，将数据 S 压入栈顶。&lt;/li&gt;
  &lt;li&gt;popq D，从栈顶删除数据并将该数据写入 D。&lt;/li&gt;
&lt;/ol&gt;

&lt;img src=&quot;/images/computersystem/stack.png&quot; wight=&quot;500&quot; height=&quot;200&quot; /&gt;

%rsp 是stack pointer， 指向栈顶。
</description>
        <pubDate>Mon, 02 Jan 2017 08:29:33 +0000</pubDate>
        <link>https://chengjunwen.github.io/2017/01/02/data_movement_instruction/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2017/01/02/data_movement_instruction/</guid>
        
        
      </item>
    
      <item>
        <title>程序编译,链接</title>
        <description>&lt;h3 id=&quot;简介&quot;&gt;简介&lt;/h3&gt;

  一般我们写的编程语言 eg. C++ ,C 等都是高级编程语言，并不能倍机器直接认识，高级语言需要先转换成低级的机器语言指令，才能被机器执行。将这些指令打包到一个 executable object program里面，这个executable object program 就是我们常说的可执行文件 executable object file。&lt;br /&gt;
 关于 GNU , GNU 是一种编译工具，支持的语言有 C，C++ ，java ，fortran，pascal object-C，Ada等。

&lt;h3 id=&quot;编译过程&quot;&gt;编译过程&lt;/h3&gt;

以helloword为例子， hello.c:

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;#include &amp;lt;stdio.h&amp;gt;
int main()
{
	printf( 11 hello, world\n 11 ) ;
	return O;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

 在linux系统上，把一个源文件(hello.c) 转换成 可执行文件(hello)需要四个步骤:

&lt;ol&gt;
  &lt;li&gt;预处理 ，preprocessing &lt;br /&gt;
 	预处理是处理 ‘#’开头的代码行，例如 #include &lt;stdio.h&gt; ,预处理器会读取系统头文件 stdio.h里面的全部文件 并插入到hello.c里,这一步生成的文件还是文本的 program，后缀  .i 。&lt;/stdio.h&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    	gcc -E hello.c -o test.i
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;ol&gt;
  &lt;li&gt;编译 ， compilation &lt;br /&gt;
 编译是指将文本的程序代码(hello.i)编译成汇编语言的程序代码(hello.s)。hello.s也是text file.汇编语言以一种人能理解的方式描述了机器语言指令。对于不同的编译器和不同的语言， 汇编语言提供了一种通用的语言模式。&lt;/li&gt;
&lt;/ol&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    	gcc -S hello.i -o test.s
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;	main:
		sub'q 	$8, %rsp
		movl 	$.LCO, %edi
		call	puts
		movl 	$0, %eax
    	addq	$8, %rsp
		ret 
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;ol&gt;
  &lt;li&gt;汇编， assembly &lt;br /&gt;
 汇编将汇编语言(hello.s)转换成机器语言指令，并打包成可重定位的目标代码(relocatable object program)，存储成二进制的目标文件(hello.o)&lt;/li&gt;
&lt;/ol&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;   gcc -c hello.s -o test.o     
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;ol&gt;
  &lt;li&gt;链接， linking&lt;br /&gt;
 链接是将 程序的目标文件和其他所需的目标文件链接起来生成最后的可执行文件。&lt;br /&gt;
 关于其他所需的目标文件， 可能是调用的自己项目里的其他目标文件，也可能是调用的第三方库文件，以及系统库文件。例如helloword里用到的printf函数，其实现方法是在一个printf.o 的目标文件里， 链接需要将 hello.o 和 printf.o 链接起来生成 可执行文件(hello) 。&lt;/li&gt;
&lt;/ol&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    gcc hello.o  -o hello
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;h4 id=&quot;静态库a-和-动态库so&quot;&gt;静态库(.a) 和 动态库(.so)&lt;/h4&gt;

&lt;h5 id=&quot;1-静态库&quot;&gt;1. 静态库：&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;在程序编译的时加载到程序里，所以程序运行时删掉.a文件也可以运行。&lt;/li&gt;
  &lt;li&gt;
    编译时需要指定库文件路径(通过-L参数传递)，也要指定库名(-l)，&lt;br /&gt;
  eg，Makefile里通常用LDFLAGS指定库路径，LIBS指定库名：

  	LDFLAGS=-L/usr/lib -L/path/to/your/lib
  	LIBS = -lpthread -liconv

    关于编译过程，假设libhello.a和main.c在一个目录下：

    &lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;  gcc -c main.c
  gcc -o hello main.o libhello.a
  	//gcc -o hello main.o -L. -lhello  //可替代上句
  //gcc -o hello main.c -L. -lhello  //可替代一二句
&lt;/code&gt;&lt;/pre&gt;
    &lt;/div&gt;

    编译时，非系统库不能放在main文件之前，否则会报错未定义。
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h5 id=&quot;2-动态库&quot;&gt;2. 动态库&lt;/h5&gt;

&lt;ul&gt;
  &lt;li&gt;在程序运行时才加载到程序中，所以运行时也需要库文件的存在&lt;/li&gt;
  &lt;li&gt;编译时，和静态库一样，需要指定动态库库路径和库名&lt;/li&gt;
&lt;/ul&gt;

静态库函数改变后，调用静态库的源码也需要重新编译
动态库函数改变后，调用动态库的源码不需要重新编译

</description>
        <pubDate>Wed, 28 Dec 2016 04:31:16 +0000</pubDate>
        <link>https://chengjunwen.github.io/2016/12/28/compile_and_link/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2016/12/28/compile_and_link/</guid>
        
        
        <category>ComputerSystem</category>
        
      </item>
    
      <item>
        <title>convolution和deconvolution</title>
        <description>&lt;h3 id=&quot;卷积&quot;&gt;卷积&lt;/h3&gt;

 首先简单的介绍一下卷积的定义，如下图，f 和 g 卷积， 相当于把 g 翻转之后沿着 x 轴滑动来累计两函数的积分值。如下图所示：
&lt;img src=&quot;/images/conv/Convolution.png&quot; alt=&quot;convolution&quot; /&gt;

&lt;h3 id=&quot;图像卷积convolution的三种形式&quot;&gt;图像卷积(convolution)的三种形式&lt;/h3&gt;

大家看CNN(卷积网络)时肯定有注意到有个参数padding可以设置成 full , same, valid三种，不同参数的卷积形式略有不同。

&lt;ol&gt;
  &lt;li&gt;
    full卷积&lt;br /&gt;
 full卷积很像上述所提到的卷积， iamge(A)和kernel filter(B)卷积（A*B），就是把B翻转然后滑动累积和A的积分指。由于A是图片，这样就意味着要对A进行padding，卷积计算从B和A的最边缘有交集就开始计算，所以也叫 full convolution。full conv之后图片的大小会比 A图大。如下图所示(盗图，懒得画图了).&lt;br /&gt;
 ![]/images/conv/full.png)
  &lt;/li&gt;
  &lt;li&gt;
    same 卷积&lt;br /&gt;
 将图 A 和 B 进行 same 卷积，卷积之后 A 图的大小不变，所以就叫 same 卷积。s卷积计算的起始点是从 B 图的中心和 A 图有交集开始，same 卷积如下图所示，所以 same 卷积也会对 A 图进行padding。&lt;br /&gt;
 ![]/images/conv/same.png)
  &lt;/li&gt;
  &lt;li&gt;
    valid 卷积&lt;br /&gt;
 valid 卷积不需要对图 A 进行padding， 也就是大家平常看CNN 网络讲解图时常用的卷积形式，卷积计算从 B 被 A 完全交集开始计算， 如下图所示：&lt;br /&gt;
 ![]/images/conv/valid.png)
  &lt;/li&gt;
&lt;/ol&gt;

%emsp;关于 三种卷积对于输出map大小的影响，假设 输入 iamge 大小是 N*N ,kernel filter大小是 M*M,卷积时步长为s，如果padding的长度是p，则卷积之后map大小是 [ (N-M+2*p)/s +1 ] * [ (N-M+2*p)/s +1 ]，这个公式可以套到下面三种卷积里面。

&lt;ul&gt;
  &lt;li&gt;valid 卷积，步长为1 时，输出大小 (N-M +1) * (N-M +1)&lt;/li&gt;
  &lt;li&gt;same 卷积，步长为1 时， 输出map大小 N * N。pad的长度是 (M-1)/2, M 一般是奇数。&lt;/li&gt;
  &lt;li&gt;full 卷积，步长为1 时， 输出map大小 (N+M-1) * (N+M-1)。pad的长度是 M-1&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;图像反卷积-deconvolution&quot;&gt;图像反卷积 ,deconvolution&lt;/h3&gt;

 其实关于图像的反卷积并不是真正意义上的反卷积，用反卷积命名是错误的，成为 转置卷积（transposed convolution ）更为准确。反卷积可以让输出图比输入图大，CNN网络用反卷积通常是为了重构出原图的大小(经过conv之后图片一般会变小)，这个在 full CNN 里面就用来重构出原图的大小，从而进行pixel 级别的语义分割。反卷积有两种形式，

&lt;ol&gt;
  &lt;li&gt;
    上面提到的 full convolution 其实就是一种反卷积，如果步长为一，如下图所示，蓝色部分是原图 2*2， 白色部分是 padding的：

    &lt;img src=&quot;/images/conv/YyCu2.gif&quot; alt=&quot;deconv1&quot; /&gt;
  &lt;/li&gt;
  &lt;li&gt;
    还有一种，并不是直接在原图四周padding，而是一种插入时的padding，如下，蓝色部分是原图 2*2， 白色部分是 padding的:

    &lt;img src=&quot;/images/conv/f2RiP.gif&quot; alt=&quot;deconv2&quot; /&gt;
  &lt;/li&gt;
&lt;/ol&gt;

</description>
        <pubDate>Thu, 22 Dec 2016 09:01:57 +0000</pubDate>
        <link>https://chengjunwen.github.io/2016/12/22/convolution_vs_deconvolution/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2016/12/22/convolution_vs_deconvolution/</guid>
        
        
        <category>DeepLearning</category>
        
      </item>
    
      <item>
        <title>BWT算法</title>
        <description>&lt;h3 id=&quot;bwtburrows-wheeler-transform&quot;&gt;BWT(Burrows Wheeler Transform)&lt;/h3&gt;

 BWT，数据转换算法，其实也是一种压缩算法，基本思想就是找到字符串的重复部分来进行压缩，还可以用来进行序列比对。BWT会将字符串转换成一个类似的字符串，但是转换后的字符串的相同字符是相邻的，这样，我们就可以对数据进行压缩了。这个算法的解压缩也很方便简单。

&lt;h3 id=&quot;bwt原理&quot;&gt;BWT原理&lt;/h3&gt;

&lt;h4 id=&quot;bwt编码部分&quot;&gt;BWT编码部分&lt;/h4&gt;

BWT编码压缩步骤如下：

&lt;ol&gt;
  &lt;li&gt;首先对要转换的字符串，添加一个不在字符串里的ASCII码表里最小的字符。如 AGGAGC ——&amp;gt; $AGGAGC，添加了 $ 。&lt;/li&gt;
  &lt;li&gt;对字符串进行依次循环移位，得到一系列的字符串，如果字符串长度为 n， 就可以得到n个字符串，如下面图里的第二列所示。&lt;/li&gt;
  &lt;li&gt;对2中的位移后的一系列的字符串按照ASCII进行排序，如下图的第四列所示，第三列是排序后的字符串的原index位置。&lt;/li&gt;
  &lt;li&gt;取位移后的一系列字符串的首字母出来作为 F 列， 最后一个字母作为 L 列。如下图 F 列 和L 列所示。&lt;/li&gt;
  &lt;li&gt;L 列就是最后的编码结果。&lt;/li&gt;
&lt;/ol&gt;

&lt;table&gt;
  &lt;tbody&gt;
    &lt;tr&gt;
      &lt;td&gt;No.&lt;/td&gt;
      &lt;td&gt;rotated&lt;/td&gt;
      &lt;td&gt;index&lt;/td&gt;
      &lt;td&gt;sorted&lt;/td&gt;
      &lt;td&gt;F&lt;/td&gt;
      &lt;td&gt;L&lt;/td&gt;
      &lt;td&gt;LF&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td&gt;0&lt;/td&gt;
      &lt;td&gt;AGGAGC$&lt;/td&gt;
      &lt;td&gt;6&lt;/td&gt;
      &lt;td&gt;$AGGAGC&lt;/td&gt;
      &lt;td&gt;$&lt;/td&gt;
      &lt;td&gt;C&lt;/td&gt;
      &lt;td&gt;C-&amp;gt;$&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td&gt;1&lt;/td&gt;
      &lt;td&gt;GGAGC$A&lt;/td&gt;
      &lt;td&gt;3&lt;/td&gt;
      &lt;td&gt;AGC$AGG&lt;/td&gt;
      &lt;td&gt;A&lt;/td&gt;
      &lt;td&gt;G&lt;/td&gt;
      &lt;td&gt;G-&amp;gt;A&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td&gt;2&lt;/td&gt;
      &lt;td&gt;GAGC$AG&lt;/td&gt;
      &lt;td&gt;0&lt;/td&gt;
      &lt;td&gt;AGGAGC$&lt;/td&gt;
      &lt;td&gt;A&lt;/td&gt;
      &lt;td&gt;$&lt;/td&gt;
      &lt;td&gt;$-&amp;gt;A&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td&gt;3&lt;/td&gt;
      &lt;td&gt;AGC$AGG&lt;/td&gt;
      &lt;td&gt;5&lt;/td&gt;
      &lt;td&gt;C$AGGAG&lt;/td&gt;
      &lt;td&gt;C&lt;/td&gt;
      &lt;td&gt;G&lt;/td&gt;
      &lt;td&gt;G-&amp;gt;C&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td&gt;4&lt;/td&gt;
      &lt;td&gt;GC$AGGA&lt;/td&gt;
      &lt;td&gt;2&lt;/td&gt;
      &lt;td&gt;GAGC$AG&lt;/td&gt;
      &lt;td&gt;G&lt;/td&gt;
      &lt;td&gt;G&lt;/td&gt;
      &lt;td&gt;G-&amp;gt;G&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td&gt;5&lt;/td&gt;
      &lt;td&gt;C$AGGAG&lt;/td&gt;
      &lt;td&gt;4&lt;/td&gt;
      &lt;td&gt;GC$AGGA&lt;/td&gt;
      &lt;td&gt;G&lt;/td&gt;
      &lt;td&gt;A&lt;/td&gt;
      &lt;td&gt;A-&amp;gt;G&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td&gt;6&lt;/td&gt;
      &lt;td&gt;$AGGAGC&lt;/td&gt;
      &lt;td&gt;1&lt;/td&gt;
      &lt;td&gt;GGAGC$A&lt;/td&gt;
      &lt;td&gt;G&lt;/td&gt;
      &lt;td&gt;A&lt;/td&gt;
      &lt;td&gt;A-&amp;gt;G&lt;/td&gt;
    &lt;/tr&gt;
  &lt;/tbody&gt;
&lt;/table&gt;

由编码过程，参考上图，其实可以发现BWT编码有三个特性(循环位移决定)，

&lt;ol&gt;
  &lt;li&gt;L 列的第一个元素是源字符串的最后一个元素。&lt;/li&gt;
  &lt;li&gt;循环位移可知，同一行的 F 列和 L 列的元素在源字符串里是相邻的，而且 L 列元素的下一个字符就是 同行里 F 列的元素。&lt;/li&gt;
  &lt;li&gt;同一种字符在 F 列和 L 列里的rank是一样的，比方说， F 列里的第二个 A 和 L 列里的第二个 A 在源字符串里是同一个A。 F 列里的第一个 G 和 L 列里的第一个 G 在源字符串里是同一个G,rank如下图所示。&lt;/li&gt;
&lt;/ol&gt;

&lt;img src=&quot;/images/bwt/FLrank.png&quot; alt=&quot;rank&quot; /&gt;

根据以上这三个条件， 我们就可以进行BWT解码，也就是解压缩。

&lt;h4 id=&quot;bwt解码部分&quot;&gt;BWT解码部分&lt;/h4&gt;

BWT解码，已知 L 列， 推源字符串。

&lt;ol&gt;
  &lt;li&gt;由 L 列 得到 F 列。因为L 列 和F 列其实都是源串的字符的不同排列方式，但是我们知道 F 列是按照 ASCII码排序的，所以从 L 就可以推出 F 。&lt;/li&gt;
  &lt;li&gt;根据第一个性质，我们可以得到源串的最后一个字符是 L 列的第一个字符，作为当前字符(下面依次往前递推)。&lt;/li&gt;
  &lt;li&gt;依据上一步得到的作为当前字符， 根据第三个性质，我们可以得到同一个字符在 F 列中的位置，作为当前字符。&lt;/li&gt;
  &lt;li&gt;依据 F 列里的当前字符，根据第二个性质，我们可以得到当前字符的上一个字符是同行里的 L 列里的元素,将新增字符作为当前字符，然后跳转到第 3 步。&lt;/li&gt;
  &lt;li&gt;直到所有字符全部推算出来。&lt;/li&gt;
&lt;/ol&gt;

整个过程如下图所示：&lt;br /&gt;
&lt;img src=&quot;/images/bwt/LFmapping.png&quot; alt=&quot;jiema&quot; /&gt;

</description>
        <pubDate>Tue, 08 Nov 2016 12:37:45 +0000</pubDate>
        <link>https://chengjunwen.github.io/2016/11/08/bwt/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2016/11/08/bwt/</guid>
        
        
        <category>算法</category>
        
      </item>
    
      <item>
        <title>强化学习课程系列之四：模型无关的策略估计</title>
        <description> 模型无关的策略估计(model free prediction)，可以看作是求解环境知识不完整的模型在特定策略π下的每一个状态值函数,模型无关(model free)，是指对于模型的环境知识知道的不完整，比如不知道转移概率或者立即回报函数。有两种方法求解，蒙特卡洛法和时间差分法，这两种方法的适用情况略有不同：

&lt;strong&gt;蒙特卡洛法(Mento Carlo methods, MC)&lt;/strong&gt; 适用条件:

&lt;ol&gt;
  &lt;li&gt;直接从eposides of experience中学习。即从经验中学习经验，经验就是训练样本，在初始状态 s下，遵循策略π最终获得总回报G，这就是一个样本。&lt;/li&gt;
  &lt;li&gt;model free。不需要知道状态转移概率或者立即回报函数。&lt;/li&gt;
  &lt;li&gt;只适用于eposides task。eposides task是指eposides必须有终点，能够在有限时间内达到终止状态,比方说围棋，经过若干回合之后一定会分出输赢或平局。训练所用的eposides必须是完整的eposides。&lt;/li&gt;
  &lt;li&gt;认为经验均值是期望值。&lt;/li&gt;
&lt;/ol&gt;

 可以发现，MC方法对于连续性的任务是不能用的，比方说自动驾驶，根据当前环境路况等来调整行驶方向和速度，要保证行驶，这样的问题，我们是得不到一个完整的有终点的样本。于是，有人就想出了 时间差分学习法来解决连续性任务。

&lt;strong&gt;时间差分法(Temporal different Learning, TD leaning)&lt;/strong&gt; 适用条件:

&lt;ol&gt;
  &lt;li&gt;直接从eposodes中学习。&lt;/li&gt;
  &lt;li&gt;model free。不需要完整的环境知识。不需要知道状态转移概率或者立即回报函数。&lt;/li&gt;
  &lt;li&gt;除了 eposides task， 还可以用于连续性任务。&lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&quot;1-蒙特卡洛法mento-carlo-methods-mc&quot;&gt;1. 蒙特卡洛法(Mento Carlo methods, MC)&lt;/h3&gt;

 策略估计，就是要学习策略对应的状态值函数Vπ(S)。MC分为first visit和every visit，first visit是只记录一个eposide里面状态 s 的第一次访问，every visit则记录每一次访问。下面讲一下 first visit MC 。
Gt是当前状态的长期总回报值：

&lt;img src=&quot;/images/rel2/Gt.png&quot; alt=&quot;Gt&quot; /&gt;   &lt;br /&gt;
估计状态 s 的值函数:

&lt;ol&gt;
  &lt;li&gt;对于每一个eposide里面，状态 s 的第一次访问:
    &lt;ul&gt;
      &lt;li&gt;增加访问计数：N(s) &amp;lt;—— N(s) + 1&lt;/li&gt;
      &lt;li&gt;增加总回报： S(s) &amp;lt;—— S(s) + Gt&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;估计 V(s)， V(s) = S(s)/N(s)&lt;/li&gt;
  &lt;li&gt;当N(s)——&amp;gt;∞,V(s)——&amp;gt; Vπ(s)&lt;/li&gt;
&lt;/ol&gt;

every visit的差别只需要把第一访问改成每一次访问即可

&lt;strong&gt;Incremental Monte Carlo Update:&lt;/strong&gt;    &lt;br /&gt;
一个序列 x1,x2,x3…..的均值 u1，u2, u3,…计算方式有如下简化：

&lt;img src=&quot;/images/rel3/transi.gif&quot; alt=&quot;uk&quot; /&gt;

从这个式子考虑发现，其实 MC methods的更新也有类似的变种: &lt;br /&gt;
估计状态 s 的值函数:

&lt;ol&gt;
  &lt;li&gt;每一个状态 St 的,其长期总回报函数为Gt,访问到St时：
    &lt;ul&gt;
      &lt;li&gt;增加访问计数：N(St) &amp;lt;—— N(St) + 1&lt;/li&gt;
      &lt;li&gt;更新状态值函数：&lt;img src=&quot;/images/rel3/MC1.gif&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;当N(s)——&amp;gt;∞,V(s)——&amp;gt; Vπ(s)&lt;/li&gt;
&lt;/ol&gt;

状态更新的式子也可以用这个式子： &lt;img src=&quot;/images/rel3/MC2.gif&quot; alt=&quot;&quot; /&gt; ,α 是学习率。

&lt;h3 id=&quot;2-时间差分法temporal-different-learning-td-leaning&quot;&gt;2. 时间差分法(Temporal different Learning, TD leaning)&lt;/h3&gt;

&lt;strong&gt;TD:&lt;/strong&gt;&lt;br /&gt;
 时间差分法的状态值更新方式和incremental MC的的第二种更新方式很像，也是引进了学习率 α,但还引进了衰减因子 γ，将 Gt 替换成了Rt+1 + γV(St+1)。

估计状态 s 的值函数:

&lt;ol&gt;
  &lt;li&gt;每一个状态 St 的,其长期总回报函数为Gt,每次访问到St时：
    &lt;ul&gt;
      &lt;li&gt;增加访问计数：N(St) &amp;lt;—— N(St) + 1&lt;/li&gt;
      &lt;li&gt;更新状态值函数：&lt;img src=&quot;/images/rel3/TD.gif&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;当N(s)——&amp;gt;∞,V(s)——&amp;gt; Vπ(s)&lt;/li&gt;
&lt;/ol&gt;

在这个状态值更新式里：&lt;br /&gt;
&lt;img src=&quot;/images/rel3/TDtarget.gif&quot; alt=&quot;&quot; /&gt; 是TD target   &lt;br /&gt;
&lt;img src=&quot;/images/rel3/TDerror.gif&quot; alt=&quot;&quot; /&gt; 是TD error

&lt;strong&gt;n-step TD:&lt;/strong&gt;
&lt;img src=&quot;/images/rel3/TDnstep.png&quot; width=&quot;800&quot; height=&quot;300&quot; /&gt;
 n-step TD对未来预测采取 n 步，总回报 G也是计算的n步的回报值。从上面的式子和图可以发现：

&lt;ol&gt;
  &lt;li&gt;n=1时，总回报值就是 TD 算法计算的总回报值。&lt;/li&gt;
  &lt;li&gt;n=∞时，总回报值就是 MC 算法计算的总回报值，这时候的n-step TD其实就是 MC算法。&lt;/li&gt;
&lt;/ol&gt;

&lt;strong&gt;TD(λ):&lt;/strong&gt;  &lt;br /&gt;
如果考虑到给 每个 step 的回报加上权重值然后相加来作为总回报值，如下图所示：
&lt;img src=&quot;/images/rel3/TDlamda.png&quot; width=&quot;700&quot; height=&quot;300&quot; /&gt;
这样子的总回报值是结合了所有step的回报，利用 λ来评估每个step的回报所占的比重。&lt;br /&gt;
从上图左边的链图里可以发现，有两个特殊情况：

&lt;ol&gt;
  &lt;li&gt;λ=0时，可以发现 TD(0) = TD。λ=0时，除了step=1的时候的回报比重是 1 ，其他step的回报的比重是0，所以这个时候实际上总回报只有 step=1的时候的总回报，和 TD算法的总回报值是一样的。&lt;/li&gt;
  &lt;li&gt;λ=1时，TD(1) = MC。λ=1的时候，可以发现总回报值只有最后一条链step=∞时候的回报，其他的占比都是0,这和MC是一样的。&lt;/li&gt;
&lt;/ol&gt;

</description>
        <pubDate>Mon, 17 Oct 2016 12:44:36 +0000</pubDate>
        <link>https://chengjunwen.github.io/2016/10/17/reinforcement_learning4/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2016/10/17/reinforcement_learning4/</guid>
        
        
        <category>强化学习</category>
        
      </item>
    
      <item>
        <title>强化学习课程系列之三：MDP动态规划求解</title>
        <description>强化学习，目的就是求解MDP(马尔科负决策过程)，而MDP的求解有三种情况:

&lt;ol&gt;
  &lt;li&gt;动态规划求解法：求解一个已知环境完整知识的MDP。有两种方法：
    &lt;ul&gt;
      &lt;li&gt;策略迭代&lt;/li&gt;
      &lt;li&gt;值迭代&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;Model free prediction：对于一个环境知识不完整的MDP， 估计状态值函数。有两种方法：
    &lt;ul&gt;
      &lt;li&gt;蒙特卡罗法： MC&lt;/li&gt;
      &lt;li&gt;时间差分学习法： TD&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;Model free control： 对于一个环境知识不完整的MDP， 优化状态值函数。&lt;/li&gt;
&lt;/ol&gt;

第三节，本篇博客就是讲的动态规划求解法，还有两种接下来的两节博客会讲到。

&lt;h3 id=&quot;1-贝尔曼方程bellman-equation&quot;&gt;1. 贝尔曼方程，Bellman Equation&lt;/h3&gt;

这里回顾一下上一节讲MDP时讲到的 Bellman equation

&lt;h4 id=&quot;贝尔曼期望方程-bellman-exception-equation&quot;&gt;贝尔曼期望方程： Bellman Exception Equation&lt;/h4&gt;

上一节提到了对于给定策略，如何计算状态值函数Vπ和动作值函数qπ，方程式如下：

&lt;img src=&quot;/images/rel3/vvalue.gif&quot; alt=&quot;&quot; /&gt;

&lt;img src=&quot;/images/rel3/qvalue.gif&quot; alt=&quot;&quot; /&gt;

这就是bellman exception equation， 从式子可以看出来，当前状态的值函数Vπ和下一状态的值函数相关。

&lt;h4 id=&quot;贝尔曼优化方程bellman-optimal-equation&quot;&gt;贝尔曼优化方程：Bellman Optimal Equation&lt;/h4&gt;
 关于寻找最优策略，是指时所有状态值函数最大的策略,而关于最优策略下的优化状态值函数和优化动作值函数，是满足bellman optimal equation方程的，也就是如下式两个方程：

&lt;img src=&quot;/images/rel3/svalueMax.png&quot; alt=&quot;&quot; /&gt;&lt;br /&gt;
&lt;img src=&quot;/images/rel3/qvalueMax.png&quot; alt=&quot;&quot; /&gt;

有了贝尔曼期望方程和贝尔曼优化方程，我们就可以利用动态规划求解法求解MDP的最优策略了，求解方法有策略迭代和值迭代两种。

&lt;h3 id=&quot;2-策略迭代-policy-iteration&quot;&gt;2. 策略迭代： Policy Iteration&lt;/h3&gt;

在讲策略迭代之前，先讲以下这个方法用到的两个基本步骤：策略估计和策略改进。

&lt;h4 id=&quot;21-策略估计policy-evaluation&quot;&gt;2.1 策略估计：Policy evaluation&lt;/h4&gt;

 策略估计：给定一个策略π，计算该策略下的所有状态值函数Vπ(S)，可以通过迭代贝尔曼期望方程求解。&lt;br /&gt;
贝尔曼方程告诉了我们对于确定的策略，如何求状态值函数，但是一般某个策略下，某个状态π(S)对应的动作a可能有很多种，一般采用多次迭代的方法更新状态值函数：

V1——&amp;gt;V2——&amp;gt;…——&amp;gt;Vπ

&lt;ol&gt;
  &lt;li&gt;首先初始化所有状态值函数V(s)为0&lt;/li&gt;
  &lt;li&gt;进行迭代，也就是重复步骤 3直至收敛。对于每一次迭代 k+1，进行步骤 3 :&lt;/li&gt;
  &lt;li&gt;遍历状态，对每一个状态 s in S，都进行以下操作:
    &lt;ul&gt;
      &lt;li&gt;采用下面式子对状态 s 的状态值函数进行更新。&lt;br /&gt;
&lt;img src=&quot;/images/rel3/valueItevPolicy.png&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;最后收敛至 Vπ,就是该策略的状态值函数。&lt;/li&gt;
&lt;/ol&gt;

最后，举个栗子，关于策略估计，假设一个4*4格子，左上角和右下角是终止状态点，非终止状态14个，明日歌状态可以采取的动作是移到相邻的格子(碰壁则留在原状态)，上下左右移动概率相等，都是0.25，转到终止态回报为0，其他任意转移的reward都是 -1，γ是1。
&lt;p align=&quot;center&quot;&gt;&lt;img src=&quot;/images/rel3/example11.png&quot; /&gt;
在k=0，初始状态是随机策略，V(s)全部随机为0. &lt;br /&gt;
k=1, 第一行第二列， v = 0.25*(-1+0)+ 0.25*(-1+0)+ 0.25*(-1+0)+ 0.25*(-1+0)= -1.0 ； &lt;br /&gt;
k=2, 第一行第二列， v = 0.25*(-1+0)+ 0.25*(-1-1)+ 0.25*(-1-1)+ 0.25*(-1-1)= -1.75 = -1.7；   &lt;br /&gt;
k=2，第一行第三列， v = 0.25*(-1-1)+ 0.25*(-1-1)+ 0.25*(-1-1)+ 0.25*(-1-1)=  -2.0；

&lt;h4 id=&quot;22-策略改进policy-improvement&quot;&gt;2.2 策略改进：Policy improvement&lt;/h4&gt;

 策略改进：是为了寻找一个更好的策略，对于一个策略，我们到底能不能找到更好的策略呢。如果对于策略π,对某个状态，采用的动作a0得到状态值函数，如果我们采取其他动作，会不会更好。怎么判断动作的好坏，我们就可以通过计算动作值函数来判断了，通过选取动作值函数最大的动作来改进策略获得新策略：&lt;br /&gt;
对于一个确定的策略，对每个状态，遍历这个状态的所有可能动作，采用贪心算法来获得新的优化的策略，步骤如下：

&lt;ol&gt;
  &lt;li&gt;遍历状态 s， 对每个状态 s in S，采用下面式子进行更新。&lt;br /&gt;
&lt;img src=&quot;/images/rel3/policyImpro.png&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;h4 id=&quot;23-策略迭代&quot;&gt;2.3 策略迭代&lt;/h4&gt;

 策略迭代的过程，其实就是策略估计和策略改进的组合，比如先随机给定一个策略，利用策略估计计算它的状态值函数，然后利用策略改进获得新策略，然后重复计算策略估计和策略改进，直至收敛。

&lt;ol&gt;
  &lt;li&gt;随机初始化一个策略&lt;/li&gt;
  &lt;li&gt;重复步骤 3，4，直至收敛&lt;/li&gt;
  &lt;li&gt;策略估计：&lt;br /&gt;
 多次迭代，对每个状态值函数进行更新直至收敛得到该策略的状态值函数。&lt;/li&gt;
  &lt;li&gt;策略改进：&lt;br /&gt;
 对每个状态进行改进，找动作值函数最大的动作来改进策略获得新策略。&lt;/li&gt;
  &lt;li&gt;最后策略收敛稳定时，返回的值函数和策略就是想要的结果。 
整个过程图解如下：&lt;br /&gt;
&lt;img src=&quot;/images/rel3/policyIteFigure.png&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
&lt;/ol&gt;

看图，策略迭代的过程就是根据策略迭代计算这个策略下每个状态的值函数，然后根据状态值函数来，利用贪心算法改进策略，不断的重复这两个步骤，最后收敛，所得到的就是优化策略。

&lt;h3 id=&quot;3-值迭代&quot;&gt;3. 值迭代&lt;/h3&gt;

 可以发现，其实策略迭代的方法计算量很大，在策略估计的过程中，每一个状态都要扫描很多次，这样代价太大。但是值迭代，每次迭代时，每个状态只需要扫描一次。

V1——&amp;gt;V2——&amp;gt;…——&amp;gt;V*

&lt;ol&gt;
  &lt;li&gt;首先初始化所有状态值函数V(s)为0&lt;/li&gt;
  &lt;li&gt;迭代操作，即重复步骤 3直至收敛。对于每一次迭代 k+1 :&lt;/li&gt;
  &lt;li&gt;对每一个状态 s in S，都进行以下操作:
    &lt;ul&gt;
      &lt;li&gt;采用下面式子对状态 s 的状态值函数进行更新。&lt;br /&gt;
&lt;img src=&quot;/images/rel3/valueIte.png&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;最后收敛的输出策略就是所求最优策略 π*。&lt;/li&gt;
&lt;/ol&gt;

一般来说，迭代次数很多才会收敛，实际计算的时候，可以根据精度需求来设置收敛阈值。&lt;br /&gt;
举个栗子，计算最短路径， 只有终止态回报为0， 其他都是-1，γ=1，如下图所示：
&lt;p align=&quot;center&quot;&gt;&lt;img src=&quot;/images/rel3/example2.png&quot; /&gt;
第一次迭代，初始化最大V值都是 V = 0；&lt;br /&gt;
第二次迭代，第一行第二列，下一状态不管往哪走，最大V值都是 V=-1 + 1*(0) = -1;&lt;br /&gt;
第三次迭代，第一行第二列， 向左走到终止态时，当前状态V最大， V = -1 + 1*(0) = -1；&lt;br /&gt;
第三次迭代，第一行第三列， 不管往哪走当前状态V一样， V = -1 + 1*(-1) = -2；&lt;br /&gt;
第四次迭代，第一行第三列， 往左走，当前状态V最大， V = -1 + 1*(-1) = -2；&lt;br /&gt;
第四次迭代，第二行第二列， 往上或者左走，当前状态V最大， V = -1 + 1*(-1) = -2；

&lt;h3 id=&quot;4-总结&quot;&gt;4. 总结&lt;/h3&gt;

通过策略迭代和值迭代都可以求出最优策略。下面有个表格总结以下完整环境知识下的MDP各种问题的求解：

&lt;img src=&quot;/images/rel3/conclusion.png&quot; alt=&quot;&quot; /&gt;

</description>
        <pubDate>Mon, 17 Oct 2016 04:39:59 +0000</pubDate>
        <link>https://chengjunwen.github.io/2016/10/17/reinforce_learning3/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2016/10/17/reinforce_learning3/</guid>
        
        
        <category>强化学习</category>
        
      </item>
    
      <item>
        <title>强化学习课程系列之二：马尔科夫决策过程，MDP</title>
        <description>&lt;h3 id=&quot;马尔科夫模型&quot;&gt;马尔科夫模型&lt;/h3&gt;

 关于马尔科夫，可以认为是一个自动机，以一定的概率P在各个状态s之间转移，马尔科夫模型由状态、转移概率矩阵{s,p}两部分组成。&lt;br /&gt;
 关于隐马尔科夫模型(HMM),比马尔科夫多了一个观测集合 O。可以认为是一个双重随机过程，状态之间的转移是随机的， 在某状态时的输出也是随机的。隐马尔科夫链由初始状态概率向量π、状态转移概率矩阵p、观测概率矩阵B三部分组成，{π,p,B}。马尔科夫和隐马尔科夫都具有无后效性，也就是系统的下一个状态之和当前的状态有关，和更早以前的无关。&lt;br /&gt;
 马尔科夫决策过程(Markov Decision Process, MDP)，比HMM多了一个动作集合，也具有无后效性。但是相比于隐马尔科夫，MDP的下一状态s’不仅和当前状态s相关，还和当前状态下所采取的动作a相关。

&lt;h3 id=&quot;马尔科夫决策过程mdp&quot;&gt;马尔科夫决策过程，MDP&lt;/h3&gt;

 一个马尔科夫决策过程由一个元组构成： M = { S, A, Psa, R，γ}

&lt;ol&gt;
  &lt;li&gt;S, 状态集合， s ∈  S, si 表示 第 i 步的状态&lt;/li&gt;
  &lt;li&gt;A, 动作集合， a ∈  A, ai 表示 第 i 步的动作&lt;/li&gt;
  &lt;li&gt;Psa, 状态转移概率， Psa表示在状态 s 下，采取动作 a 之后的所转移到的状态的概率分布情况。&lt;/li&gt;
  &lt;li&gt;R，回报函数，reward， 假设在 {s,a}的情况下转移到 s’,则定义其回报函数为 r(s’|s,a)。回报是根据状态和动作得到的,如果 s，a确定之后的 s’是唯一的，回报函数可以记作 r(s,a)。&lt;/li&gt;
  &lt;li&gt;γ, 衰减因子， 0-1之间。&lt;/li&gt;
&lt;/ol&gt;

&lt;h4 id=&quot;策略policyπ&quot;&gt;策略(policy),π&lt;/h4&gt;

 策略：π： S-&amp;gt;A, ，指在t时刻，给定状态下，所能采取的动作的概率分布： 记作 π(a|s) = P(At=a | St=s),可以认为是状态到动作的映射，这也正是一个智能体(agent)所要学习的东西，策略完全决定了一个智能体(agent)的行为，MDP 的策略取决于当前状态。 &lt;br /&gt;
 给定一个MDP， M= { S, A, Psa, R，γ}，以及策略 π，则状态序列S1，S2，… 就是一个马尔科负过程{S, Pπ}。状态和回报序列 S1，R1，S2，R2，… 就是一个马尔科夫回报过程 {S,Pπ, Rπ, γ},而且有：

&lt;img src=&quot;/images/rel2/Psspi.png&quot; alt=&quot;Pss'π&quot; /&gt;

&lt;h4 id=&quot;值函数value-function&quot;&gt;值函数，value function&lt;/h4&gt;

 强化学习的过程，就是学习环境状态到动作的映射，可以发现，这就是在学习一个能够获得最大回报的策略π。不过强化学习的回报是具有延迟性的，立即回报函数 r(s,a) 并不能完全确定策略的好坏，我们还必须评估未来的回报函数。

如果定义衰减回报和如下式所示,其中Ri是第i-1步的立即回报：

&lt;img src=&quot;/images/rel2/Gt.png&quot; alt=&quot;Gt&quot; /&gt;&lt;br /&gt;
其中γ是衰减因子，决定了长期回报的重要性，γ为0时忽略长期回报，为1时，所有时刻的回报同等重要。&lt;br /&gt;
定义一个状态值函数 Vπ(s),来表示在状态s 下，策略 π的长期影响产生的回报: &lt;br /&gt;
&lt;strong&gt;状态值函数(state value function)&lt;/strong&gt;如下：&lt;br /&gt;
&lt;img src=&quot;/images/rel2/vvalue.gif&quot; alt=&quot;vValue&quot; /&gt;

再定义一个&lt;strong&gt;动作值函数(action value fucntion)&lt;/strong&gt;，表示在状态 s 下， 采取动作 a 之后依照 策略 π所产生的期望回报:

&lt;img src=&quot;/images/rel2/qvalue.gif&quot; alt=&quot;qValue&quot; /&gt;

需要注意的是，在状态值函数里，只有初始状态s和策略π是给定的，初始动作是由s和π决定的，而在动作值函数里面，初始状态s和初始动作a，策略π都是给定的。

其实上面两个值函数的定义方程也就是贝尔曼方程(Bellman exception equation)。&lt;br /&gt;
根据状态s下，采取动作a之后的状态转移概率，可以发现 状态值函数和动作值函数之间的关系如下所示：
&lt;img src=&quot;/images/rel2/rela1.png&quot; alt=&quot;rela1&quot; /&gt;  &lt;br /&gt;
&lt;img src=&quot;/images/rel2/rela2.png&quot; alt=&quot;rela2&quot; /&gt;

将关系式带入原贝尔曼方程，可以得到贝尔曼方程变种，算是展开了的贝尔曼方程。。 &lt;br /&gt;
&lt;img src=&quot;/images/rel2/rela4.png&quot; alt=&quot;bellman1&quot; /&gt;  &lt;br /&gt;
&lt;img src=&quot;/images/rel2/rela3.png&quot; alt=&quot;bellman2&quot; /&gt;

&lt;h4 id=&quot;优化值函数&quot;&gt;优化值函数&lt;/h4&gt;

优化值函数，就是寻找在任意初始条件下，能够最大化值函数的策略π*，&lt;br /&gt;
通过最大化状态值函数或者最大化动作值函数都可以:

&lt;img src=&quot;/images/rel2/argmaxQ.png&quot; alt=&quot;argmaxQ&quot; /&gt;

关于贝尔曼优化方程(Bellman optimal equation)：

&lt;img src=&quot;/images/rel2/optimalV.png&quot; alt=&quot;&quot; /&gt;&lt;br /&gt;
&lt;img src=&quot;/images/rel2/optimalQ.png&quot; alt=&quot;&quot; /&gt;

贝尔曼优化方程是非线性的，通过多次迭代求解贝尔曼优化方程可以求解MDP的最优策略。

</description>
        <pubDate>Fri, 14 Oct 2016 07:08:39 +0000</pubDate>
        <link>https://chengjunwen.github.io/2016/10/14/reinforcement_learning_2/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2016/10/14/reinforcement_learning_2/</guid>
        
        
        <category>强化学习</category>
        
      </item>
    
      <item>
        <title>强化学习课程系列之一：基本介绍</title>
        <description> 最近在看reinforcement learning 的视频课程，记录了一些笔记，顺便整理成博客，课程内容复杂有些难理解，博客也许会有些错误的地方，望指正谅解，大家一起学习.

&lt;h3 id=&quot;机器学习分类&quot;&gt;机器学习分类&lt;/h3&gt;

机器学习大概可以分为以下几个类别：

&lt;ol&gt;
  &lt;li&gt;监督学习：从有标注的训练集中训练学习模型，可以对新数据进行预测。eg. 决策树，回归分析等&lt;/li&gt;
  &lt;li&gt;无监督学习：和有监督相比，训练集没有标注，eg 各种聚类算法。&lt;/li&gt;
  &lt;li&gt;半监督学习： 介于以上的两者之间。&lt;/li&gt;
  &lt;li&gt;强化学习：基于环境而行动，以获得最大化的预期利益。&lt;/li&gt;
&lt;/ol&gt;

&lt;a href=&quot;http://www0.cs.ucl.ac.uk/staff/d.silver/web/Teaching.html&quot;&gt;强化学习课程官网&lt;/a&gt;，主讲人是David Silver。&lt;br /&gt;
课程视频油管上可以找到，不能翻墙的小伙伴可以点这个&lt;a href=&quot;https://pan.baidu.com/s/10M8gA#list/path=%2F&quot;&gt;强化学习百度网盘&lt;/a&gt;。

&lt;h3 id=&quot;强化学习&quot;&gt;强化学习&lt;/h3&gt;

  强化学习： 是指一个智能体(agent)从环境(environment)中学习从状态(state)到动作(action)的映射。是一种无监督学习，没有label，而是反馈信号，而且反馈具有延时性，并不是即时的。比方说下棋，这一步所下的棋所产生的影响并不会完全的即时反馈出来，在未来的步骤中也会有所影响。强化学习组成如下：   &lt;br /&gt;
&lt;img src=&quot;/images/rel2/relearning.png&quot; alt=&quot;relearning&quot; /&gt;

&lt;ol&gt;
  &lt;li&gt;agent,智能体(上图中的大脑)&lt;/li&gt;
  &lt;li&gt;environment,环境(上图中的地球)&lt;/li&gt;
  &lt;li&gt;&lt;img src=&quot;/images/rel2/sat.gif&quot; alt=&quot;Sta&quot; /&gt;：agent的状态(state)，表示agent自己内部的表现，这是强化学习学习时所用到的信息。&lt;/li&gt;
  &lt;li&gt;&lt;img src=&quot;/images/rel2/sae.gif&quot; alt=&quot;Ste&quot; /&gt;：environment的状态,这是环境自己的状态，一般对agent不可见&lt;/li&gt;
  &lt;li&gt;At: 动作(action)，表示 agent在某状态 S 采取的动作&lt;/li&gt;
  &lt;li&gt;Rt; 回报函数(Reward)，在 S 状态， 采取 A 动作所获得的奖励。&lt;/li&gt;
  &lt;li&gt;Ot: 观测值(observation)。&lt;/li&gt;
&lt;/ol&gt;

整个过程：
在某时刻 t ：

&lt;ol&gt;
  &lt;li&gt;agent行为：
    &lt;ul&gt;
      &lt;li&gt;执行动作 At&lt;/li&gt;
      &lt;li&gt;接收Observation Ot&lt;/li&gt;
      &lt;li&gt;接受reward Rt&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;environment：
    &lt;ul&gt;
      &lt;li&gt;接收动作 At&lt;/li&gt;
      &lt;li&gt;发射Observation O(t+1)&lt;/li&gt;
      &lt;li&gt;发射reward R(t+1)&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;进入下一时刻 t+1 ，重复1，2，3步骤。&lt;/li&gt;
&lt;/ol&gt;

对于整个过程下来， 最后就会得到一个observation，action，reward组成的序列 Ht= O1,R1,A1,…At-1，Ot，Rt. &lt;br /&gt;
环境分为两种：

&lt;ol&gt;
  &lt;li&gt;
    fully observable Environment：这种就是agent能够直接观测到环境的状态，agent state = environment state = observation :    &lt;br /&gt;
&lt;img src=&quot;/images/rel2/OAEstate.gif&quot; alt=&quot;allequal&quot; /&gt;  &lt;br /&gt;
 这种情况下，就是一个马尔科夫决策过程(Markov decision process, MDP)。
  &lt;/li&gt;
  &lt;li&gt;
    partial observable Environment：agent不能直接观测到环境的状态，所以agent 和environment的状态不同。
  &lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&quot;策略policy&quot;&gt;策略，policy&lt;/h3&gt;

 policy，是一个智能体的行为，是从 state 到 action 的映射，表示在某状态下采取的动作的概率分布。&lt;br /&gt;
 a = π(s)

&lt;h3 id=&quot;值函数-value-function&quot;&gt;值函数, value function&lt;/h3&gt;

  value function，是对未来reward的预测，用来评估当前状态的好坏。&lt;br /&gt;
  &lt;img src=&quot;/images/rel2/vs.png&quot; alt=&quot;vs&quot; /&gt;

</description>
        <pubDate>Mon, 10 Oct 2016 12:43:08 +0000</pubDate>
        <link>https://chengjunwen.github.io/2016/10/10/reinforcement_learning_1/</link>
        <guid isPermaLink="true">https://chengjunwen.github.io/2016/10/10/reinforcement_learning_1/</guid>
        
        
        <category>强化学习</category>
        
      </item>
    
  </channel>
</rss>
