tensorflow学习笔记（从0开始）

看mooc北大的tensorflow学习笔记课程的笔记av71676258和自己遇到的问题

去掉警告：
比如这种警告（因为安装问题的警告）：The TensorFlow library wasn’t compiled to use SSE instructions,

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

识别中文字符：

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

画正方形：

 import turtle
t = turtle.Pen()
for i in range(0, 4):
    t.forward(100)
    t.left(90)

变量包括： 数值，字符，数组，字典，元组
数组： a=[1,2,3,4,5]
a[0]=1,a[4: :-2]=[5,3],del a[4]
列表名[起：止：步长] 列表名.Insert（插入位置索引，新元素）
字典： b={1:‘name’,‘ch’:100}
字典名[键]=新值，字典名[新键]=新值
元组： 不变 c=(1,2,3)

变量作用域：
局部变量：在函数中定义，只在函数中可用
全局变量：在函数前定义，一般在整个代码最前面定义

定义函数与占位符%s： 带返回值的用return

def hi_name(yourname):
    print "hello %s" %yourname

就是将后一个%内的yourname放%s的位置

模块： 函数的集合，先导入再使用，用模块.函数名调用。

import time
time.asctime(）

包： 包含多个模块

from PIL import Image  #从PIL包里调用Image模块

类： 函数的集合，可实例化出对象的模具
实例化： 对象=类（） t = turtle.Pen() Pen就是类
类的第一个字母大写
有父类和子类，子类实体化出的对象可以使用父类的函数和变量
用class定义类，定义子类后面加（父类名），下一行用pass起架构再用具体函数替换
类里定义函数，第一个参数必须是self（self）

对象: 类实例化出的实体，完成具体工作

面向对象： 程序员反复修改优化类，类实例化出对象，对象调用类里的函数执行具体的操作。
eg.

class Cats(Mammals):
    def __init__(self,spots ):  #__init__类实例化时首先默认的初始化函数，给实例化对象赋初值
        self.spots=spots
    def catch_mouse(self):
        print "catch mouse"
#猫类实例化出一个叫kitty的对象，特征时10个spots：
kitty = Cats(10)   #实例化运行__init__函数，给spots赋初值
print kitty.spots   #打印出10 
#kitty可以做具体的工作，比如运行catch_mouse函数：
kitty.catch_mouse()  #对象调用类里的函数（变量），对象.函数名（变量名）
>>>catch mouse
类里定义函数，调用自身或父类的函数或变量，用self.

文件写操作：开、存、关
开： 文件变量 = open（“文件路径文件名”，“wb”）
存：pickle.dump（待写入的变量，文件变量）
关：文件变量.close（）
文件读操作：开、取、关
开：文件变量 = open（“文件路径文件名”，“rb”）
取：放内容的变量 = pickle.load（文件变量）
关：文件变量.close()

张量： 多维数组（列表），阶为张量的维数
0-D为标量，1-D为向量[1,2]，2-D为矩阵[[1,2],[3,4]],n-D有n个[[[

tf.constant函数：定义常数

计算图（Graph）： 搭建神经网络的计算过程，不运算，结果为张量的名称维度和类型。
会话（Session）： 执行计算图中的节点运算，

with tf.Session() as sess:
    print sess.run(y）
eg.import tensorflow as tf
a = tf.constant([[1.0, 2.0]])
b = tf.constant([[3.0], [4.0]])
y = tf.matmul(a, b)
print(y)
with tf.Session() as sess:
    print(sess.run(y))
>>>Tensor("MatMul:0", shape=(1, 1), dtype=float32)
[[11.]]

参数： 从神经元线上的的权重，用变量表示，初值随机。
生成随机数：

tf.Variable(tf.random_normal([2,3], stddev=2, mean=0, seed=1))正态分布           矩阵    标准差      平均值   随机种子

随机种子如果去掉，每次生成的随机数会不一致
tf.random_normal()还可以用tf.truncated_normal()去掉过大偏离点正态分布、tf.random_uniform()平均分布来替换。

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

变量初始化： 在sess.run函数中用tf.global_variables_initializer()
init_op = tf.global_variables__initializer()
sess.run(init_op)
在sess.run中喂数据： 用tf.placeholder占位，在sess.run中用feed_dict喂数据
x=tf.placeholder(tf.float32,shape=(None,2)) #None为多组数据，2个输入特征
sess.run(y, feed_dict={x: [[0.1, 0.2], [0.2, 0.3], [0.3, 0.4]]})
eg.

x = tf.placeholder(tf.float32, 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)
    print("y is:", sess.run(y, feed_dict={x: [[0.7, 0.5], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]}))
    print("w1:", sess.run(w1))
    print("w2:", sess.run(w2))

反向传播： 训练模型参数，在所有参数上用梯度下降，使NN模型在训练数据上的损失函数最小训练方法以减小loss为优化目标。

train_step tf.train.GradienDescentOptimizer(learning_rate).minimize(loss)
train_step=tf.train.MomentumOptimizer(learing_rate,momentum).minmize(loss)
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)

学习率： 决定参数每次更新的幅度，需要在一开始设定
损失函数（loss）： 预测值（y）与已知答案（y_）的差距
均方误差MSE： loss = tf.reduce_mean(tf.square(y_-y))
eg.

# coding:utf-8
import tensorflow as tf
import numpy as np
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
BATCH_SIZE = 8  #一次喂入神经网络多少组数据
seed = 23455

rng = np.random.RandomState(seed)
X = rng.rand(32, 2)  #随机生成32组输入数据，为体积和重量
Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]  #设置x0+x1<1返回1，否则为0
print("X:", X)
print("y:", Y)

#前向传播过程：定义输入，参数，输出
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)
#定义损失函数和反向传播方法
loss = tf.reduce_mean(tf.square(y-y_))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print("w1:", sess.run(w1))
    print("w2:", sess.run(w2))
    print("/n")
    STEPS = 3000  #训练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:  #每500次，输出一次loss
            total_loss = sess.run(loss, feed_dict={x: X, y_: Y})
            print("After %d steps, loss is %g" % (i, total_loss))
    print("/n")
    print("w1:", sess.run(w1))
    print("w2:", sess.run(w2))

搭建神经网络的八股：
准备（import、常量定义、数据集）、
前向传播（输入、参数、输出）、
反向传播（定义损失函数、反向传播方法）、
迭代（with生成会话、训练STEPS）

神经元模型： 输入、权重、偏置b、激活函数f
激活函数：
tf.nn.relu() 小于0为0，大于等于0为x
tf.nn.sigmoid() 以（0，0.5）为对称中心，上下限为1、0的S曲线
tf.nn.tanh() 以（0，0）为对称中心，上下限为1、-1的S曲线
NN的复杂度： 多用NN的层数（不包括输入层）和NN参数个数表示

神经网络的优化： 损失函数loss（预测值与已知值的差距，loss最小）、学习率learning_rate、滑动平均ema、正则化regularization
比较判断函数： tf.where(tf.greater(y, y_), COST(y- y_),PROFIT(y_- y)) #y>y_?,真,假

交叉熵ce（Cross Entropy）： 两个概率分布之间的距离
ce = -tf.reduce_mean(y_*tf.log(tf.cilp_by_value(y, 1e-12, 1.0)))
或
ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
cem = tf.reduce_mean(ce)

学习率： 每次参数更新的幅度（参数更新向损失函数梯度下降的方向，以找到损失函数梯度最小点，即loss最小点）
更新后的参数=当前参数 - 学习率×损失函数的导数
学习率大了震荡不收敛，学习率小了收敛速度缓慢，所以设置：

指数衰减学习率：
学习率=初值*衰减率（global_step/LEARNING_RATE_STEP）
global_step： 当前运行了几轮BATCH_SIZE，据此动态改变学习率
LEARNING_RATE_STEP：多少轮更新一次学习率=总样本数/BATCH_SIZE

global_step = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, LEARNING_RATE_STEP, LEARNING_RATE_DECAY, staircase=True)

滑动平均（影子值）： 记录每个参数一段时间过往值的平均，增加模型的泛化性
影子 = 衰减率*影子 +（1 - 衰减率）*参数 影子初值=参数初值
衰减率 = min{MOVING_AVERAGE_DECAY，（（1+轮数）/（10+轮数））}

ema = tf.train.ExponentiaMovingAverage(MOVING_AVERAGE_DECAY, global_step)
ema_op =  ema.apply(tf.trainable_variables())
with tf.control_dependencies([train_step, ema_op]):train_op = tf.no_op(name='train')

正则化缓解过拟合： 正则化在损失函数中引入了模型复杂度指标，利用给W加权值，弱化了训练数据的噪声
loss =所有参数的损失函数 loss(y与y_)+正则化的权重REGULARIZER*loss(参数w)
L1正则化：对wi求和

loss(w) = tf.contrib.layers.l1_regularizer(REGULARIZER)(w)

L2正则化：对wi的平方绝对值求和

loss(w) = tf.contrib.layers.l2_regularizer(REGULARIZER)(w)
tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(REGULARIZER)(w))
loss = cem + tf.add_n(tf.get_collection('losses'))