Tensorflow从0到1（3）之实战传统机器算法

计算图中的操作

import numpy as np
import tensorflow as tf
sess = tf.Session()
x_vals = np.array([1., 3., 5., 7., 9.])
x_data = tf.placeholder(dtype=tf.float32)
m_const = tf.constant(3.)
my_product = tf.multiply(x_data, m_const)
for x_val in x_vals:
    print(sess.run(my_product, feed_dict={x_data:x_val}))

Tensorflow的嵌入Layer

import tensorflow as tf
sess = tf.Session()
# 创建数据和占位符
my_array = np.array([[1., 3., 5., 7., 9.],
                     [-2., 0., 2., 4., 6.],
                     [-6., -3., 0., 3., 6.]])
x_vals = np.array([my_array, my_array+1])
x_data = tf.placeholder(shape=(3,5), dtype=tf.float32)
# 创建常量矩阵
m1 = tf.constant([[1.], [0.], [-1.], [2.], [4.]]) # 5x1矩阵
m2 = tf.constant([[2.]]) # 1x1矩阵
a1 = tf.constant([[10.]]) # 1x1矩阵
# 声明操作， 表示成计算图
prod1 = tf.matmul(x_data, m1) # 3x5 乘以 5x1 = 3x1
prod2 = tf.matmul(prod1, m2) # 3x1 乘以标量 = 3x1
add1 = tf.add(prod2, a1)
# 赋值
for x_val in x_vals:
    print(sess.run(add1, feed_dict={x_data: x_val}))
sess.close()

注意：对于事先不知道的维度大小，可以用None代替。例如：

x_data = tf.placeholder(dtype=tf.float32, shape=(3,None))

Tensorflow的多层layer

对2D图像数据进行滑动窗口平均，然后通过自定义操作层Layer返回结果。

import tensorflow as tf
import numpy as np
sess = tf.Session()
# 创建2D图像，4X4像素。
x_shape = [1, 4, 4, 1] # [batch, in_height, in_width, in_channels] tensorflow处理（图片数量，高度、宽度、颜色）思维图像数据
x_val = np.random.uniform(size=x_shape)
# 占位符
x_data = tf.placeholder(dtype=tf.float32, shape=x_shape)
# 创建滑动窗口
my_filter = tf.constant(0.25, shape=[2,2,1,1]) # [filter_height, filter_width, in_channels, out_channels]
my_strides = [1, 2, 2, 1] # 长宽方向滑动步长均为2
mov_avg_layer = tf.nn.conv2d(x_data, my_filter, my_strides,
                            padding='SAME', name='Moving_avg_Window')
# 定义一个自定义Layer，操作上一步滑动窗口的2x2的返回值。
# 自定义函数将输入张量乘以一个2X2的矩阵张量，然后每个元素加1.因为矩阵乘法只计算二维矩阵，所以裁剪多余维度（大小为1的维度）。Tensorflow通过内建函数squeeze()函数裁剪。
def custom_layer(input_matrix):
    input_matrix_squeezed = tf.squeeze(input_matrix)
    A = tf.constant([[1., 2.], [-1., 3.]])
    b = tf.constant(1., shape=[2,2])
    temp1 = tf.matmul(A, input_matrix_squeezed)
    temp = tf.add(temp1, b) # Ax+b
    return (tf.sigmoid(temp))
# 把刚刚定义的Layer加入到计算图中，并用tf.name_scope()命名Layer名称。
with tf.name_scope('Custom_Layer') as scope:
    custom_layer1 = custom_layer(mov_avg_layer)
# 传入数据，执行
print(sess.run(custom_layer1, feed_dict={x_data:x_val}))
# 关闭会话，释放资源
sess.close()

Tensorflow实现损失函数

损失函数对机器学习来讲非常重要，它度量模型输出值与目标值之间的差距。

回归问题常用损失函数

