tensorflow入门实例

陆老师说，学习一门语言，或者说学习一个工具最好最快的方式就是阅读代码，偶尔查查手册，亦或是借助一个google或者bing，深以为然。

下面是tensorflow入门的小例子，看看就差不多了了解了tensorflow的运作方式。这几个例子是：三维拟合、CNN和GAN。这些例子我是从别处抄的，自己看了看，加了些注释。

tensorflow三维拟合

这里例子是官方学习网站上抄的。

# coding: utf-8

# In[ ]:


import tensorflow as tf
import numpy as np

# 使用 NumPy 生成假数据(phony data), 总共 100 个点.
x_data = np.float32(np.random.rand(2, 100)) # 随机输入
y_data = np.dot([0.100, 0.200], x_data) + 0.300

# 构造一个线性模型
# 
b = tf.Variable(tf.zeros([1]))
W = tf.Variable(tf.random_uniform([1, 2], -1.0, 1.0))
y = tf.matmul(W, x_data) + b


# In[ ]:



# 初始化变量
init = tf.initialize_all_variables()

# 启动图 (graph)
sess = tf.Session()
sess.run(init)


# In[ ]:


# 拟合平面
for step in range(0, 201):
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(W), sess.run(b))

# 得到最佳拟合结果 W: [[0.100  0.200]], b: [0.300]

用slim来搭建CNN

实际上，tensorflow的运行方式有点像Makefile，即会话去运行目标，目标有哪些依赖的变量，层层回溯去求，最后搭成一个网络。就像是一个水管，管头灌水，管尾出水，我们拿嘴巴在管尾一吸（相当于会话），就有水下来，也就知道水从哪里来了。开始的时候，我们要做的，就是建水管。

• 导入相关的模块

#导入相关的模块
import tensorflow as tf
import tensorflow.contrib.slim as slim
from tensorflow.examples.tutorials.mnist import input_data

• 获取数据

#获取相关的数据，存入新建文件夹，独热编码开启
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

• 占位符的使用

# 定义一些占位符，存放待输入的变量
x = tf.placeholder(tf.float32, shape=[None, 784], name="input")
y = tf.placeholder(tf.float32, shape=[None, 10], name="label")
keep_prob = tf.placeholder(tf.float32, name="dropout_ratio")

• 网络搭建

net = tf.reshape(x, shape=[-1, 28, 28, 1])#输入reshape成四维，[batch, width, height, channel]，-1表示不固定
#逻辑结构
# input -> reshape
# -> Convolution ->  ReLU -> Max pooling
# -> Convolution ->  ReLU -> Max pooling
# -> dropout -> fully connected -> Softmax
net = slim.conv2d(net, num_outputs=32, kernel_size=[5, 5],
                  activation_fn=slim.nn.relu, padding="SAME")#卷积层设置，32个卷积核
net = slim.nn.max_pool(net, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID")#池化层设置
net = slim.conv2d(net, num_outputs=64, kernel_size=[5, 5],
                  activation_fn=slim.nn.relu,padding="SAME")
net = slim.nn.max_pool(net, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID")#ksize滑动窗口大小，在意中间两个值，strides两个方向
#滑动步长
net = slim.flatten(net)#压平
net = slim.nn.dropout(net, keep_prob=keep_prob)#drop out，keep_prob=1,说明不dropout
net = slim.fully_connected(net, 10, activation_fn=slim.nn.softmax)#全连接层，最后softmax

ce_loss = tf.losses.softmax_cross_entropy(y, net)#定义损失函数
train = tf.train.AdamOptimizer(0.001).minimize(ce_loss)#定义训练过程，学习率设置为0.001

correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(y, 1))#准确率判断，tf.argmax(vector, 1)：返回的是vector中的最大值的索引号。
#tf.equal(A, B)是对比这两个矩阵或者向量的相等的元素，如果是相等的那就返回True，反正返回False
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))#误差计算，tf.cast(correct_prediction, tf.float32)数据格式转化
#tf.reduce_mean 函数用于计算张量tensor沿着指定的数轴（tensor的某一维度）上的的平均值，实际上就求了准确率

• 使用会话，驱动网络

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())#初始化
    for i in range(1):  #总共训练5000步
        input_x, input_y = mnist.train.next_batch(512)#一批的大小，选取数据input_x是n行的数据
 #       print(input_x)
 #       print(input_y)
        sess.run(train, feed_dict={x:input_x, y:input_y, keep_prob:0.5})#把相关数据喂进去，开始训练
        
        if i % 100 == 0:  #每一百次，做一些操作
            train_accuracy = sess.run(accuracy, feed_dict={x:input_x, y:input_y, keep_prob:1})
            print("step %d, training accuracy is %g" % (i, train_accuracy))
    print("Test accuracy is %g" % sess.run(accuracy,feed_dict={x:mnist.test.images, y:mnist.test.labels, keep_prob:1}))
 #   x_pre,y_pre = mnist.train.next_batch(1);
    #print(x_pre)
    #y_pre
  #  print(sess.run(net,feed_dict={x:x_pre, y:y_pre, keep_prob:1}))

GAN网络的搭建

从占位符开始，构建一个个的tensorflow。拼下水管道。

#导入一些需要的模块
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import os
from tensorflow.examples.tutorials.mnist import input_data




mnist = input_data.read_data_sets('./MNIST_data', one_hot=True)#读入数据集




