theano篇

theano

---

• theano.tensor.matrix(name=None,dtype=config.floatX)：返回一个2维ndarry变量。
• theano.tensor.matrix(name=None,dtype=config.floatX)：返回一个3维的ndarry变量。
• theano.tensor里有scalar(一个数据点),vector(向量),matrix(矩阵),tensor3(三维矩阵),tensor4(四维矩阵)。
  1.theano.dimshuffle:改变输入维度的顺序，返回原始变量的一个view。输入是一个包含[0, 1, ..., ndim - 1]和任意数目的'x'的组合：
  则：
  • .dimshuffle('x')：将标量变成1维数组
  • .dimshuffle(0, 1)：与原始的2维数组相同
  • .dimshuffle(1, 0)：交换2维数组的两个维度，形状从N * M 变成M * N
  • .dimshuffle('x', 0)：形状从N变成1 * N
  • .dimshuffle(0, 'x')：形状从N变成N * 1
  • .dimshuffle(2, 0, 1)：形状从A * B * C变成C * A * B
• .dimshuffle(0, 'x', 1)：形状从A * B变成A * 1 * B
• .dimshuffle(1, 'x', 0)：形状从A * B变成B * 1 * A
• .dimshuffle(1,)：将第0维去掉，除去的维度大小必须为1。形状从1 * A变成A
  2.theano.tnesor.concatenate:拼接

import theano
import numpy as np
import theano.tensor as T
ones = theano.shared(np.float32([[1, 2, 3], [4, 5, 6],[7, 8, 9]]))
print(ones.get_value())
--->>[[1, 2, 3]
      [4, 5, 6]
      [7, 8, 9]]
result = T.concatenate([ones,ones], axis=0)
print(result.eval())
--->>
[[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]]
result = T.concatenate([ones, ones], axis=1)
print(result.eval())
--->>
[[ 1.  2.  3.  1.  2.  3.]
 [ 4.  5.  6.  4.  5.  6.]
 [ 7.  8.  9.  7.  8.  9.]]

当操作数为二维数组时，axis=0为第一维的方向，axis=1为第二维的方向。
3.theano.tensor.dot(a, b, axes):矩阵乘法

import theano
import numpy as np
import theano.tensor as T
ones = theano.shared(np.float32([[1, 2, 3],[4, 5, 6], [7, 8, 9]]))
print(ones.get_value())
--->>
[[ 1.  2.  3.]
 [ 4.  5.  6.]
 [ 7.  8.  9.]]
result = T.dot(ones, ones)
print(result.eval())
--->>
[[  30.   36.   42.]
 [  66.   81.   96.]
 [ 102.  126.  150.]]

4.theano.gradient.grad_clip(x,lower_bound,upper_bound)：梯度裁剪
其中x是想要进行梯度裁剪的输入，lower_bround,upper_bound表示梯度的上限和下限。
5.theano.tensor.le(a,b)：返回a,b中较小的值a<=b
6.theano.tensor.gt(a,b)：返回逻辑上大于的值，表示为'int8'的tensor, 也可以用来表示语法a>b
7.theano.tensor.lt(a,b)：返回逻辑上较小的值，表示为一个'int8'的tensor，也可以用来表示语法a < b

---

2018-05-24

1.theano.tensor.switch(cond,ift,iff)：满足条件(cond)输出x, 不满足输出y.
2.theano.scan(fn, sequences=None, outputs_info=None, non_sequences=None, n_steps=None, truncate_gradient=-1, go_backwards=False, mode=None, name=None, profile=False, allow_gc=None, strict=False)

