Python深度学习TensorFlow1.0版本框架day1

最新推荐文章于 2023-09-26 16:37:38 发布

self.键盘上的钢琴师.LX

最新推荐文章于 2023-09-26 16:37:38 发布

阅读量2k

点赞数 1

分类专栏：机器学习文章标签： 1024程序员节

本文链接：https://blog.csdn.net/lixiangohoh/article/details/120940420

版权

机器学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

黑马程序3天tensorflow课程笔记

import tensorflow as tf

def tensorflow_demo():
    '''tensorflow 的基本结构'''
    #原来的加法运算
    a = 2
    b =3
    c = a+b
    print('普通加法运算：\n',c)

    #tensorflow 实现加法运算
    a_t = tf.constant(2, name="a_t")
    b_t = tf.constant(3, name="b_t")
    c_t = tf.add(a_t, b_t, name="c_t")
    # print('普通加法运算：\n', c_t)

    #开启会话，才能到计算啊
    with tf.Session() as sess:
        c_t_value = sess.run(c_t)
        print('c_t_value:\n', c_t_value)
      #1)第一步将写入本地生成event文件
        tf.summary.FileWriter('./tmp/summary', graph=sess.graph)

    return None

tensorflow_demo()

普通加法运算：
 5
c_t_value:
 5

def tensorflow_demo_1():
    '''tensorflow 的基本结构'''
    #原来的加法运算
    a = 2
    b =3
    c = a+b
    print('普通加法运算：\n',c)

    #tensorflow 实现加法运算
    a_t = tf.constant(2, name="a_t")
    b_t = tf.constant(3, name="b_t")
    c_t = tf.add(a_t, b_t, name="c_t")
    # print('普通加法运算：\n', c_t)

    #第二种方法，进行的到c_t的值
    with tf.Session() as sess:
        print('c_t_value:\n', c_t.eval())
      #1)第一步将写入本地生成event文件
        tf.summary.FileWriter('./tmp/summary', graph=sess.graph)

    return None

tensorflow_demo_1()

普通加法运算：
 5
c_t_value:
 5

feed 操作

#定义占位符
a_ph = tf.placeholder(tf.float32)
b_ph = tf.placeholder(tf.float32)
c_ph = tf.add(a_ph, b_ph)
print("a_ph:\n",a_ph)
print("b_ph:\n",b_ph)
print("b_ph:\n",b_ph)

a_ph:
 Tensor("Placeholder:0", dtype=float32)
b_ph:
 Tensor("Placeholder_1:0", dtype=float32)
b_ph:
 Tensor("Placeholder_1:0", dtype=float32)

#开启会话
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)) as sess:
    c_ph_value = sess.run(c_ph, feed_dict={a_ph:3.9, b_ph:4.8})
    print("c_ph_value:\n", c_ph_value)

c_ph_value:
 8.7

小结：当我们不知道有多少个样本的时候，也不知道有多少行，这时候就需要用placehold把位置先占上

常见报错类型小结：

RuntimeError : 如果这Session是无效状态（例如已经关闭）
TypeError : 如果fetches或者feed_dict键的类型不对
ValueError : 如果fetches或者feed_dict键无效或者引用 Tensor不存在

张量

与nadarray有联系的

张量就是一个n维数组，类型是Tensor，
标量是一个数字（0阶张量）
向量是一维数组（一阶张量）
矩阵就是二阶张量

#张量的演示
tensor1 = tf.constant(4.0)
tensor2 = tf.constant([1,2,3,4.0])
linear_squares = tf.constant([[4],[3],[5],[29],[12]],dtype=tf.int32)
print("tensor1:",tensor1)
print("tensor2:",tensor2)
print("linear_squares:",linear_squares)

tensor1: Tensor("Const:0", shape=(), dtype=float32)
tensor2: Tensor("Const_1:0", shape=(4,), dtype=float32)
linear_squares: Tensor("Const_2:0", shape=(5, 1), dtype=int32)

注意一下啊：tf.zeros(shape=[3,4]).eval()会报错的，一定要在Session里面运行才可以


with tf.Session() as sess:

    print(tf.zeros(shape=[3,4]).eval())#默认的类型是32浮点类型
    
    print(tf.random_normal(shape=[2,3]).eval())

