Skip to content

Tensorflow基础

Jump to bottom
qiufeihu edited this page May 21, 2017 · 1 revision

Tensorflow

目录：

  1. 安装
  2. 编写一个简单例子
  3. 介绍这个例子
  4. 数据可视化
  5. 解决过拟合
  6. 卷积神经网络
  7. 循环神经网络
  8. 保存

一，安装

准备：

1.安装Python 3.6以上

Python下载地址

Python不熟的建议先学习：

最简单： 莫烦Python

最详细： 廖雪峰Python3教程

2.安装Numpy和Pandas

pip3 install numpy

pip3 install pandas

莫烦Numpy和Pandas教程

3.安装matplotlib

pip3 install matplotlib

莫烦Matplotlib教程

4.安装scikit-learn

pip3 install -U scikit-learn

3.安装Tensorflow

安装：

pip3 install tensorflow

卸载：

pip3 uninstall tensorflow

二，一个简单的小例子

import tensorflow as tf
import numpy as np

# 创建样本数据 y = x*0.1+0.3; y = x*a+b;
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data*0.1+0.3

print(x_data)
print(y_data)

# for i in range(x_data.size):
#     print('x=',x_data[i],",",'y=',y_data[i])

### create tensorflow structure start ###
# 随机数列，一维结构，范围-1到1 Weight相当于a
Weights = tf.Variable(tf.random_uniform([1],-0.1,1.0))

#初始值是0,biases相当于b,从初始值不断提升
biases = tf.Variable(tf.zeros([1]))

print("Weights:")
print(Weights)
print("biases:")
print(biases)

#预测y
y = x_data*Weights + biases

print("y:")
print(y)


#提升y的准确度，计算预测的y和实际的y误差是多少
loss = tf.reduce_mean(tf.square(y-y_data))


#建立一个优化器，减少误差，0.5是学习效率，小于1的一个数
optimizer = tf.train.GradientDescentOptimizer(0.5)
#每一次训练减少一次误差
train = optimizer.minimize(loss)

# 初始化变量，神经网络是一个大的图，先把网络结构做好，
# 然后我们再初始化这个结构，让他们真正的活动起来
init = tf.initialize_all_variables()

#session是一个指针，指向初始化的节点
sess = tf.Session()
# 把这个结构激活初始化，使这个链接指向一个地方
sess.run(init) #激活

# 开始让神经网络一步一步的训练
for step in range(201):
     sess.run(train)  # 指向train真正的开始训练
     #每隔20步就打印一下训练的结果
     if step % 20 == 0:
         # 输出第几步，Weights参数是多少，biases参数是多少
         print(step,sess.run(Weights),sess.run(biases))

三，添加神经层

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

#添加神经层的方法
def add_layer(inputs, in_size, out_size, activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

#-1到1，有300个例子
x_data = np.linspace(-1,1,300, dtype=np.float32)[:, np.newaxis]
#噪点，变的更像一个真实数据
noise = np.random.normal(0, 0.05, x_data.shape).astype(np.float32)
#结果
y_data = np.square(x_data) - 0.5 + noise

#所要输入的值是什么
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

#输入层，隐藏层10
l1 = add_layer(xs,1,10,activation_function=tf.nn.relu)
#输出层，隐藏层10
prediction = add_layer(l1,10,1,activation_function=None)

#求平均值
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                                    reduction_indices=[1]))
#进行练习，的优化器，以0.1的速度进行优化
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

#对所有变量进行初始化
init = tf.initialize_all_variables()
#建立连接的session
sess = tf.Session()
#进行运算
sess.run(init)

#学习1000次
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data)
plt.ion()
plt.show()

for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i % 50 == 0:
        try:
            ax.lines.remove(lines[0])
        except Exception:
           pass
         #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))
        prediction_value = sess.run(prediction, feed_dict={xs: x_data})
        # plot the prediction
        lines = ax.plot(x_data, prediction_value, 'r-', lw=5)

        plt.pause(0.2)

