TensorFlow案例实现线性回归

一、线性回归原理复习

根据数据建立回归模型，w1x1+w2x2+…..+b = y，通过真实值与预测值之间建立误差，使用梯度下降优化得到损失最小对应的权重和偏置。最终确定模型的权重和偏置参数。最后可以用这些参数进行预测。

二、 案例：实现线性回归的训练

1 案例确定

  • 假设随机指定100个点，只有一个特征
  • 数据本身的分布为 y = 0.8 * x + 0.7   【目标值：（100，1）】

这里将数据分布的规律确定，是为了使我们训练出的参数跟真实的参数（即0.8和0.7）比较是否训练准确

2 API

运算

  • 矩阵运算

    • tf.matmul(x, w)
  • 平方
    • tf.square(error)
  • 均值
    • tf.reduce_mean(error)

梯度下降优化

  • tf.train.GradientDescentOptimizer(learning_rate)

    • 梯度下降优化
    • learning_rate:学习率，一般为0~1之间比较小的值
    • method:
      • minimize(loss)
    • return:梯度下降op

3 步骤分析

  • 1 准备好数据集：y = 0.8x + 0.7 100个样本
  • 2 建立线性模型
    • 随机初始化W1和b1
    • y = W·X + b，目标：求出权重W和偏置b
  • 3 确定损失函数（预测值与真实值之间的误差）-均方误差
  • 4 梯度下降优化损失：需要指定学习率（超参数）

4 实现完整功能

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()def linear_regression():"""自实现线性回归:return: None"""# 1）准备好数据集：y = 0.8x + 0.7 100个样本# 特征值X, 目标值y_true# X = tf.random_normal(shape=(100, 1), mean=2, stddev=2)X = tf.random_normal([100, 1], mean=2, stddev=2)  # 创建随机值# y_true [100, 1]# 矩阵运算 X（100， 1）* （1, 1）= y_true(100, 1)y_true = tf.matmul(X, [[0.8]]) + 0.7  # 0.8这儿必须为二维，0.7可以是一维也可以写成二维# 2）建立线性模型：# y = W·X + b，目标：求出权重W和偏置b# 3）随机初始化W1和b1weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)))bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)))y_predict = tf.matmul(X, weights) + bias# 4）确定损失函数（预测值与真实值之间的误差）-均方误差error = tf.reduce_mean(tf.square(y_predict - y_true))# 5）梯度下降优化损失：需要指定学习率（超参数）# W2 = W1 - 学习率*(方向)# b2 = b1 - 学习率*(方向)optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)# 初始化变量init = tf.global_variables_initializer()# 开启会话进行训练with tf.Session() as sess:# 运行初始化变量Opsess.run(init)print("随机初始化的误差为%f，权重为%f， 偏置为%f" % (error.eval(), weights.eval(), bias.eval()))# 训练模型for i in range(100):sess.run(optimizer)print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))return Noneif __name__ == '__main__':linear_regression()

运行结果：