[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]
[[-1.99493873 -0.18655238  0.51768929]
 [-1.0361129  -0.47611722 -1.33966744]]

张量的变化

#类型的修改
linear_squares = tf.constant([[4],[5],[10],[25]],dtype = tf.int32)
print(linear_squares)
l_cast = tf.cast(linear_squares, dtype=tf.float32)
#cast,不会改变原始的类型，有返回值的函数
print(l_cast)

Tensor("Const_3:0", shape=(4, 1), dtype=int32)
Tensor("Cast:0", shape=(4, 1), dtype=float32)

#静态形状的修改：#shape=(4, 1), dtype=float32，表示静态形状--表示初始创建的张量的形状
###只有在形状没有完全固定下来的情况下，才能更新形状
a_ph = tf.placeholder(tf.float32,shape=[None,None])
b_ph = tf.placeholder(tf.float32,shape=[None,10])
c_ph = tf.placeholder(tf.float32,shape=[3,2])
print("a_ph:\n",a_ph)
print("b_ph:\n",b_ph)
print("b_ph:\n",c_ph)

a_ph:
 Tensor("Placeholder_2:0", shape=(?, ?), dtype=float32)
b_ph:
 Tensor("Placeholder_3:0", shape=(?, 10), dtype=float32)
b_ph:
 Tensor("Placeholder_4:0", shape=(3, 2), dtype=float32)

#？？？表示形状还没有固定下来的静态形状

a_ph.set_shape([2,3])
b_ph.set_shape([3,10])
print("a_ph:\n",a_ph)
print("b_ph:\n",b_ph)

a_ph:
 Tensor("Placeholder_2:0", shape=(2, 3), dtype=float32)
b_ph:
 Tensor("Placeholder_3:0", shape=(3, 10), dtype=float32)

#动态形状修改
a_ph_reshape = tf.reshape(a_ph,shape=[2,3,1])
print(a_ph_reshape)

Tensor("Reshape:0", shape=(2, 3, 1), dtype=float32)

这里注意形状可以修改，但是原来的元素的总个数，要保持不变，2x3x1 = 2x3

张量的数学运算

需要时查CSDN

变量OP

变量的特点
#存储持久化
#可修改
#可指定被训练
#适合存储模型参数

import tensorflow as tf

with tf.variable_scope("my_scope"):#命名空间能使得结构更加清晰
    
    a = tf.Variable(initial_value=50)
    b = tf.Variable(initial_value=40)
    c = tf.add(a, b)

print(a,b,c)
#初始化变量
init = tf.global_variables_initializer()


#开启会话
with tf.Session() as sess:
    sess.run(init)
    a_value, b_value, c_value = sess.run([a,b,c])#这里的中括号一定要加上
    print(a_value)
    print(b_value)    
    print(c_value)

<tf.Variable 'my_scope/Variable:0' shape=() dtype=int32_ref> <tf.Variable 'my_scope/Variable_1:0' shape=() dtype=int32_ref> Tensor("my_scope/Add:0", shape=(), dtype=int32)
50
40
90

基础API和高级API

#tf.app
#tf.imag
#tf.gfile
#tf.summary#生产tensorboars的日志
#tf.python_io#用来导入数据
#tf.train
#tf.nn#神经网络的底层函数

#高级API
#tf.keras
#tf.layers
#tf.contrib
#tf.estimator
需要查CSDN

案例-线性回归

#线性回归三部曲
#1.构建模型：y= x1*1+…
#2.构造损失函数：均方误差
#3.优化损失：梯度下降

def Linear_regression():
    """自实现线性回归"""
    #1.准备数据
    x = tf.random_normal(shape=[100,1])
    y_true = tf.matmul(x, [[0.8]]) + 0.7
    
    
    #2.构造模型
    #定义模型参数 用的变量
    weights = tf.Variable(initial_value = tf.random_normal(shape=[1,1]))
    bais = tf.Variable(initial_value = tf.random_normal(shape=[1,1]))
    y_predict = tf.matmul(x,weights) + bais
    
    
    #3.构造损失函数(这里用的是均方误差)
    error = tf.reduce_mean(tf.square(y_predict-y_true))
    
    
    #4.优化损失
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(error)
    
    #显示的初始化变量
    init = tf.global_variables_initializer()
    
    #开启会话
    with tf.Session() as sess:
        #初始化变量
        sess.run(init)
        #查看初始化模型参数之后的值
        print("训练前模型参数：权重%f,偏置%f,损失伟为%f"%(weights.eval(), bais.eval(), error.eval()))
        
        
        #开始训练
        for i in range(50):
            sess.run(optimizer)
            print("第%f训练后模型参数：权重%f,偏置%f,损失为%f"%(i+1,weights.eval(), bais.eval(), error.eval()))