import matplotlib.pyplot as plt
import tensorflow as tf
sess = tf.Session()
# 创建数据
x_vals = tf.linspace(-1., 1., 500)
target = tf.constant(0.)
# L2正则损失函数：预测值与目标值差距的平方和。
# L2正则损失函数在目标值附近有更好的曲度，机器学习算法利用这点收敛，并且离目标越近收敛越慢。
l2_y_vals = tf.square(target - x_vals)
l2_y_out = sess.run(l2_y_vals)
# 注意：tensorflow有内建的L2正则形式：nn.l2_loss()。这个函数实际上是L2正则的1/2
# L1正则损失函数：预测值与目标值差值平均值
# L1正则在目标值附近不平滑，导致算法不能很好的收敛。
l1_y_vals = tf.abs(target - x_vals)
l1_y_out = sess.run(l1_y_vals)
# Pseudo-Huber损失函数：Huber损失函数的连续、平滑估计
# 试图利用L1和L2正则消减极值处的陡峭，是的目标值附近连续。
# 其表达式依赖参数delta
delta1 = tf.constant(0.25)
phuber1_y_vals = tf.multiply(tf.square(delta1), tf.sqrt(1.+tf.square((target-x_vals)/delta1))-1.)
phuber1_y_out = sess.run(phuber1_y_vals)
delta2 = tf.constant(5.)
phuber2_y_vals = tf.multiply(tf.square(delta2), tf.sqrt(1.+tf.square((target-x_vals)/delta2))-1.)
phuber2_y_out = sess.run(phuber2_y_vals)

关于Huber函数

L1正则在目标值处不平滑。L2正则在异常值处过大，会放大异常值的影响。因此，Huber函数在目标值附近（小于delta)是L2正则，在大于delta处是L1正则。解决上述问题。
参考
Huber损失函数

绘图展示回归算法损失函数

x_array = sess.run(x_vals)
plt.plot(x_array, l2_y_out, 'b-', label='L2 Loss')
plt.plot(x_array, l1_y_out, 'r--', label='L1 Loss')
plt.plot(x_array, phuber1_y_out, 'k-', label='P-Huber Loss (0.25)')
plt.plot(x_array, phuber2_y_out, 'g:', label='P-Huber Loss (0.5)')
plt.ylim(-0.2, 0.4)
plt.legend(loc='lower right', prop={'size':11})
plt.show()

回归算法损失函数入下图所示：

 

regression_loss_function.png

可以看出，L2损失函数离0点越远，损失会被2次方放大。L1损失函数在0点处不可导。P-Huber损失函数则在0点出是近似的L2损失函数，在远离零点处是近似的斜线。既解决了L1损失梯度下降算法可能不收敛的问题，又减少了异常值的影响。

分类问题常用损失函数

# 创建数据
x_vals = tf.linspace(-3., 5., 500)
target = tf.constant(1.)
targets = tf.fill([500,], 1)
# Hinge 损失函数：评估支持向量机算法，有时也用来评估神经网络算法。
hinge_y_vals = tf.maximum(0., 1. - tf.multiply(target, x_vals))
hinge_y_out = sess.run(hinge_y_vals)
# 两类交叉熵损失函数(cross-entropy loss)：
xentropy_y_vals = -tf.multiply(target, tf.log(x_vals)) - tf.multiply((1.-target), tf.log(1. - x_vals))
xentropy_y_out = sess.run(xentropy_y_vals)
# Sigmoid交叉熵损失函数：与上面的交叉熵损失函数非常类似，只是先将x_vals值通过sigmoid转换在计算交叉熵。
xentropy_sigmoid_y_vals = tf.nn.sigmoid_cross_entropy_with_logits(labels = target, logits = x_vals)
xentropy_sigmoid_y_out = sess.run(xentropy_sigmoid_y_vals)
# 加权交叉熵损失函数：Sigmoid交叉熵损失函数的加权，对正目标加权。
weight = tf.constant(0.5)
xentropy_weighted_y_vals = tf.nn.weighted_cross_entropy_with_logits(targets = targets, logits = x_vals, pos_weight = weight)
xentropy_weighted_y_out = sess.run(xentropy_weighted_y_vals)
# Softmax交叉熵损失函数：作用于非归一化的输出结果，只针对单个目标分类的计算损失。
unsacled_logits = tf.constant([[1., -3., 10.]])
target_dist = tf.constant([[0.1, 0.02, 0.88]])
softmax_xentropy = tf.nn.sotfmax_entropy_with_logits(logits = unscaled_logits, labels = target_dist)
print(sess.run(softmax_xentropy)
# 稀疏Softmax交叉熵损失函数
unscaled_logits = tf.constant([[1., -3., 10.]])
sparse_target_dist = tf.constant([2])
sparese_xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = unscaled_logits, labels = sparse_target_dist)
print(sess.run(sparse_xentropy))

