Tensorflow框架

import tensorflow as tf

#张量的计算图，神经网络的计算过程，只搭建，不运算。
a=tf.constant([1.0,2.0])
b=tf.constant([3.0,4.0])
result=a+b
print(result)

c=tf.constant([[1.0,2.0]])
d=tf.constant([[3.0],[4.0]])
y=tf.matmul(c,d)
print(y)
'''
会话（session)执行计算图中的节点运算
'''
with tf.Session() as sess:
    print(sess.run(y))
    print(sess.run(result))

　

import tensorflow as tf

'''
神经网络实现过程：
1，准备数据集，提取特征，作为输入喂给神经网络
2，搭建NN结构，从输入到输出(先搭建计算图，再用会话执行)
（NN前向传播算法--->计算输出)
3大量特征数据喂给NN,迭代优化NN参数
(NN反向传播算法--->优化参数训练模型)
4使用训练好的模型预测和分类
'''

'''
参数:即神经网络线上权重W,用变量表示，随机给初值
w=tf.Variable(tf.random_normal([2,3],stddev=2,mean=0,seed=1))
random_normal  正态分布
[2,3]   产生2*3矩阵
stddev=2  标准差为2
mean=0     均值为0
seed=1    随机种子
tf.truncated_normal()  去掉过大偏离点的正态分布
tf.random_uniform()     平均分布

tf.zeros  全0数组
tf.ones   全1数组
tf.fill   全定值数组
tf.constant 直接给值
'''

#前向传播

#coding:utf-8
import tensorflow as tf

#定义输入和参数
#用placeholder实现输入定义(sess.run喂一组数据)
x=tf.placeholder(tf.float32,shape=(1,2))
#x=tf.constant([[0.7,0.5]])
#用placeholder实现输入定义(sess.run喂多组组数据)
#x=tf.placeholder(tf.float32,shape=(None,2))
'''因为shape(None,2)中的特征有两个所以是shape(None,2)'''
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

#定义向前传播过程
a=tf.matmul(x,w1)
y=tf.matmul(a,w2)

#用会话计算结果
with tf.Session() as sess:
    '''变量初始化'''
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    #sess.run(y,feed_dict={x:[[0.7,0.5]]})
    '''feed_dict喂入信息'''
    print(sess.run(y,feed_dict={x:[[0.7,0.5]]}))
    '''结果[[3.0904665]]'''

　　

#coding:utf-8
import tensorflow as tf
import numpy as np
BATCH_SIZE=8
seed=23455

'''基于seed产生的随机数'''
rng=np.random.RandomState(seed)
'''随机数返回32行2列的矩阵，表示32组 体积和重量 作为输入的数据集'''
X=rng.rand(32,2)
'''从x这个32行2列的矩阵中 取出一行 判断如果和小于1 给Y赋值1 如果和不小于1 给Y赋值0
作为输入数据集的标签(正确答案)
'''
Y=[[int(x0+x1<1)] for (x0,x1) in X ]
print("X:\n",X)
print("Y:\n",Y)

'''1定义神经网络的输入，参数和输出，定义前向传播过程'''
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))

w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

a=tf.matmul(x,w1)
y=tf.matmul(a,w2)

'''2定义损失函数及反向传播方法'''
loss=tf.reduce_mean(tf.square(y-y_))
'''均方误差计算loss'''
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss)
'''这三个都可以
使用梯度下降实现训练过程，学习率填0.001
'''
#train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss)
#train_step=tf.train.AdamOptimizer(0.001).minimize(loss)

'''生成会话，训练STEPS轮'''
with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    #输出目前（未经训练）的参数取值
    print("w1\n",sess.run(w1))
    print("w2:\n",sess.run(w2))

    '''训练模型'''
    STEPS=3000
    for i in range(STEPS):
        start=(i*BATCH_SIZE)%32
        end=start+BATCH_SIZE
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]})
        if i%500==0:
            total_loss=sess.run(loss,feed_dict={x:X,y_:Y})
            print("after %d training step(s),loss on all data is %g"%(i,total_loss))

    '''输出训练后的参数取值'''
    print("\n")
    print("w1:\n",sess.run(w1))
    print("w2:\n",sess.run(w2))

'''搭建神经网络的八股:准备，前传，反传，迭代
01准备  import  常量定义  生成数据集
02前向传播:定义输入，参数和输出
x=
y_=
w1=
w2=
a=
y=

03反向传播：定义损失函数，反转传播方法
loss=
train_step=

04生成会话，训练STEPS轮

'''