TensorFlow学习（2）：非线性回归和简单的MNIST手写数字识别

1.非线性回归

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

#使用np生成200个随机点样本
x_data=np.linspace(-0.5,0.5,200)[:,np.newaxis]     #-0.5~0.5之间均匀生成200个点 ,[:,np.newaxis]增加维度，使1维变2维 200行
#生成噪声
noise=np.random.normal(0,0.02,x_data.shape)        #形状和x_data一样
y_data=np.square(x_data)+noise

#定义两个placeholder
x=tf.placeholder(tf.float32,[None,1])              #形状[None,1]  行不确定（自动确定），1列，与样本对应
y=tf.placeholder(tf.float32,[None,1])

#定义神经网络隐层
Weight_L1=tf.Variable(tf.random_normal([1,10]))     #隐层权重，输入1个神经元，隐层10个神经元
baise_L1=tf.Variable(tf.zeros([1,10]))              #隐层偏置为0，10个
Wx_pluse_b_L1=tf.matmul(x,Weight_L1)+baise_L1
L1=tf.nn.tanh(Wx_pluse_b_L1)                        #隐层输出L1，激活函数tf.nn.tanh

#定义神经网络输出层
Weight_L2=tf.Variable(tf.random_normal([10,1]))      #隐层10个神经元，输出1个神经元
baise_L2=tf.Variable(tf.zeros([1,1]))                #一个
Wx_pluse_b_L2=tf.matmul(L1,Weight_L2)+baise_L2
prediction=tf.nn.tanh(Wx_pluse_b_L2)

#二次代价函数
loss=tf.reduce_mean(tf.square(y-prediction))
#使用梯度下降法
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)

with tf.Session() as sess:
    #变量初始化
    sess.run(tf.global_variables_initializer())
    for _ in range(2000):
        sess.run(train_step,feed_dict={x:x_data,y:y_data})

    #获得预测值
    prediction_value=sess.run(prediction,feed_dict={x:x_data})

    #画图
    plt.figure()
    plt.scatter(x_data,y_data)                            #训练样本散点图
    plt.plot(x_data,prediction_value,'r',lw=5)            #预测结果线图，红色，线宽5
    plt.show()

2.MNIST数据集

3.Softmax函数

4.简单的MNIST手写数字识别

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

#载入数据
mnist=input_data.read_data_sets("MNIST_data",one_hot=True)

#每个批次的大小
batch_size=100                                 #一次训练100张图
#计算共有多少批次
n_batch=mnist.train.num_examples//batch_size

#定义两个placeholder
x=tf.placeholder(tf.float32,[None,784])
y=tf.placeholder(tf.float32,[None,10])

#创建简单神经网络
W=tf.Variable(tf.zeros([784,10]))
b=tf.Variable(tf.zeros([10]))
prediction=tf.nn.softmax(tf.matmul(x,W)+b)

#定义二次代价函数
#loss=tf.reduce_mean(tf.square(y-prediction))
#交叉熵
loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))

#使用梯度下降
train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss)

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

#结果村发展一个布尔型列表中
#tf.equal里面变量，相同返回ture，不同返回fals。tf.argmax求一维张量最大值在哪个位置
correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(prediction,1)) 

#求准确率
#tf.cast布尔型转换为float32类型，tf.reduce_mean求平均得到准确率
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))  

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(21):                                                   #所有图片训练21次
        for batch in range(n_batch):
            batch_xs,batch_ys=mnist.train.next_batch(batch_size)              #取下一批次
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter "+str(epoch)+" ,Testing Accuracy: "+str(acc))

实验结果：使用交叉熵比二次代价函数收敛快、精度高。