关于交叉熵的说明

1 信息量

假设我们听到了两件事：
A：巴西队进入了2018世界杯决赛圈；B：中国队进入了2018世界杯决赛圈。
直觉上来说，事件B比事件A包含的信息量大，因为小概率事件发生了，一定是有些我们不知道的东西。因此，这样定义信息量：
假设X是一个离散型随机变量，其取值集合为,概率分布函数 ，则定义事件的信息量为：

信息量函数如下图所示：

 

image

可以看出-log(x)函数刻画的信息量，x越接近零越大，越接近1越小。这里便可以理解二分类问题中的logistics回归的损失函数-y*log(y_hat)-(1-y)*log(1-y_hat), 它会给错误分类很大的惩罚。比如，在y=1是，y_hat如果接近0，会导致loss很大，同样y=0时，y_hat接近1，也会导致loss很大。因此在最小化Loss函数时，会尽可能的将y=1的y_hat预测成1，y=0的y_hat预测为0。

2 熵

对于某个事件，有n中可能，那么求其n中可能的信息量的期望，便是熵。即熵：

3 相对熵（KL散度）

相对熵又称KL散度，如果对于随机变量x有两个概率分布P(x)和Q(x),我们可以使用KL散度来衡量两个分布的差异。KL散度的计算公式：

可见当q和p的分布越接近时，KL散度越小。当q和p为相同的分布是，KL散度为0。

4 交叉熵

