tensorflow学习01

# 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))