tensorflow 笔记(2):tensorflow框架

1.基于Tensorflow的NN：用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。

2.张量（tensor）：多为数组（列表）   阶：张量的维数（几个方括号几阶）

#vim ~/.vimrc 写入：      set ts=4        set nu       配置使Tab缩进4格

3.数据类型：Tensorflow的数据类型有tf.float32、tf.int32等

print输出内容(计算图)：Tensor(“节点名”，shape=(长度，),dtype=float32)         #shape 维度     dtype 数据类型

4.计算图（Graph）：搭建神经网络的计算过程，只搭建，不运算。

5.会话（Session）：执行计算图中的节点运算。

语法：

with tf.Session() as sess:
    sess.run(内容)

6.参数：即神经元线上的权重W，用变量表示，随机给初值。

语法：

w = tf.Variable(tf.random_normal([2,3],stddev=2,mean=0,seed=1))
      #生成随机数       正态分布    2×3矩阵  （标准差为2  均值为0 随机种子为1）可默认

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

7.神经网络实现过程：

（1）准备数据集，提取特征，作为输入喂给神经网络（NN）

（2）搭建NN结构，从输入到输出（先搭建计算图，再用会话执行）（NN前向传播算法—>输出）

（3）大量特征数据喂给NN，迭代优化NN参数（NN反向传播算法—>优化参数训练模型）

（4）使用训练好的模型预测和分类

8.前向传播—>搭建模型，实现推理

# -*- coding: utf-8 -*-

import tensorflow as tf

#定义输入参数
#用placeholder定义输入(sess.run喂多组数据)
x = tf.placeholder(tf.float32,shape=(None,2))
#几行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)
    #汇总所有待优化变量
    
    print("the result is :\n",sess.run(y,feed_dict={x:[[0.7,0.5],[0.2,0.3],[0.3,0.4],[0.4,0.5]]}))
    #feed_dict喂多组数据
    print("w1:\n",sess.run(w1))
    print("w1:\n",sess.run(w2))

9.反向传播

定义:训练模型参数，在所有参数上用梯度下降，使NN模型在训练数据上的损失函数最小。

损失函数（loss）：预测值（y）与已知答案（y_）的差距

方法一：均方误差（方差）：loss=tf.reduce_mean(tf.square(y_-y))

反向传播训练方法：以减小loss为优化目标

方法一：梯度下降：train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

学习率：决定参数每次更新的幅度

简单神经网络：

#coding:utf-8
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8 #一次喂入多少数据（不宜过大）
seed = 23455 #随机种子

# 基于seed生成随机数
rng = np.random.RandomState(seed)

# 使用numpy 生成随机数 32行*两列表示32组体积和重量 
X = rng.rand(32,2)

# 人为标注作为训练集 ，将X的每一行相加，如果小于1，Y为1，如果不小于1,Y为0
Y = [[int(x0+x1 < 1)] for (x0, x1) in X]
print("X:\n",X) #数据集X
print("Y:\n",Y) #标签Y

# 输入x，y_为标签
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))

# 权重 w1,w2
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)

# 定义损失函数和反向传播算法
loss = tf.reduce_mean(tf.square(y-y_))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#0.001学习率，损失函数loss朝减小方向优化
#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]})
        #每500轮打印一次loss值
        if i % 500 == 0:
            total_loss = sess.run(loss, feed_dict={x: X, y_: Y})
            print("After %d training steps, loss on all data is %g" % (i, total_loss))
    print("w1:\n", sess.run(w1))
    print("w2:\n", sess.run(w2))

搭建神经网络八股：准备、前传、反传、迭代

准备：      import
           常量定义
           生成数据集 

前向传播：定义输入、参数和输出
            x=
            y_=
            
            w1=
            w2=

            a=
            y=

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

生成会话，训练STEPS轮
            with tf.session() as sess
                init_op=tf.global_variables_initializer()
                sess_run(init_op)

                STEPS=3000
                for i in range(STEPS):
                        start=
                        end=
                        sess.run(train_step,feed_dict:)