#生成网络
D_W1 = tf.get_variable(name='D_W1', shape=[784, 128],
                       initializer=tf.contrib.layers.xavier_initializer())#创建一个变量，xavier初始化器，正态分布
D_b1 = tf.get_variable(name='D_b1', shape=[128],
                       initializer=tf.constant_initializer(0))#创建一个行向量，使用常数初始化器
D_W2 = tf.get_variable(name='D_W2', shape=[128, 1],
                       initializer=tf.contrib.layers.xavier_initializer())
D_b2 = tf.get_variable(name='D_b2', shape=[1],
                       initializer=tf.constant_initializer(0))
theta_D = [D_W1, D_W2, D_b1, D_b2]#找一个变量把这些参数存下来




#对抗网络的一些参数
G_W1 = tf.get_variable(name='G_W1', shape=[100, 128],
                       initializer=tf.contrib.layers.xavier_initializer())
G_b1 = tf.get_variable(name='G_b1', shape=[128],
                       initializer=tf.constant_initializer(0))
G_W2 = tf.get_variable(name='G_W2', shape=[128, 784],
                       initializer=tf.contrib.layers.xavier_initializer())
G_b2 = tf.get_variable(name='G_b2', shape=[784],
                       initializer=tf.constant_initializer(0))
theta_G = [G_W1, G_W2, G_b1, G_b2]




#定义函数来表示判别器
def discriminator(x):
    D_h1 = tf.nn.relu(tf.matmul(x, D_W1) + D_b1)
    D_logit = tf.matmul(D_h1, D_W2) + D_b2
    D_prob = tf.nn.sigmoid(D_logit)
    return D_prob, D_logit

#定义函数来表示生成器
def generator(z):
    G_h1 = tf.nn.relu(tf.matmul(z, G_W1) + G_b1)#行向量
    G_log_prob = tf.matmul(G_h1, G_W2) + G_b2
    G_prob = tf.nn.sigmoid(G_log_prob)
    return G_prob





#构建网络架构
X = tf.placeholder(tf.float32, shape=[None, 784], name='X')#判别器假的输入
Z = tf.placeholder(tf.float32, shape=[None, 100], name='Z')#生成器的输入，一般输入和标签都是需要占位的
G_sample = generator(Z)#生成器
D_real, D_logit_real = discriminator(X)#判别器真的输入，两个管道
D_fake, D_logit_fake = discriminator(G_sample)#D为输出的向量，logit为概率值





#管道1
D_loss_real = tf.reduce_mean(
    tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_real,
                                            labels=tf.ones_like(D_logit_real)))#ones_like创建一个形状相同，所有元素都为1的张量，统计正确率
D_loss_fake = tf.reduce_mean(
    tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_fake,
                                            labels=tf.zeros_like(D_logit_fake)))
D_loss = D_loss_real + D_loss_fake#相加？


#管道2
G_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_fake,
                                                                labels=tf.ones_like(D_logit_fake)))#相同的套路，生成器的目的是使串联输出为1





D_optimizer = tf.train.AdamOptimizer(beta1=0.5).minimize(D_loss, var_list=theta_D)#训练，var_list给出可变的参数
G_optimizer = tf.train.AdamOptimizer(beta1=0.5).minimize(G_loss, var_list=theta_G)




#画图函数
def plot(samples):
    fig = plt.figure(figsize=(4, 4))#创建大小为4 4的图片
    gs = gridspec.GridSpec(4, 4)#将整个图像窗口分成4行4列
    gs.update(wspace=0.05, hspace=0.05)#控制区域间间隔
    for i, sample in enumerate(samples):  #枚举迭代
        ax = plt.subplot(gs[i])
        plt.axis('off')
        ax.set_xticklabels([])
        ax.set_yticklabels([])
        ax.set_aspect('equal')
        plt.imshow(sample.reshape(28, 28), cmap='Greys_r')#cmap='Greys_r'将热图改为灰度图

    return fig



if not os.path.exists('out/'):#不存在这个目录，就创建这个目录
    os.makedirs('out/')



i = 0
with tf.Session() as sess:
    # 初始化
    sess.run(tf.global_variables_initializer())#都要初始化变量
    for it in range(1000):
        # 每1000步迭代之后画个图看看
        if it % 1000 == 0:
            samples = sess.run(G_sample, feed_dict={Z:np.random.uniform(-1., 1., [16, 100])})#16是批次吧，16*784
            fig = plot(samples)
            plt.savefig('out/{}.png'.format(str(i).zfill(3)), bbox_inches='tight')
            i += 1
            plt.close(fig)

        # 进行训练
        X_mb, _ = mnist.train.next_batch(128) # 训练时候不需要label,128个128个地取出来
        _, D_loss_curr = sess.run([D_optimizer, D_loss], feed_dict={X: X_mb, Z: np.random.uniform(-1., 1., [128, 100])})
        _, G_loss_curr = sess.run([G_optimizer, G_loss], feed_dict={Z: np.random.uniform(-1., 1., [128, 100])})#np.random.uniform从
        #[-1,1)上均匀采样，size为128*100

        if it % 1000 == 0:
            print('Iter: {}'.format(it))
            print('D loss: {:.4}'.format(D_loss_curr))
            print('G_loss: {:.4}'.format(G_loss_curr))
            print()

学习一个语言类工具的最好方法就是看代码，无需教程，无需过多书籍，无需从头至尾系统学习，Google而已。