Theano学习


阅读数: 次   
× 文章目录
  1. 1. 一、Theano概述
    1. 1.1. 1、介绍
    2. 1.2. 2、安装
  2. 2. 二、Theano基础
    1. 2.1. 1、基本用法
    2. 2.2. 2、function用法
    3. 2.3. 3、Shared变量
    4. 2.4. 4、Theano中的激励函数
  3. 3. 三、搭建神经网络
    1. 3.1. 1、定义Layer类或者函数
    2. 3.2. 2、一个神经网络例子
    3. 3.3. 3、保存和提取模型

一、Theano概述

1、介绍

  • Theano 是神经网络python机器学习的模块，和 Tensowflow 类似
  • 可以在MacOS、Linux、Windows上运行
  • theano 可以使用 GPU 进行运算
  • 网址：http://deeplearning.net/software/theano/

2、安装

  • Windows上直接：pip install theano
    • 可能提示个警告：WARNING (theano.configdefaults): g++ not detected ! Theano will be unable to execute optimized C-implementations (for both CPU and GPU) and will default to Python implementations. Performance will be severely degraded. To remove this warning, set Theano flags cxx to an empty string.

二、Theano基础

1、基本用法

  • 导入包

    1
    2
    3
    import numpy as np
    import theano.tensor as T
    from theano import function

  • 常量和方程定义

    1
    2
    3
    4
    x = T.dscalar('x')  # 建立 x 的容器
    y = T.dscalar('y')  # 建立 y 的容器
    z = x + y           # 建立方程
    f = function([x, y],z) # 使用function定义方程，将输入值 x, y 放在 [] 里,  输出值 z 放在后面

  • pretty print打印原始方程

    • 导入包：from theano import pp
    • 打印即可：print(pp(z))
  • 矩阵相乘
    1
    2
    3
    4
    5
    6
    7
    x = T.dmatrix('x')  # float64的矩阵,fmatrix对应float32
    y = T.dmatrix('y')
    z = T.dot(x,y)      # 相乘
    f = function([x,y],z)  # 定义function
    print(f(np.arange(12).reshape(3,4),
          np.ones((4,3))))
    print(pp(z))

输出：

1
2
3
4
[[  6.   6.   6.]
 [ 22.  22.  22.]
 [ 38.  38.  38.]]
(x \dot y)

2、function用法

  • theano 当中的 function 就和 python 中的 function类似，但是在theano中由于涉及到GPU加速以及CPU的并行的运算，所以他的function会有不同。

  • 多输入和多输出

    1
    2
    3
    4
    5
    6
    7
    8
    a,b = T.dmatrices('a','b')   # 定义两个容器
    diff = a - b
    abs_diff = abs(diff)         # 绝对值
    diff_square = diff ** 2      
    f = function([a,b],[diff,abs_diff,diff_square])  # function同样前面指定输入，后面是输出
    x1,x2,x3 = f(np.ones((2,2)),
                 np.arange(4).reshape(2,2))
    print(x1,x2,x3)

  • 指定function默认值和名字name

    1
    2
    3
    4
    5
    6
    7
    8
    9
    x,y,z = T.dscalars('x','y','z')  # 定义三个scalar容器
    w = (x + y) * z
    f = function([x,
                  theano.In(y,value=1),  # 输入y,默认值为1
                  theano.In(z,value=2,name='weights')], # 输入z,默认值为2，同时指定名字为weights，后面可以通过名字复制
                 w)
    print(f(2))         # 使用默认值
    print(f(2,2,3))     # 指定值
    print(f(2,2,weights=3)) # 通过name赋值

3、Shared变量

  • Shared 变量，意思是这些变量可以在运算过程中，不停地进行交换和更新值。 在定义 weights 和 bias 的情况下，会需要用到这样的变量
  • 定义shared变量
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    state = theano.shared(np.array(0,dtype=np.float64), name='state')  # state初值为0，为float64
    increase = T.scalar('increase',dtype=state.dtype)   # 定义一个容器，这里注意dtype为state.dtype,若是np.float64会报错
    accmulator = theano.function([increase],   # 输入
                                 state,        # 输出
                                 updates=[(state,state+increase)]) # 指定每次更新为累加
    print(state.get_value())# get_value()获取值
    accmulator(1)
    print(state.get_value())
    state.set_value(-1)     # set_value()设置值
    accmulator(1)
    print(state.get_value())

输出：

1
2
3
0.0
1.0
0.0

  • 临时使用shared变量
    1
    2
    3
    4
    5
    6
    7
    8
    9
    state = theano.shared(np.array(0,dtype=np.float64), name='state')  # state初值为0，为float64
    increase = T.scalar('increase',dtype=state.dtype)   # 定义一个容器，这里注意dtype为state.dtype,若是np.float64会报错
    tmp_func = state *2 +increase
    a = T.scalar(dtype=state.dtype)   # 定义标量a，后面用来带起state
    skip_shared = theano.function([increase,a],
                                  tmp_func,
                                  givens=[(state,a)])   # 指定givens参数用a代替state
    print(skip_shared(2,3))
    print(state.get_value())  # 输出state还是0