四，数字图像识别

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# MNIST库是手写体数字库 数据中包含55000张训练图片，每张图片的分辨率是28×28，所以我们的训练网络输入应该是28×28=784个像素数据。
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

def add_layer(inputs,in_size,out_size,activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size,out_size]))
    biases = tf.Variable(tf.zeros([1,out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs,Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

def compute_accuracy(v_xs,v_ys):
    global prediction
    y_pre = sess.run(prediction,feed_dict={xs:v_xs})
    correct_prediction = tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    result = sess.run(accuracy,feed_dict={xs:v_xs,ys:v_ys})
    return result

# 数据中包含55000张训练图片，每张图片的分辨率是28×28，所以我们的训练网络输入应该是28×28=784个像素数据。
xs = tf.placeholder(tf.float32,[None,784]) # 28x28
# 每张图片都表示一个数字，所以我们的输出是数字0到9，共10类。
ys = tf.placeholder(tf.float32,[None,10])

# 调用add_layer函数搭建一个最简单的训练网络结构，只有输入层和输出层。 其中输入数据是784个特征，输出数据是10个特征，激励采用softmax函数
prediction = add_layer(xs,784,10,activation_function=tf.nn.softmax)

# loss函数（即最优化目标函数）选用交叉熵函数。交叉熵用来衡量预测值和真实值的相似程度，如果完全相同，它们的交叉熵等于零。
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction),reduction_indices=[1]))
# train方法（最优化算法）采用梯度下降法。
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

#step
sess = tf.Session()

sess.run(tf.global_variables_initializer())

print("准确度:")
for i in range(1000):
    # 现在开始train，每次只取100张图片，免得数据太多训练太慢。
    batch_xs,batch_ys = mnist.train.next_batch(100)
    sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys})
    # 每训练50次输出一下预测精度
    if i % 50 == 0:
        print(compute_accuracy(mnist.test.images,mnist.test.labels))

五，卷积神经网络

import tensorflow as tf
from sklearn.datasets import load_digits
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import LabelBinarizer

# 加载数据
digits = load_digits()
X = digits.data
y = digits.target
y = LabelBinarizer().fit_transform(y)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=.3)

def add_layer(inputs,in_size,out_size,layer_name,activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size,out_size]))
    biases = tf.Variable(tf.zeros([1,out_size])+0.1)
    Wx_plus_b = tf.matmul(inputs,Weights)+biases
    Wx_plus_b = tf.nn.dropout(Wx_plus_b,keep_prob)

    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    tf.summary.histogram(layer_name+'/output',outputs)
    return outputs

keep_prob = tf.placeholder(tf.float32)
xs = tf.placeholder(tf.float32,[None,64])
ys = tf.placeholder(tf.float32,[None,10])

# 添隐藏层
l1 = add_layer(xs,64,100,'l1',activation_function=tf.nn.tanh)
# 输出层
prediction = add_layer(l1,100,10,'l2',activation_function=tf.nn.softmax)

# loss函数（即最优化目标函数）选用交叉熵函数。交叉熵用来衡量预测值和真实值的相似程度，如果完全相同，它们的交叉熵等于零。
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction),reduction_indices=[1]))
tf.summary.scalar('loss',cross_entropy)




# train方法（最优化算法）采用梯度下降法。
train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)

#step
sess = tf.Session()
merged = tf.summary.merge_all()
#写入文件，然后运行 tensorboard --logdir=logs
train_writer = tf.summary.FileWriter("graph/train", sess.graph)
test_writer = tf.summary.FileWriter("graph/test", sess.graph)

sess.run(tf.global_variables_initializer())

for i in range(500):
    sess.run(train_step,feed_dict={xs:X_train,ys:y_train,keep_prob:0.6})
    if i % 50 == 0:
       train_result = sess.run(merged,feed_dict={xs:X_train,ys:y_train,keep_prob:1})
       test_result = sess.run(merged,feed_dict={xs:X_test,ys:y_test,keep_prob:1})
       train_writer.add_summary(train_result,i)
       test_writer.add_summary(test_result,i)

Clone this wiki locally