第一节，基本用法(代码片段)

# -*- coding: utf-8 -*-
"""
Created on Sat Mar 31 16:54:02 2018

@author: Administrator
"""

#TensorFlow第一节

import tensorflow as tf

\'\'\'
构建阶段：op 的执行步骤被描述成一个图
\'\'\'

#创建一个常量op,产生一个1 x 2矩阵，这个op被称做一个节点，加到默认图中，构造器的返回值代表常量op的输出
matrix1 = tf.constant([[3.,3.]])

#创建另一个常量op。产生一个2 x 1的矩阵
matrix2 = tf.constant([[2.],[2.]])

#创建一个矩阵乘法 matmul op，把matrix1和matrix2作为输入
product = tf.matmul(matrix1,matrix2)

\'\'\'
默认图现在有三个节点，两个常量 constant() op和一个 matmul() op，wile真正进行矩阵相乘运算，并得到矩阵
乘法的结果，你必须载会话中启动这个图
\'\'\'
\'\'\'
执行阶段：使用会话执行执行图中的 op.
\'\'\'
#构造阶段完成后，才能启动图，启动图的第一步是创建一个Session对象，如果无任何创建函数，会话构造器将启动默认图
sess = tf.Session()

\'\'\'
调用sess的run()方法来执行矩阵乘法op,传入product作为该方法的参数，上面提到，product代表矩阵乘法op的输出
#传入它是向方法表明，我们希望取回矩阵乘法op的输出
整个执行过程是自动化的，会话负责传递op所需的全部输入，op通常是并发执行的
函数调用run(product)触发了图中三个op的执行
返回值result是一个numpy.ndarray对象
\'\'\'

result = sess.run(product)
print(result)                         #[[ 12.]]

#任务完毕，关闭会话，Session对象在使用完毕后需要关闭以释放资源，除了显示调用close()外，也可以使用with代码块
sess.close()


\'\'\'
在实现上, TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU).
一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测. 如果检测到 GPU, TensorFlow 会尽
可能地利用找到的第一个 GPU 来执行操作.
如果机器上有超过一个可用的 GPU, 除第一个外的其它 GPU 默认是不参与计算的. 为了让 TensorFlow 使用
这些 GPU, 你必须将 op 明确指派给它们执行. with...Device 语句用来指派特定的 CPU 或 GPU 执行操作:
\'\'\'

\'\'\'
设备用字符串进行标识. 目前支持的设备包括:
    "/cpu:0": 机器的 CPU.
    "/gpu:0": 机器的第一个 GPU, 如果有的话.
    "/gpu:1": 机器的第二个 GPU, 以此类推.
\'\'\'
with tf.Session() as sess:
    with tf.device("/cpu:0"):
        print(sess.run(product))             #[[ 12.]]
        
        
\'\'\'
交互式使用
文档中的python实例使用一个会话Seesion来启动图，并调用Session.run()方法执行操作
为了方便使用诸如IPython之类的Python交互环境，可以使用InteractiveSession替代Session类，使用Tensor.eval()
和Operation.run()方法来代替Session.run()，这样可以避免使用一个变量来持有会话
\'\'\'
#进入一个交互式TensorFlow会话
sess = tf.InteractiveSession()

x = tf.Variable([1.0,2.0])
a = tf.constant([3.0,3.0])

#使用初始化器 initinalizer op的run()初始化x
x.initializer.run()

#增加一个减去sub op,从 x 减去 a，运行减去op，输出结果
sub = tf.subtract(x,a)
print(sub.eval())               #[-2. -1.]

