第一节，基础知识之第一步：代数

先声明：theano模块的内容大都是参考来源于网上，并亲手实践复现一遍，也有部分内容是自己补充

本文会列出所参考文章，如有版权问题，请联系我，我会及时删除

# -*- coding: utf-8 -*-
"""
Created on Fri Mar 23 13:33:20 2018

@author: zy
"""

‘‘‘
x= T.dscalar(‘x‘)
y= T.dscalar(‘y‘)
z = x + y
f = theano.function([x,y],z)
调用re = f(2,3)
函数输出的结果re：每个元素的类型，一般和该函数输入传入的符号变量类型(x,y)一致 并且该结果的类型为numpy.ndarray
函数f传入参数时可以传入比float64长度小的数据类型，比如int32
但是反过来不行 x= T.iscalar(‘x‘) f(2.2,3)会报错
‘‘‘

‘‘‘
Theano2.1.2-基础知识之第一步：代数
http://www.cnblogs.com/shouhuxianjian/p/4590234.html
‘‘‘

import theano.tensor as T
import theano

‘‘‘
一.两个标量相加
‘‘‘
#在学习theano开始，首先来感受下它是怎么工作的，让我们定义一个简单的相加函数
x= T.dscalar(‘x‘)
y= T.dscalar(‘y‘)
z = x + y
f = theano.function([x,y],z)

#然后我们就可以开始使用创建好的函数了
print(f(2,3))                 #5.0  5.0为float64数据类型dscalar一致
print(type(f(1.0,2.3)))       #<class ‘numpy.ndarray‘>
print(f(1.0,2.3))             #3.3    

‘‘‘
这里首先把上面部分进行分布介绍，首先定义连个符号(变量),表示你想要相加的数。注意从现在开始，我们将会
使用变量(variable)来表示‘符‘(换句话说，就是x,y,z都是变量对象)，函数f就是一个有着0维的numpy.ndarray

如果你想要一个整数，你可能会发现在执行function的时候有轻微的延时，这是一位将函数f编译为C代码
‘‘‘

#第一步
x = T.dscalar(‘x‘)
y = T.dscalar(‘y‘)

‘‘‘
在theano中，所有的符号都必选手动输入。具体来说，T.dscalar就是我们分配给‘doubles类型(d)的0维数组(scalar)‘
类型，这就是一个theano类型。

dscalar不是一个类，所以x,y都不是dscalar的实例。他们是TensorVariable的实例，正如你所看到的
‘‘‘
print(type(x))             #<class ‘theano.tensor.var.TensorVariable‘>
print(x.type)              #TensorType(float64, scalar)
print(T.dscalar)           #TensorType(float64, scalar)

‘‘‘
通过一个字符串参数来调用T.dscalar，可以创建一个变量便是一个给定名字下的一个浮点标量。如果不提供参数，
该符号将会是一个未命名的。虽然名字不是必须的，但是却有助于调试。
‘‘‘

#第二步
‘‘‘
结合x与y得到他们的和z
‘‘‘
z = x + y

#z是另一个变量，同来表示x与y的和，你可以使用pp函数打印出与z关联的计算结果
from theano import pp
print(pp(z))      #(x + y)

#第三步
‘‘‘
创建一个函数，将x与y作为输入，然后通过z作为输出
function():http://deeplearning.net/software/theano/library/compile/function.html#module-function
‘‘‘
f = theano.function([x,y],z)

‘‘‘
function第一个参数是变量的列表，用来作为输入提供给函数。第二个参数是一个单一的变量或者一个变量列表。
在其它情况下，第二个参数就是我们想要的输出。然后f可以被和普通python函数一样的是用了

note：作为了一个快捷方式，你就可以跳过第三步，只使用一个变量的eval方法。eval()方法没有function()这么灵活，
不过却能做教程中的任何事情。如果你不需要import function()的额外的福利，下面就是eval()工作的过程
‘‘‘
w = z.eval({x:16.3,y:12.1})
print(w)    #28.4