Linear_regression()

训练前模型参数：权重-1.152759,偏置-0.212656,损失伟为4.332959
第1.000000训练后模型参数：权重-0.807999,偏置-0.117278,损失为2.560391
第2.000000训练后模型参数：权重-0.437624,偏置0.091886,损失为1.717989
第3.000000训练后模型参数：权重-0.159337,偏置0.258003,损失为1.144702
第4.000000训练后模型参数：权重0.022085,偏置0.322826,损失为0.624317
第5.000000训练后模型参数：权重0.139547,偏置0.411643,损失为0.604325
第6.000000训练后模型参数：权重0.294251,偏置0.488190,损失为0.277121
第7.000000训练后模型参数：权重0.412088,偏置0.525210,损失为0.215403
第8.000000训练后模型参数：权重0.478664,偏置0.563459,损失为0.141975
第9.000000训练后模型参数：权重0.540384,偏置0.597950,损失为0.085096
第10.000000训练后模型参数：权重0.591391,偏置0.623096,损失为0.040612
第11.000000训练后模型参数：权重0.623268,偏置0.638620,损失为0.025792
第12.000000训练后模型参数：权重0.657620,偏置0.651550,损失为0.022196
第13.000000训练后模型参数：权重0.681732,偏置0.662050,损失为0.016367
第14.000000训练后模型参数：权重0.705933,偏置0.669495,损失为0.011608
第15.000000训练后模型参数：权重0.722178,偏置0.678431,损失为0.006376
第16.000000训练后模型参数：权重0.744477,偏置0.680621,损失为0.004700
第17.000000训练后模型参数：权重0.755343,偏置0.683997,损失为0.001979
第18.000000训练后模型参数：权重0.764696,偏置0.688471,损失为0.001661
第19.000000训练后模型参数：权重0.772226,偏置0.691558,损失为0.000782
第20.000000训练后模型参数：权重0.778244,偏置0.692688,损失为0.000539
第21.000000训练后模型参数：权重0.782865,偏置0.694306,损失为0.000280
第22.000000训练后模型参数：权重0.786427,偏置0.695407,损失为0.000197
第23.000000训练后模型参数：权重0.789592,偏置0.696027,损失为0.000120
第24.000000训练后模型参数：权重0.791288,偏置0.696803,损失为0.000081
第25.000000训练后模型参数：权重0.792793,偏置0.697387,损失为0.000053
第26.000000训练后模型参数：权重0.794426,偏置0.697976,损失为0.000039
第27.000000训练后模型参数：权重0.795519,偏置0.698420,损失为0.000020
第28.000000训练后模型参数：权重0.796419,偏置0.698724,损失为0.000014
第29.000000训练后模型参数：权重0.797125,偏置0.698979,损失为0.000010
第30.000000训练后模型参数：权重0.797573,偏置0.699159,损失为0.000007
第31.000000训练后模型参数：权重0.798111,偏置0.699415,损失为0.000003
第32.000000训练后模型参数：权重0.798562,偏置0.699570,损失为0.000002
第33.000000训练后模型参数：权重0.798896,偏置0.699652,损失为0.000001
第34.000000训练后模型参数：权重0.799129,偏置0.699725,损失为0.000001
第35.000000训练后模型参数：权重0.799290,偏置0.699771,损失为0.000001
第36.000000训练后模型参数：权重0.799410,偏置0.699822,损失为0.000000
第37.000000训练后模型参数：权重0.799529,偏置0.699849,损失为0.000000
第38.000000训练后模型参数：权重0.799616,偏置0.699886,损失为0.000000
第39.000000训练后模型参数：权重0.799694,偏置0.699903,损失为0.000000
第40.000000训练后模型参数：权重0.799753,偏置0.699928,损失为0.000000
第41.000000训练后模型参数：权重0.799798,偏置0.699938,损失为0.000000
第42.000000训练后模型参数：权重0.799832,偏置0.699948,损失为0.000000
第43.000000训练后模型参数：权重0.799859,偏置0.699959,损失为0.000000
第44.000000训练后模型参数：权重0.799889,偏置0.699971,损失为0.000000
第45.000000训练后模型参数：权重0.799909,偏置0.699975,损失为0.000000
第46.000000训练后模型参数：权重0.799931,偏置0.699985,损失为0.000000
第47.000000训练后模型参数：权重0.799944,偏置0.699989,损失为0.000000
第48.000000训练后模型参数：权重0.799958,偏置0.699991,损失为0.000000
第49.000000训练后模型参数：权重0.799965,偏置0.699992,损失为0.000000
第50.000000训练后模型参数：权重0.799971,偏置0.699994,损失为0.000000