在机器学习里，p是样本的真实分布。比如猫狗鼠的分类问题，一个样本点(是猫）的实际分布是（1,0,0）。而q是模型预测分布，比如（0.8,0.1,0.1）。那么我们模型训练的目标可以设置为是的p、q的KL散度最小化，即q尽可能接近真实的p分布。
而：

其中，,是p分布的熵；是p和q的交叉熵。由于p是样本的真实分布，所以H(p(x))是一个常数值。那么KL散度最小化也就等价于交叉熵的最小化。

参考
关于交叉熵在loss函数中使用的理解

关于Softmax损失函数和稀疏Softmax损失函数的说明

首先，Softmax和系数Softmax损失函数最大的不同是输入的labels不同。对于某一个样本点，Softmax损失函数输入的labels是各分类的实际概率，例如猫狗鼠分类，就是（1,0,0）这样的向量。对于m各样本点，输入的labels则是一个m*3的矩阵。而稀疏Softmax，输入labels是实际所属类别的index，比如这里是（1,0,0），则输入就是0。m个样本点，输入是m维向量，向量里面的内容是该样本点所属类别的索引。
对于单个样本点，多分类的交叉熵如下：
, 其中，是样本点i各类别的实际概率分布（例如（1,0,0）），是预测概率分布（例如（0.7,0.2,0.1））。对于Softmax函数，我们需要计算log(0.7),log(0.2),log(0.1)。但由于log(0.2),log(0.1)前面乘以的实际的是零，实际上是没有必要计算的。这样，Softmax损失函数就会造成算力的浪费，尤其深度学习的数据量非常大，这种浪费往往不能忍受。而稀疏Softmax则只计算时的(这里即log(0.7)，可以大大的提升计算性能。因此，对于这种实际分布只有一个1，其他全为零的排他性分类问题，Softmax和稀疏Softmax损失函数没有本质上的区别，只是后者在计算性能上有一个优化。

评价机器学习模型的其他指标

指标	描述
	对简单线性模型来讲，用于度量因变量中可由自变量解释部分所占比例。
RMSE (平均方差)	对连续模型来讲，是度量预测值和观测值之差的样本标准差。
混淆矩阵（Confusion matrix）	对分类模型来讲，以矩阵形式将数据集中的记录按照真实的类别与预测类别两个标准进行分析汇总，其列代表预测类别，行代表实际类别。理想情况下，混淆矩阵是对角矩阵。
查全率(Recall)	正类中有多少被正确预测（正类中被正确预测为正类的比例）。
查准率（Precision）	被预测为正类的样本中有多少是真的正类。
F值（F-score）	对于分类模型来讲，F值是查全率和查准率的调和平均数

Tensorflow实现反向传播

简单的回归例子

这个例子很简单，是一个一元线性回归模型y=Ax。x是均值为1，标准差0.1的标准正态分布生成的100个样本点。y都是10。这样回归参数A应该是10左右。

# 1 导入包
import numpy as np
import tensorflow as tf
# 2 创建会话
sess = tf.Session()
# 3 生成数据，创建占位符和变量
x_vals = np.random.normal(1, 0.1, 100) # 均值为1，标准差为0.1，100个样本点
y_vals = np.repeat(10., 100) # 10
x_data = tf.placeholder(shape=[1], dtype=tf.float32)
y_target = tf.placeholder(shape=[1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(shape=[1]))
# 4 模型
my_output = tf.multiply(x_data, A)
# 5 增加L2正则损失函数
loss = tf.square(my_output - y_target) # 这里损失函数是单个样本点的损失，因为一次训练只随机选择一个样本点
# 6 初始化变量
init = tf.initialize_all_variables()
sess.run(init)
# 7 声明变量的优化器。设置学习率。
my_opt = tf.train.GradientDescentOptimizer(learning_rate=0.02)
train_step = my_opt.minimize(loss)
# 8 训练算法
for i in range(100):
    rand_index = np.random.choice(100) # 随机选择一个样本点
    rand_x = [x_vals[rand_index]]
    rand_y = [y_vals[rand_index]]
    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%25 == 0:
        print('Step #' + str(i) + ' A = ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y})))
# 9 关闭会话
sess.close()
# 输出结果如下：
Step #24 A = [4.863781] b = 4.139231
Loss = [1.2424334]
Step #49 A = [5.316289] b = 4.6542783
Loss = [0.7101963]
Step #74 A = [5.27029] b = 4.6673064
Loss = [0.3602042]
Step #99 A = [5.211789] b = 4.67501
Loss = [0.12189686]

简单的分类例子

这是一个简单的二分类问题。100个样本点，其中50个由N(-1,1)生成，标签为0，50个由N(3,1)生成，标签为1。用sigmoid函数实现二分类问题。模型设置为sigmoid(A+x)。两类数据中心点的中点是1，可见A应该在-1附近。

# 1 引入python包
import tensorflow as tf
import numpy as np
# 2 创建会话
sess = tf.Session()
# 3 生成数据，创建变量和占位符
x_vals = np.concatenate((np.random.normal(-1, 1, 50),
                        np.random.normal(3, 1, 50)))
y_vals = np.concatenate((np.repeat(0., 50),
                        np.repeat(1., 50)))
x_data = tf.placeholder(shape=[1], dtype=tf.float32)
y_target = tf.placeholder(shape=[1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(mean=10, shape=[1]))

# 模型。y_pre = sigmoid(A+x)。
# 这里不必封装sigmoid函数，因为损失函数中会实现此功能
my_output = tf.add(x_data, A)

# 增加一个批量维度，使其满足损失函数的输入要求。
my_output_expanded = tf.expand_dims(my_output, 0)
y_target_expanded = tf.expand_dims(y_target, 0)

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

# 损失函数
xentropy = tf.nn.sigmoid_cross_entropy_with_logits(logits = my_output_expanded,
                                                   labels = y_target_expanded)

# 优化器
my_opt = tf.train.GradientDescentOptimizer(learning_rate = 0.05)
train_step = my_opt.minimize(xentropy)

# 迭代训练
for i in range(1400):
    rand_index = np.random.choice(100)
    rand_x = [x_vals[rand_index]]
    rand_y = [y_vals[rand_index]]

    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%200 == 0:
        print('Step #' + str(i+1) + ' A= ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(xentropy, feed_dict={x_data: rand_x,
                                                            y_target: rand_y})))
# 关闭会话
sess.close()
# 输出结果如下：
Step #200 A= [6.4651575]
Loss = [[5.8275104]]
Step #400 A= [1.9440486]
Loss = [[1.3305019]]
Step #600 A= [-0.04775457]
Loss = [[0.11453534]]
Step #800 A= [-0.66482824]
Loss = [[0.03918179]]
Step #1000 A= [-1.0784857]
Loss = [[0.04238104]]
Step #1200 A= [-1.0975529]
Loss = [[0.06028807]]
Step #1400 A= [-1.0565817]
Loss = [[0.16332036]]

算法步骤总结

1. 生成数据或加载数据
   2.设置占位符和变量，初始化变量。
   3.创建损失函数。
   4.定义优化器算法。
   5.通过随机样本反复迭代，更新变量。

---

Tensorflow 实现随机训练和批量训练

上面的反向传播算法的例子，一次操作一个数据点，可能会导致比较古怪的学习过程。本节介绍随机批量训练。

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
sess = tf.Session()

# 1 声明批量大小。即一次传入多少数据量
batch_size = 20
# 2 生成数据，设置占位符和变量
x_vals = np.random.normal(1, 0.1, 100)
y_vals = np.repeat(10., 100)
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32) # None会自动匹配batch大小
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(shape=[1,1]))
# 3 模型
my_output = tf.matmul(x_data, A)
# 4 损失函数
loss = tf.reduce_mean(tf.square(my_output - y_target))
# 5 声明优化器
my_opt = tf.train.GradientDescentOptimizer(0.02)
train_step = my_opt.minimize(loss)
# 初始化变量A
init = tf.initialize_all_variables()
sess.run(init)
# 6 迭代训练
loss_batch = []
for i in range(100):
    rand_index = np.random.choice(100, size = batch_size)
    rand_x = np.transpose([x_vals[rand_index]])
    rand_y = np.transpose([y_vals[rand_index]])

    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%5==0:
        print('Step # '+ str(i+1) + ' A = ' + str(sess.run(A)))
        temp_loss = sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y})
        print('Loss = '+ str(temp_loss))
        loss_batch.append(temp_loss)
