tensorflow学习01

梦里梦外; 2022-01-26 01:21 253阅读 0赞

# import tensorflow
    # 使用图graphs来表示计算任务
    # 在被称之为会话Session的上下文context中执行图
    # 使用tensor表示数据
    # 通过变量（Variable)维护状态
    # 使用feed和fetch可以为任意的操作赋值或者从其中获取数据
    # Tensorflow是一个编程系统，使用图（graphs）来计算任务，图（graphs）中的节点称之为Op(operation),yi一个
    # 获得0个或多个Tensor，执行计算，产生0个或多Tensor。Tensor看作是一个N维的数组或列表。图必须在会话session里被启动
    #创建启动图
    import tensorflow as tf
    #创建一个常量Op
    m1=tf.constant([[3,3]])
    m2=tf.constant([2],[3])
    #创建矩阵乘法op，把m1,m2传入
    product=tf.matmul(m1,m2)
    #定义会话 启动默认图
    sess=tf.Session()
    result=sess.run(product)
    print(result)
    sess.close()
    with tf.Session() as sess:
        result = sess.run(product)
        print(result)
    
    x=tf.Variable([1,2])
    a=tf.constant([3,3])
    sub=tf.subtract(x,a)
    add=tf.add(x,sub)
    init=tf.global_variables_initializer()#变量初始化
    
    with tf.Session() as sess:
        sess.run(init)
        print(sess.run(sub))
    
    state=tf.Variable(0,name='counter')
    new_state=tf.add(state,new_state)
    #赋值op
    update=tf.assign(state,new_state)
    init=tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init)
        print(sess.run(state))
        for _ in range (5):
            sess.run(update)
    #Fetch and feed
    input1=tf.constant(3,0)
    input2=tf.constant(2,0)
    input3=tf.constant(5,0)
    add=tf.add(input2,input3)
    mul=tf.multiply(input1,add)
    with tf.Session() as sess:
        result=sess.run([mul,add])
        print(result)
    #FEED
    #创建占位符
    input1=tf.placeholder(tf.float32)
    input2=tf.placeholder(tf.float32)
    output=tf.multiply(input1,input2)
    with tf.Session() as sess:
        #feed的数据以字典的形式传入
        print(sess.run(output,feed_dict={input1:[7.],input2:[2.]}))
    
    #Tensorflow 简单实例
    import tensorflow as tf
    import  numpy as np
    #使用numpy生成100个随机点
    x_data=np.random.rand(100)
    y_data=x_data*0.1+0.2
    #构造一个线性模型
    b=tf.Variable(0.)
    k=tf.Variable(0.)
    y=k*x_data+b
    
    #二次代价函数
    loss=tf.reduce_mean(tf.square(y_data-y))
    #定义一个梯度下降算法来进行训练的优化器
    optimizer =tf.train.GradientDescentOptimizer(0.2)
    #最小化代价函数
    train=optimizer.minimize(loss)
    init=tf.global_variables_initializer
    
    with tf.Session() as sess:
        sess.run(init)
        for step in range(201):
            sess.run(train)
            if step%20 ==0:
                print(step.sess.run([k,b]))
    
    #非线性回归
    import  tensorflow as tf
    import numpy as np
    import  matplotlib.pyplot as plt
    #z使用numpy生成200个随机点
    x_data=np.linspace(0.5,0.5,200)[:,np.newaxis]
    nosie=np.random.normal(0,0.02,x_data.shape)
    y_data=np.square(x_data)+noise
    #定义两个placeholder
    x=tf.placeholder(tf.float32,[None,1])
    y=tf.placeholder(tf.float32,[None,1])
    
    ##定义神经网络中间层
    Weights_L1=tf.Variable(tf.random_normal([1,10]))
    biases_L1=tf.Variable(tf.zeros([1,10]))
    Wx_plus_b_L1=tf.matmul(x,Weights_L1)+biases_L1
    L1=tf.nn.tanh(Wx_plus_b_L1)
    
    #定义神经网络的输出层
    Weights_L2=tf.Variable(tf.random_normal([10,1]))#神经元个数改变权值形状改变
    # 中间层10个神经元输出层1个神经元 所以是10行1列的权值
    biases_L2=tf.Variable(tf.zeros([1,1]))#因为输出层一个神经元 只有一个偏失值
    #输出层信号的总和
    Wx_plus_b_L2=tf.matmul(L1,Weights_L2)+biases_L2#输出层的输入相当于中间层（L1）的输出 就是把L1输入到这里
    #最后d的信号就是预测的结果 输出的预测需要经过一个激活函数
    prediction=tf.nn.tanh(Wx_plus_b_L2)
    
    #二次代价函数
    loss=tf.reduce_mean(tf.square(y-prediction))
    #使用梯度下降法训练
    train_step=tf.train.GradientDescentOptimizer(0,1).minmize(loss)
    
    with tf.Session() as sess:
        #变量初始化
         sess.run(tf.global_variables_initializer())
        for _ in range(2000):
            #训练2000次
            sess.run(train_step,feed_dict={x:x_data,y:y_data})#x_data.y_data是样本
        #获得预测值
        prediction_value=sess.run(prediction,feed_dict={x:x_data})
        #画图看预测结果散点图方式
        plt.figure()
        plt.scatter(x_data,y_data)
        plt.plot(x_data,prediction_value,'r-',lw=5)
        plt.show()
    
    
    #手写数字 softmax使用
    import tensorflow as tf
    from tensorflow.examples1.tutorials.mnist import input_data
    #载入数据
    mnist=input_data.read_data_sets("MNIST_data",one_hot=True)
    #每个批次的大小
    batch_size=100
    #计算一共有多少个批次
    n_batch=mnist.train.numexamples//batch_size#整除
    
    #定义两个placeholder
    x=tf.placeholder(tf.float32,[None,784])#None代表传入批次的任意值，一张图片28*28，把28的的平面图片转化为
    一维的向量784 # 784列
    y=tf.placeholder(tf.float32,[None,10])#数字是0-9
    #输入层784神经元
    #输出层10个标签十个神经元
    #创建一个简单的神经网络
    W=tf.Variable(tf.zeros([784,10]))
    b=tf.Variable(tf.zeros([10]))
    prediction=tf.nn.softmax(tf.matmul(x,W)+b)
    #二次代价函数
    loss=tf.reduce_mean(tf.square(y-prediction))
    #使用梯度下降法
    train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
    
    #初始化变量
    init=tf.global_variables_initializer()
    #结果存放在布尔型列表中 argamx返回一维张量中最大的值所在的位置
    correct_prediction=tf.equal(tf.argamx(y,1),tf.argmax(prediction,1))#两个参数是否相等 true false
    #求准确率
    accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#对比 将correct_prediction转化为tf.float32类型  cast函数转化类型 true为1.0 false为0
    with tf.Session() as sess:
        sess.run(init)
        for epoch in range(21):
            for batch in range(n_batch):
                batch_xs,batch_ys=mnist.train.next_batch(batch_size)#batch_xs保存图片batch_ys保存图片标签
                sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})
                
                acc=sess.run(accuary,feed_dict={x:mnist.test.images,y:mnist.test.labels})
                print("Iter"+str(epoch)+",Testing Accuracy"+str(acc))