随机初始化的误差为7.773322，权重为-0.212747， 偏置为0.884827
第0步的误差为4.815594，权重为-0.074699， 偏置为0.918272
第1步的误差为2.619761，权重为0.080444， 偏置为0.950326
第2步的误差为2.033056，权重为0.187189， 偏置为0.971529
第3步的误差为1.803145，权重为0.271290， 偏置为0.990429
第4步的误差为1.147095，权重为0.343569， 偏置为1.005391
第5步的误差为0.803679，权重为0.407767， 偏置为1.017047
第6步的误差为0.545470，权重为0.465699， 偏置为1.027499
第7步的误差为0.376635，权重为0.513037， 偏置为1.035914
第8步的误差为0.336842，权重为0.545470， 偏置为1.039430
第9步的误差为0.217684，权重为0.578870， 偏置为1.044094
第10步的误差为0.144806，权重为0.594635， 偏置为1.044822
第11步的误差为0.165971，权重为0.612733， 偏置为1.046348
第12步的误差为0.139431，权重为0.631174， 偏置为1.046949
第13步的误差为0.086250，权重为0.642149， 偏置为1.046527
第14步的误差为0.085132，权重为0.649926， 偏置为1.045400
第15步的误差为0.082908，权重为0.657033， 偏置为1.043817
第16步的误差为0.081036，权重为0.666152， 偏置为1.042497
第17步的误差为0.074553，权重为0.673889， 偏置为1.041330
第18步的误差为0.054156，权重为0.677402， 偏置为1.039436
第19步的误差为0.073959，权重为0.684212， 偏置为1.037369
第20步的误差为0.067132，权重为0.688650， 偏置为1.035273
第21步的误差为0.063169，权重为0.693729， 偏置为1.032965
第22步的误差为0.044506，权重为0.698360， 偏置为1.031106
第23步的误差为0.055696，权重为0.700605， 偏置为1.028787
第24步的误差为0.049010，权重为0.705399， 偏置为1.026892
第25步的误差为0.051410，权重为0.707697， 偏置为1.024003
第26步的误差为0.046112，权重为0.709559， 偏置为1.020797
第27步的误差为0.055039，权重为0.711324， 偏置为1.017873
第28步的误差为0.050088，权重为0.712943， 偏置为1.015389
第29步的误差为0.044799，权重为0.714413， 偏置为1.012602
第30步的误差为0.042782，权重为0.714907， 偏置为1.009804
第31步的误差为0.043166，权重为0.716352， 偏置为1.006835
第32步的误差为0.045090，权重为0.717065， 偏置为1.003435
第33步的误差为0.050845，权重为0.717171， 偏置为1.000764
第34步的误差为0.036358，权重为0.718776， 偏置为0.998129
第35步的误差为0.045834，权重为0.719806， 偏置为0.995273
第36步的误差为0.044990，权重为0.719486， 偏置为0.992540
第37步的误差为0.040462，权重为0.720859， 偏置为0.989510
第38步的误差为0.040012，权重为0.723555， 偏置为0.986553
第39步的误差为0.035847，权重为0.725622， 偏置为0.983762
第40步的误差为0.036552，权重为0.726999， 偏置为0.981095
第41步的误差为0.047176，权重为0.726844， 偏置为0.978427
第42步的误差为0.042962，权重为0.728186， 偏置为0.975429
第43步的误差为0.047222，权重为0.727841， 偏置为0.972642
第44步的误差为0.034721，权重为0.728302， 偏置为0.970336
第45步的误差为0.038195，权重为0.727074， 偏置为0.968250
第46步的误差为0.033055，权重为0.728332， 偏置为0.965310
第47步的误差为0.026506，权重为0.728969， 偏置为0.963041
第48步的误差为0.031521，权重为0.729887， 偏置为0.960638
第49步的误差为0.043619，权重为0.731416， 偏置为0.957871
第50步的误差为0.023284，权重为0.732142， 偏置为0.955256
第51步的误差为0.032686，权重为0.733541， 偏置为0.952259
第52步的误差为0.032251，权重为0.734592， 偏置为0.949685
第53步的误差为0.036002，权重为0.735437， 偏置为0.947663
第54步的误差为0.037952，权重为0.736220， 偏置为0.945805
第55步的误差为0.028753，权重为0.736165， 偏置为0.943738
第56步的误差为0.034930，权重为0.735949， 偏置为0.941624
第57步的误差为0.026341，权重为0.736223， 偏置为0.939461
第58步的误差为0.025755，权重为0.736038， 偏置为0.936993
第59步的误差为0.023551，权重为0.736207， 偏置为0.934304
第60步的误差为0.030404，权重为0.736685， 偏置为0.932626
第61步的误差为0.027402，权重为0.736908， 偏置为0.930603
第62步的误差为0.022186，权重为0.738053， 偏置为0.928665
第63步的误差为0.022336，权重为0.739519， 偏置为0.927060
第64步的误差为0.023993，权重为0.739449， 偏置为0.924894
第65步的误差为0.026335，权重为0.740695， 偏置为0.922579
第66步的误差为0.022487，权重为0.740502， 偏置为0.920384
第67步的误差为0.024735，权重为0.741029， 偏置为0.917981
第68步的误差为0.023723，权重为0.742167， 偏置为0.916049
第69步的误差为0.032243，权重为0.743059， 偏置为0.914224
第70步的误差为0.018754，权重为0.744108， 偏置为0.912141
第71步的误差为0.019670，权重为0.744172， 偏置为0.910031
第72步的误差为0.017146，权重为0.744423， 偏置为0.907396
第73步的误差为0.024280，权重为0.744120， 偏置为0.905332
第74步的误差为0.021038，权重为0.743687， 偏置为0.903290
第75步的误差为0.017437，权重为0.744222， 偏置为0.901485
第76步的误差为0.022692，权重为0.744974， 偏置为0.899838
第77步的误差为0.022184，权重为0.746434， 偏置为0.897599
第78步的误差为0.017884，权重为0.746657， 偏置为0.895587
第79步的误差为0.018042，权重为0.747113， 偏置为0.893710
第80步的误差为0.021061，权重为0.747263， 偏置为0.891911
第81步的误差为0.015934，权重为0.748294， 偏置为0.890364
第82步的误差为0.016767，权重为0.747729， 偏置为0.888662
第83步的误差为0.016338，权重为0.748594， 偏置为0.886814
第84步的误差为0.016412，权重为0.749916， 偏置为0.885182
第85步的误差为0.016987，权重为0.750615， 偏置为0.883342
第86步的误差为0.018259，权重为0.751050， 偏置为0.881954
第87步的误差为0.019765，权重为0.751157， 偏置为0.880394
第88步的误差为0.013741，权重为0.751355， 偏置为0.878981
第89步的误差为0.014090，权重为0.752010， 偏置为0.877496
第90步的误差为0.017325，权重为0.752403， 偏置为0.876005
第91步的误差为0.018089，权重为0.752880， 偏置为0.874484
第92步的误差为0.015514，权重为0.752784， 偏置为0.873067
第93步的误差为0.013994，权重为0.752586， 偏置为0.871653
第94步的误差为0.017090，权重为0.753213， 偏置为0.869959
第95步的误差为0.015206，权重为0.754160， 偏置为0.868416
第96步的误差为0.012254，权重为0.754975， 偏置为0.866973
第97步的误差为0.014603，权重为0.755242， 偏置为0.865173
第98步的误差为0.013182，权重为0.755367， 偏置为0.863995
第99步的误差为0.012373，权重为0.756309， 偏置为0.862325