#小结
#损失率在中间的时候，是有可能比那原来的还要高，这是存在的，但是整体是有下降的趋势的

#关于梯度爆炸或者梯度消失的几个，调整方法
#重新设置网络
#调整学习率
#使用梯度截断（在训练过程中检查和限制梯度的大小）
#使用激活函数

增加变量的显示

def Linear_regression():
    """自实现线性回归"""
    # 1.准备数据
    x = tf.random_normal(shape=[100, 1])
    y_true = tf.matmul(x, [[0.8]]) + 0.7

    # 2.构造模型
    # 定义模型参数 用的变量
    weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))
    bais = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]))
    y_predict = tf.matmul(x, weights) + bais

    # 3.构造损失函数(这里用的是均方误差)
    error = tf.reduce_mean(tf.square(y_predict - y_true))

    # 4.优化损失
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(error)

    # 显示的初始化变量
    init = tf.global_variables_initializer()

    #2.搜集变量
    tf.summary.scalar("error",error)#这个函数是搜集标量
    tf.summary.histogram("weights", weights)
    tf.summary.histogram("bais", bais)

    #3合并变量
    merge = tf.summary.merge_all()
    # 开启会话
    with tf.Session() as sess:
        # 初始化变量
        sess.run(init)
        # 查看初始化模型参数之后的值
        print("训练前模型参数：权重%f,偏置%f,损失伟为%f" % (weights.eval(), bais.eval(), error.eval()))
        #1.创建事件文件
        file_writer = tf.summary.FileWriter("./tmp/Linear",graph=sess.graph)
        # 开始训练
        for i in range(50):
            sess.run(optimizer)
            print("第%f训练后模型参数：权重%f,偏置%f,损失为%f" % (i + 1, weights.eval(), bais.eval(), error.eval()))
            #运行合并变量操作
            summary = sess.run(merge)
            #将每次迭代后的变量写入事件文件
            file_writer.add_summary(summary,i)

Linear_regression()

