Tensorflow学习随手记（二）

95 阅读 0 评论 63 点赞

我是靠谱客的博主沉默音响，这篇文章主要介绍Tensorflow学习随手记（二），现在分享给大家，希望可以做个参考。

1,Tensorflow激励方程

activation_function,

使用激励函数，用于解决现实生活中，不能用线性方程解决的问题。

常见的激励方程如下：

（看到这个图片，想起了以前学习电路的是那些个方程，果断机电一家亲）。

一个典型的Tensorflow的结构示意图如下

以Layer2为例

图中 relu即为激励函数，即经过激励函数，小于0的输入，变成0输出；大于0的输入，仍然保持不变。

根据上图所示，首先定义一个添加层的方法

代码示例如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#定义添加层，
def add_layer(inputs,in_size,out_size,activation_function = None):
#添加层的结构如下：
#1，定义权重Wegihts，其值为in_size行、out_size列的随机矩阵
    Weights = tf.Variable(tf.random_normal([in_size,out_size]));
#2，定义偏置biases，其值为1行、out_size列的随机矩阵，避免出现0的情况，加上一个0.1
    biases = tf.Variable(tf.zeros([1,out_size])+0.1);
#3，定义计算结果 y = w * x + biases;
    Wx_plus_b = tf.matmul(inputs,Weights) + biases;
#4，计算输出
    if activation_function is None:
        outputs = Wx_plus_b;
    else:
        outputs = activation_function(Wx_plus_b);
#5，返回输出
    return outputs;

这样添加layer的方法定义完成

定义整个神经网络：

代码示例如下

复制代码

#使用add_layer
#创造数据
x_data = np.linspace(-1,1,300)[:,np.newaxis];
noise = np.random.normal(0,0.05,x_data.shape);
y_data = np.square(x_data)-0.5 + noise;

#定义占位符用于不同层之间的数据传递
xs = tf.placeholder(tf.float32,[None,1]);
ys = tf.placeholder(tf.float32,[None,1]);

#定义隐藏层,
#隐藏层假设有10个神经元，x_data目前只有一个属性
l1 = add_layer(xs,1,10,activation_function=tf.nn.relu);
product = add_layer(l1,10,1,activation_function=None);

#定义误差
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-product),reduction_indices=[1]));

#定义训练
train = tf.train.GradientDescentOptimizer(0.1).minimize(loss);

#初始化变量
init = tf.global_variables_initializer();
sess = tf.Session();
sess.run(init);

#定义一个画布
fig = plt.figure();
ax = fig.add_subplot(1,1,1);
ax.scatter(x_data,y_data);
plt.ion();#防止调show方法后，阻塞程序运行
plt.show();

#开始实际训练
for i in range(1000):
    sess.run(train,feed_dict={xs:x_data,ys:y_data});
    if i%50 == 0:
        #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}));
        try:
            ax.lines.remove(lines[0]);
        except Exception:
            pass;
        prediction_value = sess.run(product,feed_dict={xs:x_data});
        lines = ax.plot(x_data,prediction_value,'r-',lw=5);
        plt.pause(0.5);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#使用add_layer
#创造数据
x_data = np.linspace(-1,1,300)[:,np.newaxis];
noise = np.random.normal(0,0.05,x_data.shape);
y_data = np.square(x_data)-0.5 + noise;

#定义占位符用于不同层之间的数据传递
xs = tf.placeholder(tf.float32,[None,1]);
ys = tf.placeholder(tf.float32,[None,1]);

#定义隐藏层,
#隐藏层假设有10个神经元，x_data目前只有一个属性
l1 = add_layer(xs,1,10,activation_function=tf.nn.relu);
product = add_layer(l1,10,1,activation_function=None);

#定义误差
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-product),reduction_indices=[1]));

#定义训练
train = tf.train.GradientDescentOptimizer(0.1).minimize(loss);

#初始化变量
init = tf.global_variables_initializer();
sess = tf.Session();
sess.run(init);

#定义一个画布
fig = plt.figure();
ax = fig.add_subplot(1,1,1);
ax.scatter(x_data,y_data);
plt.ion();#防止调show方法后，阻塞程序运行
plt.show();

#开始实际训练
for i in range(1000):
    sess.run(train,feed_dict={xs:x_data,ys:y_data});
    if i%50 == 0:
        #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}));
        try:
            ax.lines.remove(lines[0]);
        except Exception:
            pass;
        prediction_value = sess.run(product,feed_dict={xs:x_data});
        lines = ax.plot(x_data,prediction_value,'r-',lw=5);
        plt.pause(0.5);