5 变量的trainable设置观察

trainable的参数作用，指定是否训练

weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0), name="weights", trainable=False)

示例代码：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()def linear_regression():"""自实现线性回归:return: None"""# 1）准备好数据集：y = 0.8x + 0.7 100个样本# 特征值X, 目标值y_true# X = tf.random_normal(shape=(100, 1), mean=2, stddev=2)X = tf.random_normal([100, 1], mean=2, stddev=2)  # 创建随机值# y_true [100, 1]# 矩阵运算 X（100， 1）* （1, 1）= y_true(100, 1)y_true = tf.matmul(X, [[0.8]]) + 0.7  # 0.8这儿必须为二维，0.7可以是一维也可以写成二维# 2）建立线性模型：# y = W·X + b，目标：求出权重W和偏置b# 3）随机初始化W1和b1weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name='weights', trainable=False)bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)))y_predict = tf.matmul(X, weights) + bias# 4）确定损失函数（预测值与真实值之间的误差）-均方误差error = tf.reduce_mean(tf.square(y_predict - y_true))# 5）梯度下降优化损失：需要指定学习率（超参数）# W2 = W1 - 学习率*(方向)# b2 = b1 - 学习率*(方向)optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)# 初始化变量init = tf.global_variables_initializer()# 开启会话进行训练with tf.Session() as sess:# 运行初始化变量Opsess.run(init)print("随机初始化的误差为%f，权重为%f， 偏置为%f" % (error.eval(), weights.eval(), bias.eval()))# 训练模型for i in range(100):sess.run(optimizer)print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))return Noneif __name__ == '__main__':linear_regression()

运行结果：