4、Theano中的激励函数

  • sigmoid: theano.tensor.nnet.nnet.sigmoid(x)
  • 还有relu,tanh,softmax,softplus等
  • 在隐含层中常用relu,tanh,softplus等非线性激励函数
  • 在输出层常用sigmoid，softmax求概率

三、搭建神经网络

1、定义Layer类或者函数

  • 以后想这样直接使用：

    1
    2
    l1 = Layer(inputs,1,10,T.nnet.relu)
    l2 = Layer(l1.outputs,10,1,None)

  • 实现代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    import theano
    import theano.tensor as T
    import numpy as np
    class Layer(object):
        def __init__(self,inputs,in_size,out_size,activation_function=None):
            self.W = theano.shared(np.random.normal(0,1,(in_size,out_size)))  # 使用高斯函数初始化，大小为in_size*out_size
            self.b = theano.shared(np.zeros(out_size) + 0.1)                  # 指定偏置，大小为out_size，注意+0.1在shared内，否则使用会报错
            self.Wx_plus_b = T.dot(inputs,self.W) + self.b
            self.activation_function = activation_function
            if activation_function is None:
                self.outpus = self.Wx_plus_b
            else:
                self.outputs = self.activation_function(self.Wx_plus_b)

  • 指定构造函数的参数：inputs,in_size,out_size,activation_function

2、一个神经网络例子

  • 制造数据

    1
    2
    3
    4
    5
    6
    '''制造假数据，并显示'''
    x_data = np.linspace(-1,1,300)[:,np.newaxis]  # [:,np.newaxis]是将(300,)转为(300,1),增加一个维度，将列表转化为矩阵
    noise = np.random.normal(0,0.05,x_data.shape)
    y_data = np.square(x_data) -0.5 + noise
    plt.scatter(x_data,y_data)
    plt.show()

  • 定义输入，相当于TensorFlow中的placeholder，后面传入真实数据

    1
    2
    x = T.dmatrix('x')
    y = T.dmatrix('y')

  • 定义网络，使用上面定义的Layer

    1
    2
    l1 = Layer(x, 1, 10,T.nnet.relu)
    l2 = Layer(l1.outputs,10,1,None)

  • 定义cost,并且计算其梯度

    1
    2
    cost = T.mean(T.square(l2.outputs-y))
    g_w1,g_b1,g_w2,g_b2 = T.grad(cost, [l1.W,l1.b,l2.W,l2.b])

  • 使用theano中的function进行梯度下降

    1
    2
    3
    4
    5
    6
    7
    8
    9
    learning_rate = 0.05
    '''调用function，使用梯度下降求解'''
    train = theano.function(inputs=[x,y],
                            outputs=cost,
                            updates=[(l1.W, l1.W - learning_rate * g_w1),
                                     (l1.b, l1.b - learning_rate * g_b1),
                                     (l2.W, l2.W - learning_rate * g_w2),
                                     (l2.b, l2.b - learning_rate * g_b2)]
                            )

  • 传入之前制造的数据训练

    1
    2
    3
    4
    for i in range(1000):
        err = train(x_data,y_data)  # 训练，传入真实数据
        if i%50 == 0:
            print(err)

  • 预测

    1
    2
    '''预测，输入为x，输出为layer2的输出'''
    prediction = theano.function([x],l2.outputs)

  • 计算准确度函数

    1
    2
    3
    4
    def compute_accuracy(y_target,y_predict):
        correct_prediction = np.equal(y_target,y_predict)
        accuracy = np.sum(correct_prediction)/len(correct_prediction)
        return accuracy

3、保存和提取模型

  • 导入包：import pickle

  • 保存模型–即学到的参数权重和偏置

    1
    2
    3
    4
    5
    6
    7
    8
    '''保存神经网络--保存学到的参数'''
    with open('model.pickle', mode='wb') as file:
        #model = [l1.W.get_value(),l1.b.get_value(),
        #         l2.W.get_value(),l2.b.get_value()]
        model = {'layer1_w':l1.W.get_value(),'layer1_b':l1.b.get_value(),
                 'layer2_w':l2.W.get_value(),'layer2_b':l2.b.get_value()}    # 保存为字典形式，通过get_value()获取值
        pickle.dump(model, file)
        print(model['layer1_w'])

  • 提取模型

    1
    2
    3
    4
    with open('model.pickle','rb') as file:
        model = pickle.load(file)
        l1.W.set_value(model['layer1.w'])    # 通过set_value()将值设置进去
        ...
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码
本站总访问量次 总访客数人次

tag:

    缺失模块。
    1、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    2、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: true
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序猿👨🏻‍💻