陆老师说，学习一门语言，或者说学习一个工具最好最快的方式就是阅读代码，偶尔查查手册，亦或是借助一个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而已。
扫一扫
417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
