6_逻辑回归拟合二维数据-找 y=2x 的规律

文章目录

• ​​一、题目：混乱的数据中找 y=2x 的规律​​

• ​​1、随机函数​​
• ​​2、准备训练数据​​
• ​​3、神经网络训练​​
• ​​4、总结问题:​​

一、题目：混乱的数据中找 y=2x 的规律

1、随机函数

# (1) numpy.random.rand(c,r) #生成0-1之间,c行r列
# (2) numpy.random.randn()  #正太分布
# (3) numpy.random.randint(low, high=None, size=None, dtype=’l’)  正太
'''
返回随机整数，范围区间为[low,high），包含low，不包含high
参数：low为最小值，high为最大值，size为数组维度大小，dtype为数据类型，默认的数据类型是np.int
high没有填写时，默认生成随机数的范围是[0，low)
'''
a = np.random.rand(4,2) 
print(a, '\n______\n')

a = np.random.randn(2,4)
print(a, '\n______\n')

a = np.random.randint(-5,5,size=(2,2))
print(a)

[[0.89389775 0.64800302]
 [0.31295588 0.42463888]
 [0.63642806 0.61083627]
 [0.15232416 0.01857432]] 
______

[[-1.42809966 -1.06904246  1.07176606 -0.08966346]
 [ 0.70358473  0.31523783 -0.53473004  0.34234035]] 
______

[[ 0 -2]
 [ 0  3]]

2、准备训练数据

import numpy as np
import pandas as pd
from pandas import Series,DataFrame#多维数组

import matplotlib.pyplot as plt
%matplotlib inline #用于在jupyter中显示
seed=24
rdm = np.random.RandomState(seed)#随机数生成器
train_X = np.linspace(-1,1,100)
train_Y =[ [ 2*x + (rdm.rand()/10.0  - 0.05) ] for x in X ] 
#rand 构造0-1 随机数, 除10以后,构造0-0.1的随机数, 在减0.05变成-0.05 - 0.05

plt.plot(train_X,train_Y, 'ro',label='Original data')
plt.legend() #增加标签等图标
plt.show()

3、神经网络训练

'''总结注意:
训练数据 train_X, train_Y
正向输入 in_x, in_y
正向输出 out_y

loss计算 in_y - out_y
'''

import tensorflow as tf
import numpy as np
import pandas as pd
from pandas import Series,DataFrame#多维数组

import matplotlib.pyplot as plt
%matplotlib inline 
#用于在jupyter中显示

#准备数据 训练集
seed=24
rdm = np.random.RandomState(seed)#随机数生成器
train_X = np.linspace(-1,1,100)
train_Y =[ [ 2*x + (rdm.rand()/10.0  - 0.05) ] for x in X ] 
#rand 构造0-1 随机数, 除10以后,构造0-0.1的随机数, 在减0.05变成-0.05 - 0.05随机数
#即噪声是 y=2x+(正负0.05)

# print(train_X,"\n\n\n",train_Y)

def sess_run(s):
    with tf.Session() as sess:
        init = tf.global_variables_initializer()
        sess.run(init)
        print(sess.run(s))

#前向结构
in_x = tf.placeholder("float")
in_y = tf.placeholder("float")  #注意注意,这里不能对于一维输入的时候一定要改成"float"空类型,为什么呢?因为一维在tensorflow中无法计算,会在后面程序中报错
# in_x = tf.placeholder(tf.float32, shape=(None,1))  
# in_y = tf.placeholder(tf.float32, shape=(None,1))

#模型参数
w = tf.Variable(tf.random_normal([1], name="weight", seed=1, stddev=1) )
b = tf.Variable(tf.zeros([1]), name="bias")
# 参数显示
sess_run(w)
sess_run(b)

#前向结构
out_y = tf.multiply(in_x,w)+b
print(out_y)
# sess_run(out_y)

# 反向优化
loss = tf.reduce_mean(tf.square(in_y-out_y))  #计算损失
learning_rate = 0.01  #微调率
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) #梯度下降算法
training_steps = 100
batch_size = 2
#启动session
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    plot_data = {"batchsize":[], "loss":[]} ##存放批次值和损失值
    for i in range(training_steps): ###向模型输入数据 训练了training_steps*100=20,00次
        # #方法1
        # for i in range(100):#数据0-99训练
        #     sess.run(train_step, feed_dict={in_x:train_X[i], in_y:train_Y[i]}) 
        
        # #方法2
        # for (x,y) in zip(train_X,train_Y):  #100组数据压缩成(x,y_) 进行训练100个数据训练一次
        #     sess.run(train_step, feed_dict={in_x:x, in_y:y})


        # # 注意,这里方法3,4有问题,
        # #方法3
        # sess.run(train_step, feed_dict={in_x:train_X[0:100], in_y:train_Y[0:100]})
         
        #方法4    
        start = (i*batch_size)%100                      #0   10   20
        end = (i*batch_size)%100 + batch_size           #10  20   30
        sess.run(train_step, feed_dict={in_x:train_X[start:end], in_y:train_Y[start:end]}) #训练32个数据中8个数据
        #打印损失 
        # loss_ = sess.run(loss, feed_dict={in_x:x, in_y:y})
        # if loss_ > 0.0005 :
        #      print(loss_)
        # else:
        #     break;
   
    print("w=",sess.run(w),"\nb=",sess.run(b))

[-0.8113182]
[0.]
Tensor("add_82:0", dtype=float32)
w= [0.53533095] 
b= [0.22387224]

4、总结问题:

问题1 tensorflow中不能使用一维进行运算,不然会出错
所以定义数据的时候​​​in_x = tf.placeholder("float")​​

问题2 在训练的时候,
有四种反向训练方法:

下面是循环一次的程序:

#方法1 将所有数据喂入,循环20次就能得到很好结果
for i in range(100):#数据0-99训练
    sess.run(train_step, feed_dict={in_x:train_X[i], in_y:train_Y[i]}) 

#方法2 将所有数据喂入,循环20次就能得到很好结果
for (x,y) in zip(train_X,train_Y):  
    sess.run(train_step, feed_dict={in_x:x, in_y:y})

#方法3  将每次喂入100,但是结果不太好,循环20次就能得到很好结果
sess.run(train_step, feed_dict={in_x:train_X[0:100], in_y:train_Y[0:100]})

#方法4  #每次喂食10个,循环20次,得不到想要的趋势结果,加大大循环后能改善,但不好
start = (i*batch_size)%100                      #0   10   20
end = (i*batch_size)%100 + batch_size           #10  20   30
sess.run(train_step, feed_dict={in_x:train_X[start:end], in_y:train_Y[start:end]}) #训练32个数据中8个数据

所以 每次小训练数据集,可以直接把数据进行喂食,增加效率,
如果每次分几份喂食,需要增加大循环,