训练前模型参数：权重0.511537,偏置0.275152,损失伟为0.201425
第1.000000训练后模型参数：权重0.602616,偏置0.369138,损失为0.164300
第2.000000训练后模型参数：权重0.639234,偏置0.433544,损失为0.093523
第3.000000训练后模型参数：权重0.682483,偏置0.492393,损失为0.050554
第4.000000训练后模型参数：权重0.709232,偏置0.533828,损失为0.034641
第5.000000训练后模型参数：权重0.726891,偏置0.567314,损失为0.020176
第6.000000训练后模型参数：权重0.738316,偏置0.592622,损失为0.016300
第7.000000训练后模型参数：权重0.750035,偏置0.614589,损失为0.011360
第8.000000训练后模型参数：权重0.761215,偏置0.632518,损失为0.006716
第9.000000训练后模型参数：权重0.769517,偏置0.646171,损失为0.003431
第10.000000训练后模型参数：权重0.773130,偏置0.656448,损失为0.002533
第11.000000训练后模型参数：权重0.778823,偏置0.665016,损失为0.001576
第12.000000训练后模型参数：权重0.783546,偏置0.671968,损失为0.001258
第13.000000训练后模型参数：权重0.786516,偏置0.677223,损失为0.000583
第14.000000训练后模型参数：权重0.788330,偏置0.681545,损失为0.000474
第15.000000训练后模型参数：权重0.790558,偏置0.685166,损失为0.000376
第16.000000训练后模型参数：权重0.792410,偏置0.687961,损失为0.000184
第17.000000训练后模型参数：权重0.793734,偏置0.690393,损失为0.000149
第18.000000训练后模型参数：权重0.795081,偏置0.692306,损失为0.000074
第19.000000训练后模型参数：权重0.796102,偏置0.693861,损失为0.000056
第20.000000训练后模型参数：权重0.796872,偏置0.695081,损失为0.000039
第21.000000训练后模型参数：权重0.797546,偏置0.696099,损失为0.000019
第22.000000训练后模型参数：权重0.797961,偏置0.696836,损失为0.000014
第23.000000训练后模型参数：权重0.798369,偏置0.697521,损失为0.000011
第24.000000训练后模型参数：权重0.798596,偏置0.698002,损失为0.000006
第25.000000训练后模型参数：权重0.798882,偏置0.698410,损失为0.000004
第26.000000训练后模型参数：权重0.799243,偏置0.698756,损失为0.000002
第27.000000训练后模型参数：权重0.799412,偏置0.699008,损失为0.000002
第28.000000训练后模型参数：权重0.799506,偏置0.699202,损失为0.000001
第29.000000训练后模型参数：权重0.799629,偏置0.699376,损失为0.000000
第30.000000训练后模型参数：权重0.799698,偏置0.699492,损失为0.000000
第31.000000训练后模型参数：权重0.799757,偏置0.699596,损失为0.000000
第32.000000训练后模型参数：权重0.799809,偏置0.699675,损失为0.000000
第33.000000训练后模型参数：权重0.799835,偏置0.699733,损失为0.000000
第34.000000训练后模型参数：权重0.799864,偏置0.699785,损失为0.000000
第35.000000训练后模型参数：权重0.799896,偏置0.699830,损失为0.000000
第36.000000训练后模型参数：权重0.799917,偏置0.699866,损失为0.000000
第37.000000训练后模型参数：权重0.799936,偏置0.699893,损失为0.000000
第38.000000训练后模型参数：权重0.799943,偏置0.699913,损失为0.000000
第39.000000训练后模型参数：权重0.799953,偏置0.699930,损失为0.000000
第40.000000训练后模型参数：权重0.799961,偏置0.699943,损失为0.000000
第41.000000训练后模型参数：权重0.799968,偏置0.699955,损失为0.000000
第42.000000训练后模型参数：权重0.799974,偏置0.699963,损失为0.000000
第43.000000训练后模型参数：权重0.799977,偏置0.699969,损失为0.000000
第44.000000训练后模型参数：权重0.799983,偏置0.699976,损失为0.000000
第45.000000训练后模型参数：权重0.799986,偏置0.699981,损失为0.000000
第46.000000训练后模型参数：权重0.799989,偏置0.699985,损失为0.000000
第47.000000训练后模型参数：权重0.799991,偏置0.699988,损失为0.000000
第48.000000训练后模型参数：权重0.799993,偏置0.699990,损失为0.000000
第49.000000训练后模型参数：权重0.799994,偏置0.699992,损失为0.000000
第50.000000训练后模型参数：权重0.799995,偏置0.699994,损失为0.000000

步骤

创建事件文件读写器

###收集变量
###合并变量
###每次迭代都运行合并变量
###每次迭代都将summary对象写入事件文件

增加命名空间

#作用：用with scope来命名空间，在tensorboard中查看更加清晰