随机初始化的误差为17.879795，权重为-0.517865， 偏置为0.231038
第0步的误差为17.547358，权重为-0.517865， 偏置为0.301101
第1步的误差为15.616703，权重为-0.517865， 偏置为0.353942
第2步的误差为15.548039，权重为-0.517865， 偏置为0.411972
第3步的误差为15.843994，权重为-0.517865， 偏置为0.466720
第4步的误差为12.011563，权重为-0.517865， 偏置为0.522920
第5步的误差为13.509573，权重为-0.517865， 偏置为0.584860
第6步的误差为14.762997，权重为-0.517865， 偏置为0.648481
第7步的误差为12.738248，权重为-0.517865， 偏置为0.709262
第8步的误差为11.600702，权重为-0.517865， 偏置为0.751506
第9步的误差为16.219429，权重为-0.517865， 偏置为0.811426
第10步的误差为16.273335，权重为-0.517865， 偏置为0.864308
第11步的误差为15.707130，权重为-0.517865， 偏置为0.908610
第12步的误差为14.531180，权重为-0.517865， 偏置为0.957081
第13步的误差为14.012119，权重为-0.517865， 偏置为1.005726
第14步的误差为16.946522，权重为-0.517865， 偏置为1.054099
第15步的误差为12.943899，权重为-0.517865， 偏置为1.103363
第16步的误差为13.578373，权重为-0.517865， 偏置为1.163354
第17步的误差为11.375999，权重为-0.517865， 偏置为1.212049
第18步的误差为15.016453，权重为-0.517865， 偏置为1.249937
第19步的误差为12.626629，权重为-0.517865， 偏置为1.283256
第20步的误差为10.666047，权重为-0.517865， 偏置为1.312584
第21步的误差为10.202249，权重为-0.517865， 偏置为1.352090
第22步的误差为11.947571，权重为-0.517865， 偏置为1.397027
第23步的误差为9.205770，权重为-0.517865， 偏置为1.440084
第24步的误差为9.386309，权重为-0.517865， 偏置为1.477750
第25步的误差为10.745218，权重为-0.517865， 偏置为1.506613
第26步的误差为12.723915，权重为-0.517865， 偏置为1.546583
第27步的误差为9.648569，权重为-0.517865， 偏置为1.579757
第28步的误差为11.789293，权重为-0.517865， 偏置为1.608736
第29步的误差为10.047956，权重为-0.517865， 偏置为1.652372
第30步的误差为9.164089，权重为-0.517865， 偏置为1.682632
第31步的误差为9.283854，权重为-0.517865， 偏置为1.720886
第32步的误差为10.410101，权重为-0.517865， 偏置为1.752302
第33步的误差为7.899157，权重为-0.517865， 偏置为1.777820
第34步的误差为9.374871，权重为-0.517865， 偏置为1.809327
第35步的误差为11.125130，权重为-0.517865， 偏置为1.834102
第36步的误差为8.310570，权重为-0.517865， 偏置为1.869702
第37步的误差为9.998561，权重为-0.517865， 偏置为1.897713
第38步的误差为8.035198，权重为-0.517865， 偏置为1.916702
第39步的误差为10.219856，权重为-0.517865， 偏置为1.942338
第40步的误差为8.620630，权重为-0.517865， 偏置为1.972545
第41步的误差为10.593738，权重为-0.517865， 偏置为2.010114
第42步的误差为8.809321，权重为-0.517865， 偏置为2.033468
第43步的误差为11.952991，权重为-0.517865， 偏置为2.063075
第44步的误差为7.977013，权重为-0.517865， 偏置为2.098104
第45步的误差为8.277832，权重为-0.517865， 偏置为2.120943
第46步的误差为8.889300，权重为-0.517865， 偏置为2.137918
第47步的误差为9.030307，权重为-0.517865， 偏置为2.163110
第48步的误差为5.399837，权重为-0.517865， 偏置为2.188221
第49步的误差为6.096166，权重为-0.517865， 偏置为2.201182
第50步的误差为5.375680，权重为-0.517865， 偏置为2.221221
第51步的误差为11.469138，权重为-0.517865， 偏置为2.243402
第52步的误差为5.814083，权重为-0.517865， 偏置为2.265607
第53步的误差为7.978518，权重为-0.517865， 偏置为2.288233
第54步的误差为7.715104，权重为-0.517865， 偏置为2.316288
第55步的误差为8.022579，权重为-0.517865， 偏置为2.337228
第56步的误差为7.252862，权重为-0.517865， 偏置为2.354735
第57步的误差为8.353854，权重为-0.517865， 偏置为2.368362
第58步的误差为7.231637，权重为-0.517865， 偏置为2.393216
第59步的误差为6.761820，权重为-0.517865， 偏置为2.408501
第60步的误差为6.983268，权重为-0.517865， 偏置为2.417145
第61步的误差为11.225616，权重为-0.517865， 偏置为2.430773
第62步的误差为8.855368，权重为-0.517865， 偏置为2.446436
第63步的误差为7.403721，权重为-0.517865， 偏置为2.461128
第64步的误差为7.747515，权重为-0.517865， 偏置为2.476783
第65步的误差为6.863176，权重为-0.517865， 偏置为2.493899
第66步的误差为7.442878，权重为-0.517865， 偏置为2.513060
第67步的误差为6.248405，权重为-0.517865， 偏置为2.531655
第68步的误差为6.616094，权重为-0.517865， 偏置为2.544113
第69步的误差为6.990330，权重为-0.517865， 偏置为2.562733
第70步的误差为7.755499，权重为-0.517865， 偏置为2.580885
第71步的误差为7.230806，权重为-0.517865， 偏置为2.602328
第72步的误差为7.131375，权重为-0.517865， 偏置为2.616669
第73步的误差为7.928373，权重为-0.517865， 偏置为2.625495
第74步的误差为7.153095，权重为-0.517865， 偏置为2.642561
第75步的误差为6.619280，权重为-0.517865， 偏置为2.665955
第76步的误差为8.201778，权重为-0.517865， 偏置为2.681649
第77步的误差为8.972413，权重为-0.517865， 偏置为2.687425
第78步的误差为6.519564，权重为-0.517865， 偏置为2.701268
第79步的误差为9.085206，权重为-0.517865， 偏置为2.715133
第80步的误差为6.814089，权重为-0.517865， 偏置为2.728624
第81步的误差为7.248903，权重为-0.517865， 偏置为2.737576
第82步的误差为8.229288，权重为-0.517865， 偏置为2.747341
第83步的误差为5.964194，权重为-0.517865， 偏置为2.759060
第84步的误差为8.079063，权重为-0.517865， 偏置为2.774345
第85步的误差为7.900746，权重为-0.517865， 偏置为2.786348
第86步的误差为9.452961，权重为-0.517865， 偏置为2.799447
第87步的误差为6.604714，权重为-0.517865， 偏置为2.806964
第88步的误差为7.897435，权重为-0.517865， 偏置为2.818945
第89步的误差为7.518550，权重为-0.517865， 偏置为2.834730
第90步的误差为8.740208，权重为-0.517865， 偏置为2.846767
第91步的误差为6.324539，权重为-0.517865， 偏置为2.859751
第92步的误差为6.584641，权重为-0.517865， 偏置为2.869149
第93步的误差为7.206612，权重为-0.517865， 偏置为2.889504
第94步的误差为8.188255，权重为-0.517865， 偏置为2.901691
第95步的误差为6.929775，权重为-0.517865， 偏置为2.907604
第96步的误差为6.982978，权重为-0.517865， 偏置为2.903676
第97步的误差为5.780389，权重为-0.517865， 偏置为2.915356
第98步的误差为6.892652，权重为-0.517865， 偏置为2.920003
第99步的误差为7.683592，权重为-0.517865， 偏置为2.930790

三、 增加其他功能

  • 增加命名空间    【使代码变成了一个模块一个模块的】
  • 命令行参数设置

1 增加命名空间

目的是使代码结构更加清晰，Tensorboard图结构清楚

with tf.variable_scope("lr_model"):

