tensorflow记录

 

一、TensorFlow简介

    TensorFlow是谷歌基于DistBelief进行研发的第二代人工智能学习系统，其命名来源于本身的运行原理。Tensor（张量）意味着N维数组，Flow（流）意味着基于数据流图的计算，TensorFlow为张量从流图的一端流动到另一端计算过程。TensorFlow是将复杂的数据结构传输至人工智能神经网中进行分析和处理过程的系统。TensorFlow具有以下特性：

1、高度的灵活性
2、真正的可移植性(server/mobile)
3、多语言支持(python/c++/Go)

 

 

 

 

 

 

 

 

 

常量和变量的使用

1、常量

 

import tensorflow as tf

x=tf.constant(1.0)
y=tf.constant(2.2)
z=tf.add(x,y)

with tf.Session() as sess:
    z=sess.run(z)
    print(z)

 

 

2、变量

 

import tensorflow as tf

x=tf.Variable([1,2,3],dtype=tf.int32)
y=tf.Variable([5,6,7],dtype=tf.int32)
z=tf.reduce_sum(x*y)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    z=sess.run(z)
    print(z)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

使用TensorFlow实现线性回归

 

import tensorflow as tf
import numpy as np


# 用 NumPy 随机生成 100 个数据
x_data = np.float32(np.random.rand(2, 100))            #2,100表示2行100列
y_data = np.dot([0.100, 0.200], x_data) + 0.300        #dot点乘，乘完后的形状是1行100列的数据。[0.100, 0.200]是W，0.300是b，W和b是人为初始设定的。

# 构造一个线性模型
b = tf.Variable(tf.zeros([1]))                         #
W = tf.Variable(tf.random_uniform([1, 2], -1.0, 1.0))  #random_uniform([1, 2], -1.0, 1.0)表示随机初始化向量，初始化1行2列的向量，元素的取值在-1到1之间
y = tf.matmul(W, x_data) + b                           #matmul表示乘法

# 最小化方差
loss = tf.reduce_mean(tf.square(y - y_data))            #tf.square计算平方，tf.reduce_mean求平均值
optimizer = tf.train.GradientDescentOptimizer(0.5)      #0.5是步长，步长乘以梯度。GradientDescentOptimizer继承自Optimizer，实现实现梯度下降算法的优化器类，用于构造一个新的梯度下降优化器实例
train = optimizer.minimize(loss)                        #最小化loss

# 初始化变量
init = tf.global_variables_initializer()                #全局初始化，                           

# 启动图 (graph)
sess = tf.Session()                                     #构建一个图                                     
sess.run(init)                                          #使用run生成一个图，run(init)

# 拟合平面
for step in range(0, 201):                              #迭代次数
    l, _ = sess.run([loss, train])                      #每次迭代loss都在变小
    print(l)                                            #打印loss值

w_result, b_result = sess.run([W, b])                   #获取该模型最终的W和b 
print(w_result, b_result)                               #打印模型优化后的W和b

sess.close()                                            #关闭Session

 

 

构建卷积神经网络

 

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

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("data/", one_hot=True)                                              #导入mnist数据集

tf.reset_default_graph()                                                                              #tf.reset_default_graph函数用于清除默认图形堆栈并重置全局默认图形。
sess = tf.InteractiveSession()                                                                        #创建回话Session，与tf.Session区别
x = tf.placeholder("float", shape = [None, 28,28,1])                                                  #创建x
y_ = tf.placeholder("float", shape = [None, 10])                                                      #创建y

W_conv1 = tf.Variable(tf.truncated_normal([5, 5, 1, 32], stddev=0.1))                                 #初始化权重（卷积核）
b_conv1 = tf.Variable(tf.constant(.1, shape = [32]))                                                  #初始化偏置值

h_conv1 = tf.nn.conv2d(input=x, filter=W_conv1, strides=[1, 1, 1, 1], padding='SAME') + b_conv1       #构建第一个卷积层
h_conv1 = tf.nn.relu(h_conv1)                                                                         #relu激活函数
h_pool1 = tf.nn.max_pool(h_conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')           #最大池化，卷积核大小是2X2，步长是2X2

def conv2d(x, W):                                                                                        
    return tf.nn.conv2d(input=x, filter=W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

#第二层卷积层
W_conv2 = tf.Variable(tf.truncated_normal([5, 5, 32, 64], stddev=0.1))                                #
b_conv2 = tf.Variable(tf.constant(.1, shape = [64]))                                                  #
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)                                              #
h_pool2 = max_pool_2x2(h_conv2)

#第一个全连接层
W_fc1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1024], stddev=0.1))
b_fc1 = tf.Variable(tf.constant(.1, shape = [1024]))
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

#Dropout层
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

#第二个全连接层
W_fc2 = tf.Variable(tf.truncated_normal([1024, 10], stddev=0.1))
b_fc2 = tf.Variable(tf.constant(.1, shape = [10]))

#Final Layer
y = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

crossEntropyLoss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = y_, logits = y))
trainStep = tf.train.AdamOptimizer().minimize(crossEntropyLoss)
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

sess.run(tf.global_variables_initializer())

batchSize = 50
for i in range(1000):
    batch = mnist.train.next_batch(batchSize)
    trainingInputs = batch[0].reshape([batchSize,28,28,1])
    trainingLabels = batch[1]
    if i%100 == 0:
        trainAccuracy = accuracy.eval(session=sess, feed_dict={x:trainingInputs, y_: trainingLabels, keep_prob: 1.0})
        print ("step %d, training accuracy %g"%(i, trainAccuracy))
    trainStep.run(session=sess, feed_dict={x: trainingInputs, y_: trainingLabels, keep_prob: 0.5})