Tensorflow学习笔记(三)

最新推荐文章于 2021-10-11 18:59:48 发布

WuwuwuH_

最新推荐文章于 2021-10-11 18:59:48 发布

阅读量264

点赞数

分类专栏：人工智能文章标签：神经网络卷积可视化 tensorflow 深度学习

本文链接：https://blog.csdn.net/WuwuwuH_/article/details/115496383

版权

人工智能专栏收录该内容

7 篇文章 1 订阅

订阅专栏

一、学习内容：

1.Matplotlib将学习过程可视化展示
2.Tensorboard产生神经网络图
3.分类
4.过拟合问题的解决

二、代码及注释：

1.Matplotlib将机器学习过程可视化展示

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt #输出结果可视化的模块

### 定义了一个函数 用来添加层
def add_layer(intputs,in_size,out_size,activation_function=None):
     with tf.name_scope('layer'):
        with tf.name_scope('wights'):
           Weights = tf.Variable(tf.random_normal([in_size,out_size]),name='W') # 权重 生成随机变量矩阵
        with tf.name_scope('biase'):
           biases = tf.Variable(tf.zeros([1,out_size])+0.1,name='b') # 偏移 biases初始值推荐不为0，所以此处加上0.1
        with tf.name_scope('Wx_plus_b'):
           Wx_plus_b = tf.matmul(intputs,Weights)+biases # 输入值与随机变量矩阵相乘再加上偏移
        if activation_function is None: # 如果激励函数是None的话说明是线性关系
            outputs = Wx_plus_b
        else:
            outputs = activation_function(Wx_plus_b)
        return outputs

x_data = np.linspace(-1,1,300)[:,np.newaxis] # -1到1的区间 300个单位 x_data有1个特性但是有300个例子 最后中括号代表的是维度
noise = np.random.normal(0,0.05,x_data.shape) # 起始值0 方差0.05 格式与x_data相同
y_data = np.square(x_data) - 0.5 + noise # x_datade平方减0.5加noise

with tf.name_scope('inputs'):
   xs = tf.placeholder(tf.float32,[None,1],name = 'x_input')
   ys = tf.placeholder(tf.float32,[None,1],name = 'y_input')


l1 = add_layer(xs,1,10,activation_function=tf.nn.relu6) # 添加隐藏层 （input inputsize outputsize 激励方程）
prediction = add_layer(l1,10,1,activation_function=None) # 添加输出层 （output inputsize outputsize 激励方程）

with tf.name_scope('loss'):
   loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), # 预测值与真实值的差别 求和 求平均值
                                    reduction_indices=[1]))
with tf.name_scope('train'):
   train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss) # 使用Adam/GradientDescentOptimizer优化器 学习效率0.1 作用是减小loss


init = tf.initialize_all_variables(); # 对所有的变量进行初试化
sess = tf.Session() # 定义Session
writer = tf.summary.FileWriter(logdir='logs',graph=tf.get_default_graph())
writer.flush()
sess.run(init) # 运行初始化

fig = plt.figure() # 生成图片框
ax = fig.add_subplot(1,1,1) # 连续性的画图 编号
ax.scatter(x_data,y_data) # 将真实的数据显示
plt.ion() # 程序show一次以后不暂停，连续plot显示
plt.show() # 只能输出一次 然后将程序暂停

for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data}) # 以字典的形式传入值
    if i%50==0:
        # print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))
        try:  # 先将前一条线抹除 然后再输出下一条线
            ax.lines.remove(lines[0]) # 将前一条输出的线去除
        except Exception:  # 使用try是为了防止第一次抹除线的时候报错
            pass
        prediction_value = sess.run(prediction,feed_dict={xs:x_data}) # 获得预测的值
        lines = ax.plot(x_data,prediction_value,'r-',lw=5) # 将prediction的值用一条曲线的形式输出 红色的线 宽度为5
        plt.pause(0.1) # 在每次的过程中暂停0.1秒

plt.pause(0) # 解决图线显示完毕后，窗口自动关闭的问题

2.Tensorboard的使用

### tensorboard的使用
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt #输出结果可视化的模块
### 定义了一个函数 用来添加层
def add_layer(intputs,in_size,out_size,n_layer,activation_function=None):
    layer_name ='layer%s'%n_layer
    with tf.name_scope(layer_name):
         with tf.name_scope('wights'):
             Weights = tf.Variable(tf.random_normal([in_size,out_size]),name='W') # 权重 生成随机变量矩阵
             tf.summary.histogram(layer_name + '/weigths', Weights)
             #tf.histogram_summary(layer_name+'/weigths',Weights)
         with tf.name_scope('biase'):
             biases = tf.Variable(tf.zeros([1,out_size])+0.1,name='b') # 偏移 biases初始值推荐不为0，所以此处加上0.1
             tf.summary.histogram(layer_name + '/biases', biases)
             #tf.histogram_summary(layer_name + '/biases', biases)
         with tf.name_scope('Wx_plus_b'):
             Wx_plus_b = tf.matmul(intputs,Weights)+biases # 输入值与随机变量矩阵相乘再加上偏移
         if activation_function is None: # 如果激励函数是None的话说明是线性关系
             outputs = Wx_plus_b
             tf.summary.histogram(layer_name + '/output', outputs)
             #tf.histogram_summary(layer_name + '/output', outputs)
         else:
             outputs = activation_function(Wx_plus_b)
         return outputs