# 关闭会话
sess.close()

本段实现的仍是那个线性回归的例子。唯一的不同是，上面每次优化过程计算的损失函数只用到一个随机样本点。而本处用到batch_size=20个随机样本点，损失函数是这20个随机样本点损失函数的平均值。

---

TensorFlow实现创建分类器

这里用到iris鸢尾花数据集。iris有三种花，这里只预测是否是山鸢尾。

# 1 导入包、创建会话
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
import tensorflow as tf
sess = tf.Session()

# 2 导入数据集
iris = datasets.load_iris()
binary_target = np.array([1. if x==0 else 0. for x in iris.target]) # 山鸢尾标签设置为0
iris_2d = np.array([[x[2], x[3]] for x in iris.data])

# 3 声明批大小、占位符和变量
batch_size = 20
x1_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
x2_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(shape=[1,1]))
b = tf.Variable(tf.random_normal(shape=[1,1]))

# 4 模型：x1 - Ax2 -b
my_mult = tf.matmul(x2_data, A)
my_add = tf.add(my_mult, b)
my_output = tf.subtract(x1_data, my_add)

# 5 Loss函数
xentropy = tf.nn.sigmoid_cross_entropy_with_logits(labels = y_target, logits = my_output)

# 6 优化器
my_opt = tf.train.GradientDescentOptimizer(0.05)
train_step = my_opt.minimize(xentropy)

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

# 8 训练模型
for i in range(1000):
    rand_index = np.random.choice(len(iris_2d), size=batch_size)
    rand_x = iris_2d[rand_index]
    rand_x1 = np.array([[x[0]] for x in rand_x])
    rand_x2 = np.array([[x[1]] for x in rand_x])
    rand_y = np.array([[y] for y in binary_target[rand_index]])
    sess.run(train_step, feed_dict={x1_data:rand_x1, x2_data:rand_x2, y_target:rand_y})
    if (i+1)%200 == 0:
        print('Step #' + str(i+1) +' A= '+ str(sess.run(A)) + ',b='+str(sess.run(b)))
sess.close()
输出如下:
Step #200 A= [[8.594328]],b=[[-3.3715847]]
Step #400 A= [[10.06079]],b=[[-4.6303725]]
Step #600 A= [[11.153477]],b=[[-5.2268066]]
Step #800 A= [[11.741766]],b=[[-5.9545264]]
Step #1000 A= [[12.346895]],b=[[-6.3250523]]

---

Tensorflow实现模型评估

回归

这里用MSE评估

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
sess = tf.Session()
x_vals = np.random.normal(1., 0.1, 100)
y_vals = np.repeat(10., 100)
x_data = tf.placeholder(shape=[None, 1], dtype = tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype = tf.float32)
batch_size = 25
train_indices = np.random.choice(len(x_vals),
                                 round(len(x_vals)*0.8), replace=False) # False表示不放回