‘‘‘
我们给eval()传递一个dict,将符号theano遍历映射成值从而来取代他们。然后对表达式计算返回数值
val() 在第一次调用的时候可能会比较慢，因为它需要调用 function() 来计算场景后面的表达式。之后对
eval() 以同样的变量上的调用将会很快，因为变量已经将编译后的函数进行缓存了。
‘‘‘

‘‘‘
二.两个矩阵相加
‘‘‘

#你可能已经猜到如何来作了，确实这里和之前的唯一的区别在于你需要实例化x与y，然后使用矩阵类型
x= T.dmatrix(‘x‘)
y= T.dmatrix(‘y‘)
z = x + y
f = theano.function([x,y],z)
print(x.type)          #TensorType(float64, matrix)  

#dmatrix是doubles类型的矩阵，然后我们就能在2D数组上使用新的函数了
a1 = [[1,2],[3,4]]
b1 = [[10,20],[30,40]]
re = f(a1,b1)
print(re)              #[[ 11.  22.],[ 33.  44.]]
print(type(re))        #<class ‘numpy.ndarray‘>
print(re.dtype)        #float64

#输出值f是一个numpy.ndarray数组，我们可以直接使用numpy.ndarray作为输入
import numpy as np
re=f(np.array([[1,2],[3,4]]),np.array([[10,20],[20,40]]))
print(re)              #[[ 11.  22.],[ 33.  44.]]
print(type(re))        #<class ‘numpy.ndarray‘>
print(re.dtype)        #float64

‘‘‘
计算矩阵加标量，矩阵加向量，向量加标量都是可以的，这都要归功于braodcasting：http://deeplearning.net/software/theano/library/tensor/basic.html#libdoc-tensor-broadcastable

下面的类型都是可用的：
byte: bscalar, bvector, bmatrix, brow, bcol, btensor3, btensor4
16-bit integers: wscalar, wvector, wmatrix, wrow, wcol, wtensor3, wtensor4
32-bit integers: iscalar, ivector, imatrix, irow, icol, itensor3, itensor4
64-bit integers: lscalar, lvector, lmatrix, lrow, lcol, ltensor3, ltensor4
float: fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4
double: dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4
(
float32: scalar, vector, matrix, row, col, tensor3, tensor4
float32: fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4
double(float64): dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4
)
complex: cscalar, cvector, cmatrix, crow, ccol, ctensor3, ctensor4
上面的列表不够详尽，针对使用Numpy数组来兼容所有类型的更详细文档可以看: tensor creation：http://deeplearning.net/software/theano/library/tensor/basic.html#libdoc-tensor-creation

‘‘‘

‘‘‘
三.练习
‘‘‘

a1 = T.vector()                   #定义一个变量
print(a1.type)                    #TensorType(float32, vector)
out1 = a1 + a1**2                 #表达式
f1 = theano.function([a1],out1)   #编译函数
r1 = f1([0,1,2])
print(r1,r1.dtype)                 #[ 0.  2.  6.] float32

a2 = T.fvector()                    #定义一个变量
print(a2.type)                      #TensorType(float32, vector)
out2 = a2 + a2**2                   #表达式
f2 = theano.function([a2],out2)     #编译函数
r2 = f2([0,1,2])
print(r2,r2.dtype)                 #[ 0.  2.  6.] float32

a3 = T.dvector()                    #定义一个变量
print(a3.type)                      #TensorType(float64, vector)
out3 = a3 + a3**2                   #表达式
f3 = theano.function([a3],out3)     #编译函数
r3 = f3([0,1,2])
print(r3,r3.dtype)                 #[ 0.  2.  6.] float64

‘‘‘
从上面练习可以看出

float32: scalar, vector, matrix, row, col, tensor3, tensor4
float32: fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4
double(float64): dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4

‘‘‘

a4 = T.iscalar(‘x‘) #TensorType(int32, scalar)
print(a4.type)
b4 = T.scalar(‘y‘) #TensorType(float32, scalar)
print(b4.type)
out4 = a4*b4
f4 = theano.function([a4,b4],out4)
r4 = f4(10,12)
print(r4) #120.0
print(r4.dtype) #float64
‘‘‘
我们可以看到乘积的类型变成了float64
‘‘‘

原文地址：https://www.cnblogs.com/zyly/p/8631256.html