注意：命名空间不能写中文

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()def linear_regression():# 1）准备好数据集：y = 0.8x + 0.7 100个样本# 特征值X, 目标值y_truewith tf.variable_scope("original_data"):X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name="original_data_x")# y_true [100, 1]# 矩阵运算 X（100， 1）* （1, 1）= y_true(100, 1)y_true = tf.matmul(X, [[0.8]], name="original_matmul") + 0.7# 2）建立线性模型：# y = W·X + b，目标：求出权重W和偏置b# 3）随机初始化W1和b1with tf.variable_scope("linear_model"):weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="weights")bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="bias")y_predict = tf.matmul(X, weights, name="model_matmul") + bias# 4）确定损失函数（预测值与真实值之间的误差）-均方误差with tf.variable_scope("loss"):error = tf.reduce_mean(tf.square(y_predict - y_true), name="error_op")# 5）梯度下降优化损失：需要指定学习率（超参数）# W2 = W1 - 学习率*(方向)# b2 = b1 - 学习率*(方向)with tf.variable_scope("gd_optimizer"):optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)# 2）收集变量tf.summary.scalar("error", error)tf.summary.histogram("weights", weights)tf.summary.histogram("bias", bias)# 3）合并变量merge = tf.summary.merge_all()# 初始化变量init = tf.global_variables_initializer()# 开启会话进行训练with tf.Session() as sess:# 运行初始化变量Opsess.run(init)print("随机初始化的权重为%f， 偏置为%f" % (weights.eval(), bias.eval()))# 1）创建事件文件file_writer = tf.summary.FileWriter(logdir="./tmp/summary", graph=sess.graph)# 训练模型for i in range(100):sess.run(optimizer)print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))# 4）运行合并变量opsummary = sess.run(merge)file_writer.add_summary(summary, i)return Noneif __name__ == '__main__':linear_regression()

运行结果：

知识补充：

2 模型的保存与加载

  • tf.train.Saver(var_list=None,max_to_keep=5)

    • 保存和加载模型（保存文件格式：checkpoint文件）
    • var_list:指定将要保存和还原的变量。它可以作为一个dict或一个列表传递.
    • max_to_keep：指示要保留的最近检查点文件的最大数量。创建新文件时，会删除较旧的文件。如果无或0，则保留所有检查点文件。默认为5（即保留最新的5个检查点文件。）

使用

例如：
指定目录+模型名字
saver.save(sess, '/tmp/ckpt/test/myregression.ckpt')
saver.restore(sess, '/tmp/ckpt/test/myregression.ckpt')

如要判断模型是否存在，直接指定目录

checkpoint = tf.train.latest_checkpoint("./tmp/model/")saver.restore(sess, checkpoint)

模型的保存，示例代码：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()def linear_regression():# 1）准备好数据集：y = 0.8x + 0.7 100个样本# 特征值X, 目标值y_truewith tf.variable_scope("original_data"):X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name="original_data_x")# y_true [100, 1]# 矩阵运算 X（100， 1）* （1, 1）= y_true(100, 1)y_true = tf.matmul(X, [[0.8]], name="original_matmul") + 0.7# 2）建立线性模型：# y = W·X + b，目标：求出权重W和偏置b# 3）随机初始化W1和b1with tf.variable_scope("linear_model"):weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="weights")bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="bias")y_predict = tf.matmul(X, weights, name="model_matmul") + bias# 4）确定损失函数（预测值与真实值之间的误差）-均方误差with tf.variable_scope("loss"):error = tf.reduce_mean(tf.square(y_predict - y_true), name="error_op")# 5）梯度下降优化损失：需要指定学习率（超参数）# W2 = W1 - 学习率*(方向)# b2 = b1 - 学习率*(方向)with tf.variable_scope("gd_optimizer"):optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)# 2）收集变量tf.summary.scalar("error", error)tf.summary.histogram("weights", weights)tf.summary.histogram("bias", bias)# 3）合并变量merge = tf.summary.merge_all()# 初始化变量init = tf.global_variables_initializer()# 创建一个saversaver = tf.train.Saver()# 开启会话进行训练with tf.Session() as sess:# 运行初始化变量Opsess.run(init)print("随机初始化的权重为%f， 偏置为%f" % (weights.eval(), bias.eval()))# 1）创建事件文件file_writer = tf.summary.FileWriter(logdir="./tmp/summary", graph=sess.graph)# 训练模型for i in range(100):sess.run(optimizer)print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))# 4）运行合并变量opsummary = sess.run(merge)file_writer.add_summary(summary, i)#  checkpoint：检查点文件格式saver.save(sess, './tmp/ckpt/linearregression.ckpt')return Noneif __name__ == '__main__':linear_regression()

示例截图：