整个神经网络编写完成。运行后，出现如下结果

可以看到，Tensorflow的整个过程，是使红线的走向不断接近散点（蓝色）所展示出来的趋势。

整个代码示例如下：

复制代码

#导入tensorflow包
import tensorflow as tf;
import numpy as np;
import matplotlib.pyplot as plt;

#定义添加层，
def add_layer(inputs,in_size,out_size,activation_function = None):
#添加层的结构如下：
#1，定义权重Wegihts，其值为in_size行、out_size列的随机矩阵
    Weights = tf.Variable(tf.random_normal([in_size,out_size]));
#2，定义偏置biases，其值为1行、out_size列的随机矩阵，避免出现0的情况，加上一个0.1
    biases = tf.Variable(tf.zeros([1,out_size])+0.1);
#3，定义计算结果 y = w * x + biases;
    Wx_plus_b = tf.matmul(inputs,Weights) + biases;
#4，计算输出
    if activation_function is None:
        outputs = Wx_plus_b;
    else:
        outputs = activation_function(Wx_plus_b);
#5，返回输出
    return outputs;

#使用add_layer
#创造数据
x_data = np.linspace(-1,1,300)[:,np.newaxis];
noise = np.random.normal(0,0.05,x_data.shape);
y_data = np.square(x_data)-0.5 + noise;

#定义占位符用于不同层之间的数据传递
xs = tf.placeholder(tf.float32,[None,1]);
ys = tf.placeholder(tf.float32,[None,1]);

#定义隐藏层,
#隐藏层假设有10个神经元，x_data目前只有一个属性
l1 = add_layer(xs,1,10,activation_function=tf.nn.relu);
product = add_layer(l1,10,1,activation_function=None);

#定义误差
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-product),reduction_indices=[1]));

#定义训练
train = tf.train.GradientDescentOptimizer(0.1).minimize(loss);

#初始化变量
init = tf.global_variables_initializer();
sess = tf.Session();
sess.run(init);

#定义一个画布
fig = plt.figure();
ax = fig.add_subplot(1,1,1);
ax.scatter(x_data,y_data);
plt.ion();#防止调show方法后，阻塞程序运行
plt.show();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#导入tensorflow包
import tensorflow as tf;
import numpy as np;
import matplotlib.pyplot as plt;

#定义添加层，
def add_layer(inputs,in_size,out_size,activation_function = None):
#添加层的结构如下：
#1，定义权重Wegihts，其值为in_size行、out_size列的随机矩阵
    Weights = tf.Variable(tf.random_normal([in_size,out_size]));
#2，定义偏置biases，其值为1行、out_size列的随机矩阵，避免出现0的情况，加上一个0.1
    biases = tf.Variable(tf.zeros([1,out_size])+0.1);
#3，定义计算结果 y = w * x + biases;
    Wx_plus_b = tf.matmul(inputs,Weights) + biases;
#4，计算输出
    if activation_function is None:
        outputs = Wx_plus_b;
    else:
        outputs = activation_function(Wx_plus_b);
#5，返回输出
    return outputs;

#使用add_layer
#创造数据
x_data = np.linspace(-1,1,300)[:,np.newaxis];
noise = np.random.normal(0,0.05,x_data.shape);
y_data = np.square(x_data)-0.5 + noise;

#定义占位符用于不同层之间的数据传递
xs = tf.placeholder(tf.float32,[None,1]);
ys = tf.placeholder(tf.float32,[None,1]);

#定义隐藏层,
#隐藏层假设有10个神经元，x_data目前只有一个属性
l1 = add_layer(xs,1,10,activation_function=tf.nn.relu);
product = add_layer(l1,10,1,activation_function=None);

#定义误差
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-product),reduction_indices=[1]));

#定义训练
train = tf.train.GradientDescentOptimizer(0.1).minimize(loss);

#初始化变量
init = tf.global_variables_initializer();
sess = tf.Session();
sess.run(init);

#定义一个画布
fig = plt.figure();
ax = fig.add_subplot(1,1,1);
ax.scatter(x_data,y_data);
plt.ion();#防止调show方法后，阻塞程序运行
plt.show();

#开始实际训练
for i in range(1000):
    sess.run(train,feed_dict={xs:x_data,ys:y_data});
    if i%50 == 0:
        #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}));
        try:
            ax.lines.remove(lines[0]);
        except Exception:
            pass;
        prediction_value = sess.run(product,feed_dict={xs:x_data});
        lines = ax.plot(x_data,prediction_value,'r-',lw=5);
        plt.pause(0.5);