【tensorflow笔记视频课】的笔记大集合

时间 2019-12-04

原文原文链接

这篇文章记录我所看的视频课【tensorflow笔记】的代码，这些代码并非课上讲的代码，而是我本身听了课以后根据本身的想法敲写的，因此不是100%还原老师的代码。python

1.前向传播

一个很简单很简单的前向传播例子数组

import numpy as np
import tensorflow as tf

#生成输入数据
x_data=np.random.rand(100)
y_data=0.2*x_data+0.1

#前向传播
k=0.5
b=0.3
x=tf.placeholder(tf.float32)
y=k*x+b

#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(y,feed_dict={x:x_data}))

2.反向传播

一个很简单很简单的反向传播的例子网络

import numpy as np
import tensorflow as tf

#生成输入数据
x_data=np.random.rand(100)
y_data=0.2*x_data+0.1

#前向传播
k=tf.Variable(0.5)
b=tf.Variable(0.3)
y=tf.Variable(0)
y=k*x_data+b

#反向传播
error=y-y_data
loss=tf.reduce_mean(tf.square(error))
optimizer=tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for i in range(200):
        sess.run(optimizer)
        if i%20==0:
            print(sess.run([k,b,loss]))

下面也是反向传播，但这个代码比上面那个有难度提高,由于咱们开始使用权重矩阵app

import numpy as np
import tensorflow as tf

#输入数据
x_data= np.random.rand(32,2)
y_data=[[x1+x2+(rmd.rand()/10.0-0.05)] for (x1,x2) in x_data]
"""这行代码与下句等同
y=[]
for [x1,x2] in x:
    y.append([x1+x2+(np.random.rand()/10-0.05)])
"""

#前向传播
x=tf.placeholder(tf.float32,shape=(None,2))
y=tf.placeholder(tf.float32,shape=(None,1))
w1= tf.Variable(tf.random_normal([2, 1]))#正态分布
z= tf.matmul(x, w1)#点积

#反向传播
loss=tf.reduce_mean(tf.square(z-y))
optimizer=tf.train.GradientDescentOptimizer(0.002).minimize(loss)

#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for i in range(20000):
        sess.run(optimizer,feed_dict={x:x_data,y:y_data})
        if i%5000==0:
            print(f"第{i}次训练结果：")
            print(sess.run(w1))
    print("最终结果：\n",sess.run(w1))

3.损失函数

损失函数不少，你能够本身写，也能够用经典的损失函数（线性回归、sigmoid、softmax）dom

经典的线性回归上面两个代码咱们已经用了，此次写一下本身定义的损失函数：函数

import tensorflow as tf

w=tf.Variable(5.)
loss=tf.square(w+1)
optimizer=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
inti=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(inti)
    for i  in range(50):
        sess.run(optimizer)
        print(sess.run([w,loss]))

能够看到，loss是本身定义的函数，而不是经典的三大金刚。loss能够随便定义，你想要的啥就写啥，这里方便理解因此写了个最简单的loss=（w+1）^2，在实际问题中确定不会这么简单。学习

4.学习率

这个就不写代码了，就是在使用各类优化器的时候要设定学习率，就是反向传播一次更新的程度大小。优化

学习率的设置也有讲究，小了更新慢，大了会爆炸，因此咱们说一下怎么设置学习率：编码

在实际编码时，咱们一般使用【指数衰减学习率】：spa

这是指数衰减学习率的公式，你能够不太懂它的含义，只要你会敲代码就能够

代码以下：

globe_step=tf.Variable(0，trainable=False) #计数器，用来记录当前运行了几轮batch_size，该参数不参与训练，因此trainable=False

learning_rate=tf.train.exponential_decay(

LEARNING_RATE_BASE, #学习率初始值

globe_step, #计数器

LEARNING_RATE_STEP, #学习率更新周期，值为总样本数÷batch_size样本数

LEARNING_RATE_DECAY, #学习率衰减率

staircase=True #True表示以不连续的间隔衰减学习速率，最后曲线是锯齿状

                                                       False表示以连续的间隔衰减学习速率，最后曲线是光滑状
)

在训练时，要求在tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step)的minimize里写上global_step

实际应用以下：

import tensorflow as tf

#设置learning_rate
global_step=tf.Variable(0，trainable=False)
LEARNING_RATE_BASE=0.1
LEARNING_RATE_STEP=1
LEARNING_RATE_DECAY=0.99
learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,LEARNING_RATE_STEP,LEARNING_RATE_DECAY,staircase=True)

#设置训练数据
w=tf.Variable(5.)
#设置损失函数
loss=tf.square(w+1)
#设置优化器
optimize=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step)
#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for i  in range(40):
        sess.run(optimize)
        learning_rate_val=sess.run(learning_rate)
        global_step_val=sess.run(global_step)
        w_val=sess.run(w)
        loss_val=sess.run(loss)
        print(f"通过{i}步，当前global_step为{ global_step_val}，w为{w_val}，learning_rate为{learning_rate_val}，loss为{loss_val}")

必定多多留意独特之处！

5.正则化

咱们用正则化来缓解泛化效果差的问题，就是给权重一个矩阵，加在loss上。

如图所示，正则化后的loss，是原来的loss再加上正则化项，正则化项就是正则化参数*loss（w），这个，跟吴恩达讲的如出一辙。

正则化项的表示代码为tf.contrib.layers.l2_regularizer（lambda）(w)，其中lambda是正则化参数，w是权重

tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(lambda)(w)) #把正则化项放入一个名为"losses"的集合器里面，咱们打算用这个losses来表示整个正则化项了。

loss=cem+tf.add_n(tf.get_collection("losses")) #cem是原来的loss，如今把正则化项和以前的最原始的loss加在一块儿，就获得了正则化后的loss

ok，你可能看不懂，问“为何要这么麻烦？直接把正则化项加进cem不就好了吗？”是的，我也不懂为何，但就是这样的一环套一环，你还就真得按照这个代码去操做，否则你作不出来。

下面看代码：