模型的加载，示例代码：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()def linear_regression():# 1）准备好数据集：y = 0.8x + 0.7 100个样本# 特征值X, 目标值y_truewith tf.variable_scope("original_data"):X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name="original_data_x")# y_true [100, 1]# 矩阵运算 X（100， 1）* （1, 1）= y_true(100, 1)y_true = tf.matmul(X, [[0.8]], name="original_matmul") + 0.7# 2）建立线性模型：# y = W·X + b，目标：求出权重W和偏置b# 3）随机初始化W1和b1with tf.variable_scope("linear_model"):weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="weights")bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="bias")y_predict = tf.matmul(X, weights, name="model_matmul") + bias# 4）确定损失函数（预测值与真实值之间的误差）-均方误差with tf.variable_scope("loss"):error = tf.reduce_mean(tf.square(y_predict - y_true), name="error_op")# 5）梯度下降优化损失：需要指定学习率（超参数）# W2 = W1 - 学习率*(方向)# b2 = b1 - 学习率*(方向)with tf.variable_scope("gd_optimizer"):optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)# 2）收集变量tf.summary.scalar("error", error)tf.summary.histogram("weights", weights)tf.summary.histogram("bias", bias)# 3）合并变量merge = tf.summary.merge_all()# 初始化变量init = tf.global_variables_initializer()# 创建一个saversaver = tf.train.Saver()# 开启会话进行训练with tf.Session() as sess:# 运行初始化变量Opsess.run(init)print("随机初始化的权重为%f， 偏置为%f" % (weights.eval(), bias.eval()))# 1）创建事件文件file_writer = tf.summary.FileWriter(logdir="./tmp/summary", graph=sess.graph)#  模型的加载print(weights.eval(), bias.eval())saver.restore(sess, './tmp/ckpt/linearregression.ckpt')print(weights.eval(), bias.eval())# # 训练模型# for i in range(100):#     sess.run(optimizer)#     print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))#     # 4）运行合并变量op#     summary = sess.run(merge)#     file_writer.add_summary(summary, i)##     #  checkpoint：检查点文件格式#     saver.save(sess, './tmp/ckpt/linearregression.ckpt')return Noneif __name__ == '__main__':linear_regression()

示例截图：

3 命令行参数使用

  • 1、

  • 2、 tf.app.flags.,在flags有一个FLAGS标志，它在程序中可以调用到我们前面具体定义的flag_name

  • 3、通过tf.app.run()启动main(argv)函数
# 定义一些常用的命令行参数
# 训练步数
tf.app.flags.DEFINE_integer("max_step", 0, "训练模型的步数")
# 定义模型的路径
tf.app.flags.DEFINE_string("model_dir", " ", "模型保存的路径+模型名字")# 定义获取命令行参数
FLAGS = tf.app.flags.FLAGS# 开启训练
# 训练的步数（依据模型大小而定）
for i in range(FLAGS.max_step):sess.run(train_op)

示例代码：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()#  命令行参数
tf.app.flags.DEFINE_integer("max_step", 1000, "训练模型的步数")
FLAGS = tf.app.flags.FLAGSdef linear_regression():# 1）准备好数据集：y = 0.8x + 0.7 100个样本# 特征值X, 目标值y_truewith tf.variable_scope("original_data"):X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name="original_data_x")# y_true [100, 1]# 矩阵运算 X（100， 1）* （1, 1）= y_true(100, 1)y_true = tf.matmul(X, [[0.8]], name="original_matmul") + 0.7# 2）建立线性模型：# y = W·X + b，目标：求出权重W和偏置b# 3）随机初始化W1和b1with tf.variable_scope("linear_model"):weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="weights")bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="bias")y_predict = tf.matmul(X, weights, name="model_matmul") + bias# 4）确定损失函数（预测值与真实值之间的误差）-均方误差with tf.variable_scope("loss"):error = tf.reduce_mean(tf.square(y_predict - y_true), name="error_op")# 5）梯度下降优化损失：需要指定学习率（超参数）# W2 = W1 - 学习率*(方向)# b2 = b1 - 学习率*(方向)with tf.variable_scope("gd_optimizer"):optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)# 2）收集变量tf.summary.scalar("error", error)tf.summary.histogram("weights", weights)tf.summary.histogram("bias", bias)# 3）合并变量merge = tf.summary.merge_all()# 初始化变量init = tf.global_variables_initializer()# 创建一个saversaver = tf.train.Saver()# 开启会话进行训练with tf.Session() as sess:# 运行初始化变量Opsess.run(init)print("随机初始化的权重为%f， 偏置为%f" % (weights.eval(), bias.eval()))# 1）创建事件文件file_writer = tf.summary.FileWriter(logdir="./tmp/summary", graph=sess.graph)# #  模型的加载# print(weights.eval(), bias.eval())# saver.restore(sess, './tmp/ckpt/linearregression.ckpt')# print(weights.eval(), bias.eval())# 训练模型for i in range(FLAGS.max_step):sess.run(optimizer)print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))# 4）运行合并变量opsummary = sess.run(merge)file_writer.add_summary(summary, i)# #  checkpoint：检查点文件格式# saver.save(sess, './tmp/ckpt/linearregression.ckpt')return Noneif __name__ == '__main__':linear_regression()

示例截图：

4 完整代码