def Linear_regression():
    """自实现线性回归"""
    #增加命名空间
    with tf.variable_scope("prepare_data"):
    # 1.准备数据
        x = tf.random_normal(shape=[100, 1],name="feature")
        y_true = tf.matmul(x, [[0.8]]) + 0.7
    with tf.variable_scope("create_model"):
    # 2.构造模型
    # 定义模型参数 用的变量
        weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Weights")
        bais = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Bais")
        y_predict = tf.matmul(x, weights) + bais
    with tf.variable_scope("loss_function"):
    # 3.构造损失函数(这里用的是均方误差)
        error = tf.reduce_mean(tf.square(y_predict - y_true))
    with tf.variable_scope("optimizer"):
    # 4.优化损失
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(error)

    # 显示的初始化变量
    init = tf.global_variables_initializer()

    #2.搜集变量
    tf.summary.scalar("error",error)#这个函数是搜集标量
    tf.summary.histogram("weights", weights)
    tf.summary.histogram("bais", bais)

    #3合并变量
    merge = tf.summary.merge_all()
    # 开启会话
    with tf.Session() as sess:
        # 初始化变量
        sess.run(init)
        # 查看初始化模型参数之后的值
        print("训练前模型参数：权重%f,偏置%f,损失伟为%f" % (weights.eval(), bais.eval(), error.eval()))
        #1.创建事件文件
        file_writer = tf.summary.FileWriter("./tmp/Linear",graph=sess.graph)
        # 开始训练
        for i in range(50):
            sess.run(optimizer)
            print("第%f训练后模型参数：权重%f,偏置%f,损失为%f" % (i + 1, weights.eval(), bais.eval(), error.eval()))
            #运行合并变量操作
            summary = sess.run(merge)
            #将每次迭代后的变量写入事件文件
            file_writer.add_summary(summary,i)

模型的保存与加载

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


def Linear_regression():
    """自实现线性回归"""
    #增加命名空间
    with tf.variable_scope("prepare_data"):
    # 1.准备数据
        x = tf.random_normal(shape=[100, 1],name="feature")
        y_true = tf.matmul(x, [[0.8]]) + 0.7
    with tf.variable_scope("create_model"):
    # 2.构造模型
    # 定义模型参数 用的变量
        weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Weights")
        bais = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Bais")
        y_predict = tf.matmul(x, weights) + bais
    with tf.variable_scope("loss_function"):
    # 3.构造损失函数(这里用的是均方误差)
        error = tf.reduce_mean(tf.square(y_predict - y_true))
    with tf.variable_scope("optimizer"):
    # 4.优化损失
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(error)

    # 显示的初始化变量
    init = tf.global_variables_initializer()

    #2.搜集变量
    tf.summary.scalar("error",error)#这个函数是搜集标量
    tf.summary.histogram("weights", weights)
    tf.summary.histogram("bais", bais)

    #3合并变量
    merge = tf.summary.merge_all()

    #创建Saver对象
    saver = tf.train.Saver()



    # 开启会话
    with tf.Session() as sess:
        # 初始化变量
        sess.run(init)
        # 查看初始化模型参数之后的值
        print("训练前模型参数：权重%f,偏置%f,损失伟为%f" % (weights.eval(), bais.eval(), error.eval()))
        #1.创建事件文件
        file_writer = tf.summary.FileWriter("./tmp/Linear",graph=sess.graph)
        # 开始训练
        # for i in range(50):
        #     sess.run(optimizer)
        #     print("第%f训练后模型参数：权重%f,偏置%f,损失为%f" % (i + 1, weights.eval(), bais.eval(), error.eval()))
        #     #运行合并变量操作
        #     summary = sess.run(merge)
        #     #将每次迭代后的变量写入事件文件
        #     file_writer.add_summary(summary,i)
        #     if i % 10 == 0:
        #     #保存模型
        #         saver.save(sess, "./tmp/model/my_linear.ckpt")

        #加载模型
        if os.path.exists("./tmp/model/checkpoint"):
            saver.restore(sess, "./tmp/model/my_linear.ckpt")
        print("训练后模型参数：权重%f,偏置%f,损失为%f" % (weights.eval(), bais.eval(), error.eval()))

import os
Linear_regression()

训练前模型参数：权重0.381453,偏置0.181587,损失伟为0.473731
训练后模型参数：权重0.381453,偏置0.181587,损失为0.546453

self.键盘上的钢琴师.LX

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python深度学习TensorFlow1.0版本框架day1

黑马程序3天tensorflow课程笔记import tensorflow as tfdef tensorflow_demo(): '''tensorflow 的基本结构''' #原来的加法运算 a = 2 b =3 c = a+b print('普通加法运算：\n',c) #tensorflow 实现加法运算 a_t = tf.constant(2, name="a_t") b_t = tf.constant(3, name=
复制链接

扫一扫