test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))
x_vals_train = x_vals[train_indices]
x_vals_test = x_vals[test_indices]
y_vals_train = y_vals[train_indices]
y_vals_test = y_vals[test_indices]
A = tf.Variable(tf.random_normal(shape=[1,1]))

#2. 声明算法模型、损失函数和优化器
my_output = tf.matmul(x_data, A)
loss = tf.reduce_mean(tf.square(my_output - y_target))
init = tf.initialize_all_variables()
sess.run(init)
my_opt = tf.train.GradientDescentOptimizer(0.02)
train_step = my_opt.minimize(loss)
#3. 训练代码
for i in range(100):
    rand_index = np.random.choice(len(x_vals_train), size=batch_size)
    rand_x = np.transpose([x_vals_train[rand_index]])
    rand_y = np.transpose([y_vals_train[rand_index]])
    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%25 == 0:
        print('Step #'+ str(i+1) + ' A= ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y})))

#4. 评估训练模型
mse_test = sess.run(loss, feed_dict = {x_data:np.transpose([x_vals_test]),
                                       y_target:np.transpose([y_vals_test])})
mse_train = sess.run(loss, feed_dict = {x_data:np.transpose([x_vals_train]),
                                        y_target:np.transpose([y_vals_train])})
print('MSE on test:' + str(np.round(mse_test, 2 )))
print('MSE on train:' + str(np.round(mse_train, 2)))
sess.close()

分类

# 引入包
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
# 创建计算图、加载数据、创建占位符和变量
sess = tf.Session()
batch_size = 25
x_vals = np.concatenate((np.random.normal(-1,1,50), np.random.normal(3, 1, 50)))
y_vals = np.concatenate((np.repeat(0., 50), np.repeat(1.,50)))
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None,1], dtype=tf.float32)

# 分割数据集为训练集和测试集
train_indices = np.random.choice(len(x_vals),
                                 round(len(x_vals)*0.8), replace=False) # False表示不放回
test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))
x_vals_train = x_vals[train_indices]
x_vals_test = x_vals[test_indices]
y_vals_train = y_vals[train_indices]
y_vals_test = y_vals[test_indices]
A = tf.Variable(tf.random_normal(mean=10,shape=[1,1]))

# 设置模型
my_output = tf.add(x_data,A)

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

# 损失函数和优化器
xentropy = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = my_output, labels=y_target))
my_opt = tf.train.GradientDescentOptimizer(0.05)
train_step = my_opt.minimize(xentropy)

# 训练模型
for i in range(1800):
    rand_index = np.random.choice(len(x_vals_train), size=batch_size)
    rand_x = np.transpose([x_vals_train[rand_index]])
    rand_y = np.transpose([y_vals_train[rand_index]])
    sess.run(train_step, feed_dict={x_data:rand_x,
                                    y_target:rand_y})
    if (i+1)%200 ==0:
        print('Step #'+ str(i+1) + ' A= ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(xentropy, feed_dict={x_data:rand_x, y_target:rand_y})))

# 模型评估
y_prediction = tf.round(tf.nn.sigmoid(tf.add(x_data, A)))
correct_prediction = tf.squeeze(tf.equal(y_prediction, y_target))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
acc_value_test = sess.run(accuracy, feed_dict={x_data:np.transpose([x_vals_test]),
                                               y_target:np.transpose([y_vals_test])})
acc_value_train = sess.run(accuracy, feed_dict={x_data:np.transpose([x_vals_train]),
                                                y_target:np.transpose([y_vals_train])})
print('Accuracy on train set:' + str(acc_value_train))
print('Accuracy on test set:' + str(acc_value_test))

# 画图
A_result = -sess.run(A)
bins = np.linspace(-5, 5, 50)
plt.hist(x_vals[0:50], bins, alpha=0.5, label='N(-1,1)', color='blue')
plt.hist(x_vals[50:100], bins[0:50], alpha=0.5, label='N(2,1)', color='red')
plt.axvline(A_result, color = 'k', ls = '--', linewidth=1, label='A='+str(np.round(A_result, 2)))
plt.legend(loc='upper right')
plt.show()
sess.close()