#创建一个变量，初始化为标量0
state = tf.Variable(0,name = \'counter\')

#创建一个op，其作用是使state增1
one = tf.constant(1)
new_value = tf.add(state,one)

\'\'\'
assign()操作室图所描述的表达式的一部分，正如add()操作一样，所以在调用run()执行表达式之前，它并不会
正则执行赋值操作

通常会将一个统计模型中的参数表示为一组变量. 例如, 你可以将一个神经网络的权重作为某个变量存储在一个 
tensor 中. 在训练过程中, 通过重复运行训练图, 更新这个 tensor.
\'\'\'
update = tf.assign(state,new_value)

#启动图后，变量必须先经过\'初始化\' op 
#首先必须增加一个 \'初始化\' op 到图中
init_op = tf.global_variables_initializer()

#启动图，运行op
with tf.Session() as sess:
    sess.run(init_op)
    #打印state初始值
    print(sess.run(state))             #0
    #运行op,更新state,并打印
    for _ in range(3):
        sess.run(update)
        print(sess.run(state))      #1  2  3

in1 = tf.constant(1.0)
in2 = tf.constant(2.0)
in3 = tf.constant(3.0)
intermed = tf.add(in1,in2)
mul = tf.multiply(in2,in3)

#需要获取多个tensor，在op的一次运行中一起获得。
with tf.Session() as sess:
    re = sess.run([intermed,mul])
    print(re)                 #[3.0, 6.0]

input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.multiply(input1, input2)

#使用7替代input1,2替代input2，feed操作相当于设置一个占位符
with tf.Session() as sess:
  print(sess.run([output], feed_dict=input1:[7.], input2:[2.]))    #[array([ 14.], dtype=float32)]  

#二元线性回归案例
import numpy as np

\'\'\'
准备数据，并设置目标函数
\'\'\'
#产生测试数据     
def genDate(numPoints,bias,variance):
    \'\'\'
    :param numPoints : 实例个数 两维数据
    :param bias : 偏向值
    :param variance : 变化
    返回得到的x和y数据
    \'\'\'
    #产生numPoints*2的零矩阵
    x = np.zeros(shape = (numPoints,2))
    #产生一维数组
    y = np.zeros(shape = numPoints)
    for i in range(0,numPoints):        
        #x赋值  x = [[1,0],[1,1],[1,2]...]
        x[i][0] = 1
        x[i][1] = i        
        #y赋值  正太分布      
        y[i] = i + np.random.normal(loc=bias, scale=variance, size=None)   
    return np.array(x,dtype = \'float32\').reshape(numPoints,2),np.array(y,dtype = \'float32\').reshape(numPoints,1)

#生成数据
x_data,y_data = genDate(100,25,3)


print(x_data.shape,y_data.shape)

#print(training_x,training_y)

import matplotlib.pyplot as plt

fig = plt.figure(1,figsize=(8,4))
#http://blog.csdn.net/eddy_zheng/article/details/48713449
#ax=plt.subplot(111,projection=\'3d\') #创建一个三维的绘图工程
ax = Axes3D(fig)

#坐标轴
ax.set_zlabel(\'Z\') 
ax.set_ylabel(\'Y\')
ax.set_xlabel(\'X\')

ax.scatter(x_data[:,0],x_data[:,1],y_data,c=\'r\',s=1)         #绘制数据点


#构造二元线性回归模型
b = tf.Variable(1.0)
w = tf.Variable(tf.ones([2,1])) 
y = tf.matmul(x_data,w) + b

#设置均方差损失函数，在使用梯度下架法的时候学习率不能选择太多，不然会震荡，不会收敛  
cost = tf.reduce_mean(tf.square(y - y_data))  #拟合效果更好

#选择绝对损失函数可以拟合很好
#cost = tf.reduce_mean(tf.abs(y - y_data))

#选择梯度下降的方法 传入学习率
optimizer = tf.train.GradientDescentOptimizer(0.0001)   #学习率不能选择过大，不然会震荡
#迭代的目标，最小化损失函数
train = optimizer.minimize(cost)

\'\'\'
#开始求解
\'\'\'
#初始化变量：tf的准备工作，主要声明了变量，就必须先初始化才可以使用
init = tf.global_variables_initializer()

#设置tensorflow对GPU使用按需分配
config = tf.ConfigProto()
config.gpu_options.allow_growth = True

#使用会话执行图
with tf.Session(config=config) as sess:
    sess.run(init)
    #迭代，重复执行最下化损失函数这一步骤
    for step in range(100000):
        sess.run(train)
        if step % 10000 == 0:
            print(\'迭代次数0:W->1,b->2,3\'.format(step,sess.run(w),sess.run(b),sess.run(cost)))
    #保存最后结果
    rw = sess.run(w)
    rb = sess.run(b)
   
     
#计算预测的结果
X, Y = np.meshgrid(x_data[:,0], x_data[:,1])
Z = rb + rw[0]*X + rw[1]*Y 
#绘制数据点
ax.scatter(X,Y,Z,\'b--\',s=1)       

# -*- coding: utf-8 -*-
"""
Created on Thu Dec 21 22:06:59 2017

@author: zy
"""


#线性回归的例子 求解线性回归方程时采用的是梯度下降法
import numpy as np
from  sklearn import linear_model
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D



#梯度下降法
def gradientDescent(x,y,theta,alpha,m,numIterations):
    \'\'\'
    损失函数取：L(θ)=1/2*m*Σ(h(xi) - yi)^2 
    :param x: traning set 训练集数据
    :param y:输出
    :param theta:估计的参数向量  依次为b,w1,w2....
    :param alpha：梯度下降的步长
    :param m:样本的总个数
    :param numIterations : 迭代次数
    返回最后迭代值 局部极小值 
    \'\'\'
    #构建x的增广矩阵
    temp = np.ones([x.shape[0],x.shape[1]+1])
    temp[:,1:] = x
    x = temp
    xTrans = x.transpose()
    for i in range(0,numIterations):
        #hypothesis = X*θ
        hypothesis = np.dot(x,theta)         
        #误差 error = hypothesis - y
        loss = hypothesis - y
        #损失函数值L(θ)  
        #cost = np.sum(loss**2) / (2*m)
        #输出损失值
        #print(\'Iteration %d | cost: %f\'%(i,cost))
        #梯度 x\'*E
        gradient = np.dot(xTrans,loss)/m
        #更新参数
        theta = theta - alpha * gradient
    return theta
  
#产生测试数据     
def genDate(numPoints,bias,variance):
    \'\'\'
    :param numPoints : 实例个数 两维数据
    :param bias : 偏向值
    :param variance : 变化
    返回得到的x和y数据
    \'\'\'
    #产生numPoints*2的零矩阵
    x = np.zeros(shape = (numPoints,2))
    #产生一维数组
    y = np.zeros(shape = numPoints)
    for i in range(0,numPoints):        
        #x赋值  x = [[1,0],[1,1],[1,2]...]
        x[i][0] = 1
        x[i][1] = i        
        #y赋值  正太分布      
        y[i] = i + np.random.normal(loc=bias, scale=variance, size=None)   
    return np.array(x,dtype = \'float32\'),np.array(y,dtype = \'float32\')

#生成测试数据
x,y = genDate(100,25,3)

#print(\'x:\',x)
#print(\'y:\',y)
#获取行数和列数
m,n = np.shape(x)
n = n+1
    
numIterations = 100000
alpha = 0.0005
#初始化参数值
theta = np.ones(n)   
#print(theta)     
#使用梯度下降法求解多元线性回归
theta = gradientDescent(x,y,theta,alpha,m,numIterations)
print(\'theta\',theta)


#使用自带多元线性回归类库求解  可以看出下面求得与梯度下降的结果一样
#创建实例
regr = linear_model.LinearRegression()
#开始训练算法
regr.fit(x,y)

#打印权重系数
print(\'coefficients\')
print(regr.coef_)
#打印截距
print(\'intercept\')
print(regr.intercept_)


\'\'\'
绘制结果
\'\'\'
fig = plt.figure(1,figsize=(8,4))
#http://blog.csdn.net/eddy_zheng/article/details/48713449
#ax=plt.subplot(111,projection=\'3d\') #创建一个三维的绘图工程
ax = Axes3D(fig)

#坐标轴
ax.set_zlabel(\'Z\') 
ax.set_ylabel(\'Y\')
ax.set_xlabel(\'X\')

#将数据点分成三部分画，在颜色上有区分度
ax.scatter(x[:30,0],x[:30,1],y[:30],c=\'y\',s=2)         #绘制数据点
ax.scatter(x[30:70,0],x[30:70,1],y[30:70],c=\'r\',s=2)
ax.scatter(x[70:,0],x[70:,1],y[70:],c=\'g\',s=2)

#计算预测的结果
X, Y = np.meshgrid(x[:,0], x[:,1])
#print(\'X\',X)
#print(\'Y\',Y)
Z = theta[0] + theta[1]*X + theta[2]*Y 
#print(\'Z\',Z)
#绘制数据点
ax.scatter(X,Y,Z,\'b--\',s=1)       

\'\'\'
使用tf来实现对一组数求和，再计算平均
\'\'\'
h_sum = tf.Variable(0.0,dtype=tf.float32)
h_vec = tf.constant([1.0,2.0,3.0,4.0])
#把h_vec每个元素加到h_sum中，然后再除以10来计算平均值
#待添加的数
h_add = tf.placeholder(tf.float32)
#添加之后的值
h_new = tf.add(h_sum,h_add)
#更新h_new
update = tf.assign(h_sum,h_new)


with tf.Session() as sess:    
    sess.run(tf.global_variables_initializer())
    #输出原始值
    print(\'h_sum\',sess.run(h_sum))          #h_sum 0.0
    print(\'h_vec\',sess.run(h_vec))          #h_vec [ 1.  2.  3.  4.]
    
    
    #循环添加
    for i in range(4):
        sess.run(update,feed_dict=h_add:sess.run(h_vec[i]))     
        #输出每次求和之后的值
        print(\'h_sum\',sess.run(h_sum))    #h_sum 1.0
                                          #h_sum 3.0
                                          #h_sum 6.0
                                          #h_sum 10.0
        
    
    #计算平均值
    print(\'The mean is:\',sess.run(h_sum)/4.0)                            #The mean is: 2.5
    #print(\'The mean is:\',sess.run(sess.run(h_sum)/tf.constant(4.0)))     #The mean is: 2.5
    
    

\'\'\'    
使用 tf.InteractiveSession() 来 求和 、平均 的操作呢?
\'\'\'
sess = tf.InteractiveSession()
#初始化变量
sess.run(tf.global_variables_initializer())
print(\'h_sum\', h_sum.eval())
print("h_vec", h_vec.eval())
print("vec", h_vec[0].eval())


for i in range(4):
    update.eval(feed_dict=h_add: h_vec[i].eval())
    print(\'h_sum =\', h_sum.eval())
sess.close()