import tensorflow as tf
import ostf.app.flags.DEFINE_string("model_path", "./linear_regression/", "模型保存的路径和文件名")
FLAGS = tf.app.flags.FLAGSdef linear_regression():# 1）准备好数据集：y = 0.8x + 0.7 100个样本# 特征值X, 目标值y_truewith tf.variable_scope("original_data"):X = tf.random_normal(shape=(100, 1), mean=2, stddev=2, name="original_data_x")# y_true [100, 1]# 矩阵运算 X（100， 1）* （1, 1）= y_true(100, 1)y_true = tf.matmul(X, [[0.8]], name="original_matmul") + 0.7# 2）建立线性模型：# y = W·X + b，目标：求出权重W和偏置b# 3）随机初始化W1和b1with tf.variable_scope("linear_model"):weights = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="weights")bias = tf.Variable(initial_value=tf.random_normal(shape=(1, 1)), name="bias")y_predict = tf.matmul(X, weights, name="model_matmul") + bias# 4）确定损失函数（预测值与真实值之间的误差）-均方误差with tf.variable_scope("loss"):error = tf.reduce_mean(tf.square(y_predict - y_true), name="error_op")# 5）梯度下降优化损失：需要指定学习率（超参数）# W2 = W1 - 学习率*(方向)# b2 = b1 - 学习率*(方向)with tf.variable_scope("gd_optimizer"):optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01, name="optimizer").minimize(error)# 2）收集变量tf.summary.scalar("error", error)tf.summary.histogram("weights", weights)tf.summary.histogram("bias", bias)# 3）合并变量merge = tf.summary.merge_all()# 初始化变量init = tf.global_variables_initializer()# 开启会话进行训练with tf.Session() as sess:# 运行初始化变量Opsess.run(init)# 未经训练的权重和偏置print("随机初始化的权重为%f， 偏置为%f" % (weights.eval(), bias.eval()))# 当存在checkpoint文件，就加载模型# 1）创建事件文件file_writer = tf.summary.FileWriter(logdir="./summary", graph=sess.graph)# 训练模型for i in range(100):sess.run(optimizer)print("第%d步的误差为%f，权重为%f， 偏置为%f" % (i, error.eval(), weights.eval(), bias.eval()))# 4）运行合并变量opsummary = sess.run(merge)file_writer.add_summary(summary, i)return Nonedef main(argv):print("这是main函数")print(argv)print(FLAGS.model_path)linear_regression()if __name__ == "__main__":tf.app.run()

四、将面向过程改为面向对象

参考代码

# 用tensorflow自实现一个线性回归案例# 定义一些常用的命令行参数
# 训练步数
tf.app.flags.DEFINE_integer("max_step", 0, "训练模型的步数")
# 定义模型的路径
tf.app.flags.DEFINE_string("model_dir", " ", "模型保存的路径+模型名字")FLAGS = tf.app.flags.FLAGSclass MyLinearRegression(object):"""自实现线性回归"""def __init__(self):passdef inputs(self):"""获取特征值目标值数据数据:return:"""x_data = tf.random_normal([100, 1], mean=1.0, stddev=1.0, name="x_data")y_true = tf.matmul(x_data, [[0.7]]) + 0.8return x_data, y_truedef inference(self, feature):"""根据输入数据建立模型:param feature::param label::return:"""with tf.variable_scope("linea_model"):# 2、建立回归模型，分析别人的数据的特征数量--->权重数量， 偏置b# 由于有梯度下降算法优化，所以一开始给随机的参数，权重和偏置# 被优化的参数，必须得使用变量op去定义# 变量初始化权重和偏置# weight 2维[1, 1]    bias [1]# 变量op当中会有trainable参数决定是否训练self.weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0),name="weights")self.bias = tf.Variable(0.0, name='biases')# 建立回归公式去得出预测结果y_predict = tf.matmul(feature, self.weight) + self.biasreturn y_predictdef loss(self, y_true, y_predict):"""目标值和真实值计算损失:return: loss"""# 3、求出我们模型跟真实数据之间的损失# 均方误差公式loss = tf.reduce_mean(tf.square(y_true - y_predict))return lossdef merge_summary(self, loss):# 1、收集张量的值tf.summary.scalar("losses", loss)tf.summary.histogram("w", self.weight)tf.summary.histogram('b', self.bias)# 2、合并变量merged = tf.summary.merge_all()return mergeddef sgd_op(self, loss):"""获取训练OP:return:"""# 4、使用梯度下降优化器优化# 填充学习率：0 ~ 1    学习率是非常小，# 学习率大小决定你到达损失一个步数多少# 最小化损失train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)return train_opdef train(self):"""训练模型:param loss::return:"""g = tf.get_default_graph()with g.as_default():x_data, y_true = self.inputs()y_predict = self.inference(x_data)loss = self.loss(y_true, y_predict)train_op = self.sgd_op(loss)# 收集观察的结果值merged = self.merge_summary(loss)saver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# 在没训练，模型的参数值print("初始化的权重：%f, 偏置：%f" % (self.weight.eval(), self.bias.eval()))# 开启训练# 训练的步数（依据模型大小而定）for i in range(FLAGS.max_step):sess.run(train_op)# 生成事件文件，观察图结构file_writer = tf.summary.FileWriter("./tmp/summary/", graph=sess.graph)print("训练第%d步之后的损失:%f, 权重：%f, 偏置：%f" % (i,loss.eval(),self.weight.eval(),self.bias.eval()))# 运行收集变量的结果summary = sess.run(merged)# 添加到文件file_writer.add_summary(summary, i)if __name__ == '__main__':lr = MyLinearRegression()lr.train()