x_data = np.linspace(-1,1,300)[:,np.newaxis] # -1到1的区间 300个单位 x_data有1个特性但是有300个例子 最后中括号代表的是维度
noise = np.random.normal(0,0.05,x_data.shape) # 起始值0 方差0.05 格式与x_data相同
y_data = np.square(x_data) - 0.5 + noise # x_datade平方减0.5加noise

with tf.name_scope('inputs'):
   xs = tf.placeholder(tf.float32,[None,1],name = 'x_input')
   ys = tf.placeholder(tf.float32,[None,1],name = 'y_input')

l1 = add_layer(xs,1,10,n_layer=1,activation_function=tf.nn.relu6) # 添加隐藏层 （input inputsize outputsize 激励方程）
prediction = add_layer(l1,10,1,n_layer=2,activation_function=None) # 添加输出层 （output inputsize outputsize 激励方程）

with tf.name_scope('loss'):
   loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), # 预测值与真实值的差别 求和 求平均值
                                    reduction_indices=[1]))
   tf.summary.scalar('loss',loss)
with tf.name_scope('train'):
   train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss) # 使用Adam/GradientDescentOptimizer优化器 学习效率0.1 作用是减小loss

init = tf.initialize_all_variables(); # 对所有的变量进行初试化
sess = tf.Session() # 定义Session
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(logdir='logs',graph=tf.get_default_graph())
writer.flush()
sess.run(init) # 运行初始化

for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i % 50 == 0:
        result = sess.run(merged,feed_dict={xs:x_data,ys:y_data})
    writer.add_summary(result,i)

fig = plt.figure() # 生成图片框
ax = fig.add_subplot(1,1,1) # 连续性的画图 编号
ax.scatter(x_data,y_data) # 将真实的数据显示
plt.ion() # 程序show一次以后不暂停，连续plot显示
plt.show() # 只能输出一次 然后将程序暂停

for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data}) # 以字典的形式传入值
    if i%50==0:
        # print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))
        try:  # 先将前一条线抹除 然后再输出下一条线
            ax.lines.remove(lines[0]) # 将前一条输出的线去除
        except Exception:  # 使用try是为了防止第一次抹除线的时候报错
            pass
        prediction_value = sess.run(prediction,feed_dict={xs:x_data}) # 获得预测的值
        lines = ax.plot(x_data,prediction_value,'r-',lw=5) # 将prediction的值用一条曲线的形式输出 红色的线 宽度为5
        plt.pause(0.1) # 在每次的过程中暂停0.1秒

plt.pause(0) # 解决图线显示完毕后，窗口自动关闭的问题

3.Classification 分类

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

mnist = input_data.read_data_sets('MNIST_data',one_hot=True) # 如果电脑上没有数据包的话会从网上下载，第二次运行时直接从包中运行数据

## add layers
def add_layer(intputs, in_size, out_size, activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))  # 权重 生成随机变量矩阵
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)  # 偏移 biases初始值推荐不为0，所以此处加上0.1
    Wx_plus_b = tf.matmul(intputs, Weights) + biases  # 输入值与随机变量矩阵相乘再加上偏移
    if activation_function is None:  # 如果激励函数是None的话说明是线性关系
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

### 计算准确度
def compute_accuracy(v_xs,v_ys):
    global prediction  # 将prediction定义成全局变量
    y_pre = sess.run(prediction,feed_dict={xs:v_xs})  # 将xs赋值给prediction生成预测值
    correct_prediction = tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1)) # 对比和真实数据的差别
                                                            # tf.argmax用来返回最大值所在的下标，0表示按列比较返回，1表示按行比较返回
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))  #
    result = sess.run(accuracy,feed_dict={xs:v_xs,ys:v_ys}) # 这里的result是一个百分比
    return result

### define placeholder for inputs to network
xs = tf.placeholder(tf.float32,[None,784]) # 每一张图片有784个像素点 28*28
ys = tf.placeholder(tf.float32,[None,10])

### add output layer
prediction = add_layer(xs,784,10,activation_function=tf.nn.softmax)  ## 输入xs 数据点784个 输出10个 softmax一般用于做分类

### the error between prediction and real data
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction), # softmax+cross_entropy做分类
                                              reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

sess = tf.Session()
sess.run(tf.initialize_all_variables())

