190603-函数拟合的实现

基础知识：

1》发现看了好久没看懂，终明白python基础不够牢固，导致犯错，还是一点点实验出来了。

对于想要表述 数组 array = np.random可以产生，但是 请注意，这个 不同于tensorflow里面的矩阵。

tensorflow 里面矩阵  matrix1 =【3，4】matirx2=【1，4】 是可以直接相加的，matrix3=matrix1+matrix2

则matrix3是【3，4】。内部是按照column方向 把每个matirx2加到matrix1上的没行的单个值上去。所以可以利用之来计算bias用。而python中，直接利用【3，4】的数组结论是，又新加了一个数组元素。

另外

tensorflow里面 矩阵，要 tf.constant    tf.random_normal   tf.zeros 等

注意 输出 必须按照规定，sess .run ,不然 print 只会打印输出类型。

2》注意输入一般作为列向量输入习惯性reshap（n，1）.

3》对于输入变量，需要定义类型 tf。placeholder（tf。float，shape=【】）

4》理解tensor结构，对于内部 tf。variable的变量，后面一定要加上 

init= tf.global_variables_initializer()而sess。run（init）后生效。

5》 sess。run（）的函数要注意， feed——dict可以添加字典里面输入。

6》tf的 其他运算 点加 tf.add  点减 tf.subtract 点成tf.multiply 矩阵乘，tf。matmul

 

 

多项式拟合代码如下：

# import  numpy as  np
# import tensorflow as tf
# array1 = tf.constant([[1,1,1],[3,3,3]]) #tf.random_normal([3,4])
# array2 =tf.constant([[2,3,4]])#tf.zeros([3,1])+0.1
# sess = tf.Session()
#
# print(sess.run(array1))
# print(sess.run(array2))
# print(sess.run(array1 +array2))

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



x_data= np.linspace(0,1.0,200).reshape(200,1)
#print(np.random.normal(0,0.1,100))
# y_data=2*np.sin(2*np.pi*x_data+200)+3#np.random.normal(0,0.1,100).reshape(100,1)
y_data=np.sin(2*np.pi*x_data)#+np.random.normal(0,0.1,200).reshape(200,1)
#print(x_data)
'''
inputs :
in-size：


'''
def  add_layer(inputs,in_size,out_size,activation_function =None):
    weight= tf.Variable(tf.random_normal([in_size,out_size]))#先初始化上空间 ，其中初始化值为 insize outsize的大小shape的均值为0，标准差为1的正态分布数据。注意后面要global variblses 初始化
   # print(weight)
    bias= tf.Variable(tf.zeros([1,out_size])+0.1)# 每个输出对应一个bias
    #print(bias)
    layer1= tf.matmul(inputs,weight)+bias  # tf.multiply 是元素的点乘，而 tf。matmul是矩阵的相乘
    #print(layer1)
    if activation_function is None:
        return layer1
    else:
        return  activation_function(layer1)


def   predict_fun(input):

    l1 = add_layer(input, 1, 30, tf.nn.relu)
    l2 = add_layer(l1, 30, 15, tf.nn.relu)
    # l3= add_layer(l2,25,10,tf.nn.relu)
    # l1= add_layer(xs,1,20,tf.nn.relu)
    # l2= add_layer(l1,20,10,tf.nn.relu)
    output2 = add_layer(l2, 15, 1, tf.tanh)
    return output2
'''
define  network  structure

'''

xs = tf.placeholder(tf.float32,[None,1])
ys= tf.placeholder(tf.float32,[None,1])



l1= add_layer(xs,1,30,tf.nn.relu)
l2= add_layer(l1,30,15,tf.nn.relu)
#l3= add_layer(l2,25,10,tf.nn.relu)
# l1= add_layer(xs,1,20,tf.nn.relu)
# l2= add_layer(l1,20,10,tf.nn.relu)
output=add_layer(l2,15,1,tf.tanh)


# 此处验证未拟合区域外是否有用，发现只对此拟合区间有用。外部区间都是无效的！
test_input = np.linspace(0.5,1.5,200).reshape(200,1)

predict_funvalue=predict_fun(xs)

'''
define loss function
'''
learingrate=tf.placeholder(tf.float32,shape=[])


loss = tf.reduce_mean(tf.square(output-ys))
train = tf.train.AdagradOptimizer(learning_rate=learingrate).minimize(loss)#AdagradOptimizer  AdamOptimizer GradientDescentOptimizer  learning_rate=learingrate
# train = tf.train.GradientDescentOptimizer(learning_rate=learingrate).minimize(loss)
# loss2 = tf.reduce_mean(tf.square(output-y_data))
# train2 = tf.train.GradientDescentOptimizer(0.0003).minimize(loss2)
init= tf.global_variables_initializer()

# start to  train
with  tf.Session() as sess:
    sess.run(init)#初始化 all tf.variable 不用申请空间了，是全局变量独立变量，而全局单个变量需要tf.palceholder（tf.float，shape=【None，1】表示不确定rows数目）初始化。
    cur_loss =999
    use_loss=0.09
    for i in range(10000):
        date1 =datetime.datetime.now().microsecond
        sess.run(train,feed_dict={ xs:x_data,ys:y_data,learingrate:use_loss})#0.1
        #sess.run(train, feed_dict={xs: x_data, ys: y_data, learingrate: 0.04})
        date2 = (datetime.datetime.now().microsecond)
        date_span=(date2-date1)/1000
        if i%49 ==0:
            last_loss = cur_loss
            cur_loss=sess.run(loss, feed_dict={xs:x_data,ys:y_data})
            #fdis_loss=math.fabs(cur_loss-last_loss)

            print("%s%s%s"%(cur_loss,'__',str(date_span)))
            if (cur_loss <= 0.0008):
                use_loss = 0.7 * use_loss#此处 看是否根据loss 可以更改 learning_rate 失败


    plt.plot(x_data,sess.run(output,feed_dict={xs:x_data}))
    #sess.run(predict_fun,feed_dict={xs:test_input})
    plt.plot(test_input,sess.run(output,feed_dict={xs:test_input}))



plt.scatter(x_data,y_data,marker='o')#x y  画点样式
plt.show()

总结 验证数据来看，能满足部分拟合需求

问题点，1，输入函数增加偏移（x，y）后，learning rate 很难学习。

问题点，2，网络深度变化很大后，也不好收敛。

问题点，3，学习率 调节，需要仔细学习，如何使用 AdagradOptimizer AdamOptimizer

 

后期计划：

1，keras 跑通vgg 网络。

2，tensorflow 跑通 resnet网络。

3，进一步掌握理论知识。