TensorFlow案例实现线性回归相关推荐

  1. TensorFlow实现简单线性回归

    文章目录 实验主题-TensorFlow实现简单线性回归 案例实现 实验效果 逻辑回归或线性回归是用于对离散类别进行分类的监督机器学习方法.在本章中的目标是构建一个模型,用户可以通过该模型预测预测变量 ...

  2. 利用TensorFlow实现多元线性回归

    利用TensorFlow实现多元线性回归,代码如下: # -*- coding:utf-8 -*- import tensorflow as tf import numpy as np from sk ...

  3. Tensorflow实现多元线性回归

    上一篇使用tensorflow实现了简单的线性回归,这次在简单的线性回归基础上,通过在权重和占位符声明中 修改来对相同的数据进行多元线性回归. 同样以波士顿房价数据为例 波士顿房价数据集可从http: ...

  4. [机器学习-实践篇]学习之线性回归、岭回归、Lasso回归，tensorflow实现的线性回归

    线性回归.岭回归.Lasso回归 前言 1.线性回归 2. 岭回归 3. Lasso回归 4. tensorflow利用梯度下降实现的线性回归 前言 本章主要介绍线性回归.岭回归.Lasso回归,te ...

  5. python线性加权回归_python深度学习-tensorflow实现一个线性回归的案例

    线性回归:w1x1+w2x2+w3x3+......+wnxn+bias(这是一个偏移量),我们采用的算法是:线性回归,策略是:均方误差,优化是:梯度下降API, 1.转准备好实验的数据:100个数据 ...

  6. python线性回归实例 x轴坐标相同_python深度学习-tensorflow实现一个线性回归的案例...

    线性回归:w1x1+w2x2+w3x3+......+wnxn+bias(这是一个偏移量),我们采用的算法是:线性回归,策略是:均方误差,优化是:梯度下降API, 1.转准备好实验的数据:100个数据 ...

  7. python多元线性回归模型_python – 使用Tensorflow的多元线性回归模型

    我想通过使用Tensorflow构建一个多元线性回归模型. 一个数据示例:2104,3,399900(前两个是功能,最后一个是房价;我们有47个示例) 代码如下: import numpy as np ...

  8. 使用Tensorflow实现简单线性回归

    针对波士顿房价数据集采用简单线性回归,预测最后一列给出的房价 波士顿房价数据集可从http://lib.stat.cmu.edu/datasets/boston处获取. 实现简单线性回归的具体做法 1 ...

  9. 概率编程库Pymc3案例之线性回归

    参考:https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers 1. ...

最新文章

  1. 懒人神器 ！一个创意十足的 Python 命令行工具
  2. mybatis一对多关联 创建_MyBatis多对多关联查询（级联查询）
  3. 微软模拟飞行2020服务器多少内存,《微软模拟飞行2020》配置公开，想玩爽还需玩家加大投入...
  4. Linux 安装 luarocks(lua的模块管理工具)
  5. 【题解】弃疗Nim （2019,5.23）
  6. Spring WebApplicationContext
  7. 织梦dede 5.7系统基本参数无法修改保存，提示Token mismatch!
  8. OJ1029: 三角形判定
  9. Merkle Patricia Tree 详解
  10. 编程到底该用 Tab 还是 Space？比尔·盖茨也来挑事儿
  11. Design Patterns（二十四）：Visite Pattern--VB代码
  12. mybatis关于factorybean疑问
  13. ICS TRIPLEX模块T9110、T8461、T8110B、T8480C、T9110、T9451、T9402、T9432、T9110、T9310-02、1433/09232486825、9100
  14. 系统辨识（四）：系统辨识的经典方法
  15. ddt数据驱动常见的用法【多测师_王sir】
  16. 学习掌握Excel程度的层级划分
  17. 【农业物联网】智慧农业模型应用多案例分享
  18. 阿里云服务器默认登录密码是什么？
  19. 云计算主要包含哪些基本特征？
  20. git 进阶系列教程--push

热门文章

  1. 抖音发布特效数据报告：每五个投稿有一个使用特效
  2. 话AI、学实践、探未来，亚马逊云科技AI在线大会报名开启！
  3. 五项挑战获四项第一，地平线霸榜Waymo自动驾驶算法挑战赛
  4. 深度学习已至“瓶颈”？英特尔：数据处理是一剂良药
  5. 空字符串计数、让字典可排序...Python冷知识（五）
  6. 算法面试经常需要你手写的三个排序算法（Python语言）
  7. 微软曾经的二号人物永远地离开了
  8. 马斯克新视频：Boring公司将优先解决公交快速通勤
  9. Spring Aop 常见注解和执行顺序
  10. 为什么阿里巴巴要禁用 Executors 创建线程池？