• fn是一个lambda或者def函数，描述了一步scan操作的运算式，运算式是的输入参数按照sequences,outputs_info,non_sequences的顺序，运算式的输出作为theano.scan的返回值。
• sequences: sequences是一个theano variables或者dictionaries的列表。字典对象的结构为{‘variable’：taps}，其中taps是一个整数列表。’sequences’列表中的所有Theano variable会被自动封装成一个字典，此时taps被设置成[0]。比如sequences = [ dict(input= Sequence1, taps = [-3,2,-1]), Sequence2， dict(input = Sequence3, taps = 3) ]， 映射到scan输入参数为Sequence1[t-3]，Sequence1[t+2]，Sequence1[t-1]，Sequence2[t]，Sequence3[t+3]。还有一点就是，如果序列的长度不一致，scan会裁剪成它们中最短的，这个性质方便我们传递一个很长的arange，比如sequences=[coefficients, theano.tensor.arange(max_coefficients_supported)]。
• outputs_info：outputs_info是一个theano variables或者dictionaries的列表，它描述了输出的初始状态，显然应该和输出有相同的shape，而且，每进行一步scan操作，outputs_info中的数值会被上一次迭代的输出值更新掉。当然，如果当前循环结构不需要recursive，而仅仅是一个map操作的话，这个参数便可以省略；
• non_sequences：non_sequences 是一个‘常量’参数列表，这里所谓的‘常量’是相对于‘outputs_info’中的参数更新而言的，代表了一步scan操作中不会被更新的变量。计算图中的有些变量在这里也可以不显式的指明，但显式指明变量参数会得到一个简化的计算图，加速编译器对图的优化和执行。 常见的应用是，把shared variables作为non_sequences参数中的值.
• n_steps：n_steps参数是一个int或者theano scalar，代表了scan操作的迭代次数。如果存在输入序列，其中的元素个数小于n_steps，scan函数会报错。如果n_steps参数未指定，scan会根据他的输入参数自动计算出迭代步数；
• truncate_gradient：truncate_gradient参数代表了使用BPTT（back propagation through time）算法时，“梯度截断”后的步数。“梯度截断”的目的是在可接受的误差范围内，降低梯度的计算复杂度。常见的应用场景是RNN（recurrent neural network；
• strict：strict是一个shared variable校验标志，用于检验是否fn函数用到的所有shared variabes都在non_sequences中，若不满足则会Raise an error。
• 返回参数：
  形如（outputs, updates）格式的元组类型。outputs是一个theano变量，或者多个theano变量构成的list。并且，每一个theano变量包含了所有迭代步骤的输出结果。updates是形如（var, expression）的字典结构，指明了scan中用到的所有shared variables的更新规则 。
  例如，给定K，想要计算a**k，利用python可以写成：

result = 1
for i in range(k):
    result = result * A

使用theano.scan():
在此我们有三件事需要处理：第一，分配初始值result，第二是result值得计算，第三就是unchanging变量A，不变的变量传递给no_sequences。

import theano
import theano.tensor as T

k = T.iscalar("k")
A = T.vector("A")

# Symbolic description of the result
result, updates = theano.scan(fn=lambda prior_result, A: prior_result * A,
                              outputs_info=T.ones_like(A),
                              non_sequences=A,
                              n_steps=k)
# we only care about A**k, but scan has provided us with A**1 through A**k,
# Discard the values that we don't care about. Scan is smart enough to
# notice this and not waste memory saving them.
final_result = result[-1]
# compiled function that returns A**k
power = theano.function(inputs=[A, k], outputs=final_result, updates=updates)

print(power(range(3), 2))
#===>[ 0.  1.  4.]

---

2018-06-11

1.theano.tensor常用的数据类型

• 学习theano，首先要学的就是theano.tensor使用，其实基础数据结构，功能类似于python.numpy。在theano.tensor数据类型中，有double、int、uchar、float等各种类型，不过我们最常用的地int和float类型，float是因为GPU一般是float32类型，所以在编写程序的时候，我们很少用到double，常用的数据类型如下：
• 数值：
    iscalar(int类型的变量)、fscalar(float类型的变量)
   一维向量:ivector(int 类型的向量)，fvector(float类型的向量）
   二维矩阵:fmatrix(float类型的矩阵)，imatrix(int类型的矩阵)
   三维float类型矩阵:ftensor3
   四维float类型矩阵:ftensor4
  其他类型只要首字母变一下就可以了。
  2.theano编程风格
• 在以前的编程方法中，我们一般先为自变量赋值，然后在把这个自变量作为函数的输入，进行计算因变量。然而在theano中，我们一般是先声明自变量x(不需要赋值)，然后编写函数方程结束后，最后为自变量赋值，计算出函数的输出值y，比如我们要计算“2的3次方”，一般写成下面的格式：

import theano
x = theano.tensor.iscalar('x')# 声明一个int类型的变量x
y = theano.tensor.pow(x,3)# 定义y=x^3
f = theano.function([x],y)# 定义函数的自变量为x(输入),因变量为y(输出)
print(f(2))# 计算当x=2的时候，函数f(x)的值

example:

import theano
import theano.tensor as T

a = T.matrix()
b = T.matrix()
e = T.fscalar()
c = a * b
d = T.dot(a, b)
g = T.ivector()
f = g * e
f1 = theano.function([a, b], c)
f2 = theano.function([a, b], d)
f3 = theano.function([g, e], f)
A = [[1, 2], [3, 4]]# 2*2的矩阵
B = [[2, 4], [6, 8]]# 2*2的矩阵
C = [[1, 2], [3, 4], [5, 6]]# 3*2的矩阵
G = [1, 2, 3, 4]
print(f1(A, B))
print(f2(A, B))
# print(f1(C, B))
print(f2(C, B))
print(f3(G, 0.5))

输出为：

[[  2.   8.]
 [ 18.  32.]]
[[ 14.  20.]
 [ 30.  44.]]
[[ 14.  20.]
 [ 30.  44.]
 [ 46.  68.]]
[ 0.5  1.   1.5  2. ]

注意：函数输入必须是List带[ ]