for i in range(1000):
    batch_xs,batch_ys = mnist.train.next_batch(100) # 从下载好的数据中提取100个 提取一部分的xs和一部分的ys
    sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys})
    if i % 50 == 0:
        print(compute_accuracy(mnist.test.images,mnist.test.labels))  # 计算准确度

4.tensorflow解决过拟合问题

### tensorflow解决过拟合
import tensorflow as tf
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer

digits = load_digits()
X = digits.data  # 加载一个从0-9的一个数字的图片data
y = digits.target
y = LabelBinarizer().fit_transform(y) #有10个数字长度，如果y表示1的话就在第2个长度标为1
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = .3) #将X,y分成traingdata和testdata

# add layers
def add_layer(intputs, in_size, out_size, layer_name,activation_function=None,):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))  # 权重 生成随机变量矩阵
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1, name='b')  # 偏移 biases初始值推荐不为0，所以此处加上0.1
    Wx_plus_b = tf.matmul(intputs, Weights) + biases  # 输入值与随机变量矩阵相乘再加上偏移
    if activation_function is None:  # 如果激励函数是None的话说明是线性关系
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    tf.summary.histogram(layer_name+'/outputs',outputs)
    return outputs

### define placeholder for inputs to network
xs = tf.placeholder(tf.float32,[None,64])
ys = tf.placeholder(tf.float32,[None,10])

### add output layer
l1 = add_layer(xs,64,100,'l1',activation_function=tf.nn.softmax) # 隐藏层 输入xs 有64个输入 输出100个
prediction = add_layer(l1,100,10,'l2',activation_function=tf.nn.softmax) # 输出层 输入l1 有100个输入 输出10个

### the loss between prediction and real data
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction), # softmax+cross_entropy做分类
                                              reduction_indices=[1]))
tf.summary.scalar('loss',cross_entropy) # 将cross_entropy当做loss记录下来
train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)

sess = tf.Session()
merged = tf.summary.merge_all()

### summary writer goes in here
train_write = tf.summary.FileWriter(logdir='logs/train',graph=tf.get_default_graph())
test_write = tf.summary.FileWriter(logdir='logs/test',graph=tf.get_default_graph())

sess.run(tf.initialize_all_variables())
for i in range(500):
    sess.run(train_step,feed_dict={xs:X_train,ys:y_train})
    if i % 50 == 0:
        train_result = sess.run(merged,feed_dict={xs:X_train,ys:y_train})
        test_result = sess.run(merged,feed_dict={xs:X_test,ys:y_test})
        train_write.add_summary(train_result,i)
        test_write.add_summary(test_result,i)

三、相关问题整理：

1.Stochastic Gradient Descent (SGD)
将输出分批放入NN人工神经网络中学习，加速了NN的训练过程，同时也不会丢失太多的准确率。
2.过拟合现象通俗解释
机器学习过于自信已经达到了自负的地步，在自己的小圈子里表现非凡，在现实的大圈子里处处碰壁。
3.如何解决过拟合现象
(1)增加数据量
(2)正则化：
L1:cost = (Wx-real y)^2+abs(W)
L2:cost = (Wx-real y)^2 +W^2
4.Dropout regulatization
对神经网络Dropout regulatization在训练是随机忽略掉一些神经元和一些连接，使神经网络变得不完整，用不完整的神经网络训练一次，到第二次再随机忽略一些，变成另一个不完整的神经网络，多次重复，这样就不会使每一次预测的结果都只依赖于那一部分神经元，从而解决过拟合问题。
5.卷积神经网络CNN
卷积神经网络CNN常被应用于计算机图像识别、视频分析、自然语言处理、药物发现。
(1)卷积——不再是对单个像素的处理，而是对每一小块像素区域的处理，这样加强了对图像信息的连续性，使得神经网络能看到图形而非一个点，这样做也加深了神经网络对图像的理解。
(2)神经网络——神经网络是由一连串的神经层组成，每一层神经层存在很多的神经元，这些神经元是神经网络识别事务的关键，每一种神经网络都会有他的输入和输出值，当输入值为图片时，实际上输入神经网络的并不是图片，而是数字。
(3)卷积神经网络有一个批量过滤器，不断在图片上滚动收集信息，每次收集的信息只来自一小块像素区域，然后将收集来的信息进行整理，整理出来的信息有了实际上的呈现，这样使得神经网络能够看到边缘的图片信息，然后以同样的步骤扫描边缘信息，从而识别出更高层的信息。再套入普通的神经网络进行分类，这样就能得到分类结果。在卷积过程中，高度不断增高，长宽不断压缩从而可能会丢失一些信息，便需要通过池化解决这样的问题。在卷积的时候不压缩长宽，尽量保留更多信息，压缩工作交给池化，提高准确性。
(4)常见步骤：输入图片->卷积->池化->卷积->池化->神经层->神经层->分类器