tensorflow-莫凡

#tensorflow代码形式
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
#create data
x_data=np.random.rand(100).astype(np.float32)
y_data=x_data*0.1+0.3

####create tensorflow structure start####
#一维结构,生成范围是-1到1
Weights=tf.Variable(tf.random_uniform([1],-1.0,1.0))
biases=tf.Variable(tf.zeros([1]))

y=Weights*x_data+biases

#预测的y与真实的y的差别
loss=tf.reduce_mean(tf.square(y-y_data))
#优化器减少误差,有多种优化器我们选择最基础的
optimizer=tf.train.GradientDescentOptimizer(0.5)
train=optimizer.minimize(loss)

init=tf.initialize_all_variables()

####create tensorflow structure start####
#结构激活,初始化
sess=tf.Session()
sess.run(init)#Very important
for step in range(201):
    sess.run(train)
    if step%20==0:
        print(step,sess.run(Weights),sess.run(biases))

输出:
0 [0.2695405] [0.28008825]
20 [0.14046107] [0.2800137]
40 [0.11135352] [0.29439178]
60 [0.10318584] [0.29842633]
80 [0.10089399] [0.29955843]
100 [0.10025086] [0.2998761]
120 [0.1000704] [0.29996523]
140 [0.10001976] [0.29999027]
160 [0.10000557] [0.29999727]
180 [0.1000016] [0.29999924]
200 [0.10000046] [0.29999977]

#Session会话控制
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
matrix1=tf.constant([[3,3]])
matrix2=tf.constant([[2],
                     [2]])
product=tf.matmul(matrix1,matrix2)#matrix multiply np.dot(m1,m2)

#两种形式用Session控制
#Method 1
# sess=tf.Session()
# result=sess.run(product)
# print(result)
# sess.close()

#Method2
#打开了session,不用去管有没有关上
#自动帮你关闭了
with tf.Session() as sess:
    result2=sess.run(product)
    print(result2)

输出:
[[12]]

#Variable变量
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
#给定变量初始值和名字
state=tf.Variable(0,name='counter')
# print(state.name)
one=tf.constant(1)
new_value=tf.add(state,one)
#把new_value这个对象加载到了state上面,state=new_value
update=tf.assign(state,new_value)
init=tf.initialize_all_variables()#must have if define variable

with tf.Session() as sess:
    sess.run(init)
    for _ in range(3):
        sess.run(update)
        print(sess.run(state))

输出:
1
2
3

#placeholder传入值,在开始时hold住,run之后从外界传入
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
input1=tf.placeholder(tf.float32)
input2=tf.placeholder(tf.float32)

output=tf.multiply(input1,input2)

with tf.Session() as sess:
    #placeholder是要传入的值需要通过,feed_dict的字典传入
    print(sess.run(output,feed_dict={
   input1:[7.],input2:[2.]}))

输出:
[14.]

#为什么需要激励函数?就是为了解决日程生活中不能用线性方程解决的事情
'''
线性问题与非线性问题
y=Wx
W是我们需要的参数,x是输入值,y是输出值
y=AF(Wx) AF:激励函数,掰弯直线
AF():relu,sigmoid,tanh
可以自己创建激励函数,但是要确保这些激励函数是可微分的
当你的隐藏层只有两三层时可以使用任意的激励函数,当有很多层隐藏层时不可随意使用激励函数,需要考虑
如何抉择?
在少量层结构中我们可以有多种选择,
在卷积神经网络中推荐使用relu
在循环神经网络RNN中推荐的是relu或者tanh
'''

#激励函数
#想知道有哪些activation function时,可以搜索百度
#def添加层
import tensorflow.compat.v1 as tf
import numpy as np
tf.disable_v2_behavior()
def add_layer(inputs,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)
    Wx_plus_b=tf.matmul(inputs,Weights)+biases
    if activation_function is None:
        outputs=Wx_plus_b
    else:
        outputs=activation_function(Wx_plus_b)
    return outputs

x_data=np.linspace(-1,1,200)[:,np.newaxis]
noise=np.random.normal(0,0.05,x_data.shape)
y_data=np.square(x_data)-0.5+noise
xs=tf.placeholder(tf.float32,[None,1])
ys=tf.placeholder(tf.float32,[None,1])
#定义隐藏层
l1=add_layer(xs,1,10,activation_function=tf.nn.relu)
#定义输出层
prediction=add_layer(l1,10,1,activation_function=None)
#预测值与真实值的差别,对所有求和的值求一个平均值
loss=tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),reduction_indices=[1]))
#如何去练习,参数是学习率,小于1
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)
#对所有的变量进行初始
init=tf.initialize_all_variables()
sess=tf.Session()
sess.run(init)

for i in range(1000):
    sess.run(train_step,feed_dict={
   xs:x_data,ys:y_data})