TensorFlow 多元線性回歸【波士頓房價】

1數據讀取

1.1數據集解讀

1.2引入包

%matplotlib notebook

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle

1.2.1pandas介紹

1.2.2TensorFlow下安裝pandas

1、激活tensorflow：      Activate tensorflow
2、安裝Pandas：          conda install pandas

1.2.3出現“No module named 'sklearn'”錯誤

原因：未安裝sklearn模塊

方法：

在anaconda 中安裝： conda install scikit-learn

1.3顯示數據

# 讀取數據文件   boston.csv文件位置自填
df = pd.read_csv("D:\學習資料\課程學習資料\深度學習\TensorFlow/boston.csv",header = 0)  

# 顯示數據摘要描述信息
print(df.describe()

　

# 打印所有數據，只顯示前30行和后三十行
print(df)

　

# 獲取df的值
df = df.values
print(df)

　

# 將df轉換成np的數組格式 ,內部存儲格式不同，方便以后使用np的功能
df = np.array(df)
print(df)

　

# x_data為前12列的數據，實際上是0 - 11列;y_data為最后一列的數據，即12列
x_data = df[:,:12]
y_data = df[:,12]
print(x_data,"\nshape = ",x_data.shape)
print(y_data,"\nshape = ",y_data.shape)

2模型定義

2.1定義訓練的占位符

#定義特征數據和標簽數據的占位符
#shape中 None 表示行的數量未知，在實際訓練時決定一次代入多少行樣本，從一
#個樣本的隨機SDG到批量SDG都可以
x = tf.placeholder(tf.float32,[None,12],name = "X")  #12個特征數據（12列）
y = tf.placeholder(tf.float32,[None,1],name = "Y")  #1個標簽數據（1列）

2.2定義模型結構

定義模型函數

# 定義一個命名空間
with tf.name_scope("model"):
    # w 初始化值為shape =  (12,1)的隨機數  stddev為標准差
    w = tf.Variable(tf.random_normal([12,1],stddev = 0.01),name = "w")
    # b 初始化值為 1.0 
    b = tf.Variable(1.0,name = "b")
    #w和x是矩陣相乘，用matmul,不能用mutiply或*
    def model(x,w,b):
        return tf.matmul(x,w) + b
    
    #預測計算操作，前向計算節點
    pred = model(x,w,b)

3模型訓練

3.1設置訓練超參數

# 迭代輪次
train_epochs = 50

# 學習率
learning_rate = 0.01

3.2定義均方差損失函數

#定義均方差損失函數
with tf.name_scope("LossFunction"):
    loss_function = tf.reduce_mean(tf.pow(y -pred,2))

3.3選擇優化器

# 創建優化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

常用優化器包括：

tf.train.GradientDescentOptimizer
tf.train.AdadeltaOptimizer
tf.train.AdagradOptimizer
tf.train.AdagradDAOptimizer
tf.train.MomentumOptimizer
tf.train.AdamOptimizer
tf.train.FtrlOptimizer
tf.train.ProximalGradientDescentOptimizer
tf.train.ProximalAdagradOptimizer
tf.train.RMSPropOptimizer

3.4聲明會話

#聲明回話
sess = tf.Session()
#定義初始化變量的操作
init = tf.global_variables_initializer()
#啟動會話
sess.run(init)

3.5迭代訓練

#迭代訓練
for epoch in range(train_epochs):
    loss_sum = 0.0
    for xs,ys in zip(x_data,y_data):
        
        #x_data得到的是一維數組，要變成二維數組；y_data得到的是一個常量，要變成二維數組
        xs = xs.reshape(1,12)
        ys = ys.reshape(1,1)
        # Feed 數據必須和Placeholder 的shape 一致
        _,loss = sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})
        
        loss_sum = loss_sum + loss
    
    #打亂數據順序
    x_data,y_data = shuffle(x_data,y_data)
    
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    loss_average = loss_sum / len(y_data)
    
    print("epoch=",epoch+1,"loss=",loss_average,"b=",b0temp,"w=",w0temp)

  注：訓練結果異常

3.6異常明示

3.6.1原因

 

3.6.2方法

4特征歸一化版本

%matplotlib notebook

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle

# 讀取數據文件
df = pd.read_csv("D:\學習資料\課程學習資料\深度學習\TensorFlow/boston.csv",header = 0)

# 顯示數據摘要描述信息
print(df.describe())

# 獲取df的值
df = df.values
print(df)

# 將df轉換成np的數組格式 ,內部存儲格式不同，方便以后使用np的功能
df = np.array(df)
print(df)

特征歸一化

# 對特征數據 【0到11】列 做 （0-1）歸一化
for i in range(12):
    df[:,i] = (df[:,i] - df[:,i].min()) / (df[:,i].max() - df[:,i].min())

#x_data 為歸一化后的前12列特征數據

x_data = df[:,:12]
#y_data 為最后一列標簽數據

y_data = df[:,12]

#定義特征數據和標簽數據的占位符
#shape中 None 表示行的數量未知，在實際訓練時決定一次代入多少行樣本，從一
#個樣本的隨機SDG到批量SDG都可以
x = tf.placeholder(tf.float32,[None,12],name = "X")  #12個特征數據（12列）
y = tf.placeholder(tf.float32,[None,1],name = "Y")  #1個標簽數據（1列）

# 定義一個命名空間
with tf.name_scope("model"):
    # w 初始化值為shape =  (12,1)的隨機數  stddev為標准差
    w = tf.Variable(tf.random_normal([12,1],stddev = 0.01),name = "w")
    # b 初始化值為 1.0 
    b = tf.Variable(1.0,name = "b")
    #w和x是矩陣相乘，用matmul,不能用mutiply或*
    def model(x,w,b):
        return tf.matmul(x,w) + b
    
    #預測計算操作，前向計算節點
    pred = model(x,w,b)

# 迭代輪次
train_epochs = 50

# 學習率
learning_rate = 0.01

#定義均方差損失函數
with tf.name_scope("LossFunction"):
    loss_function = tf.reduce_mean(tf.pow(y -pred,2))
    
# 創建優化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#聲明回話
sess = tf.Session()
#定義初始化變量的操作
init = tf.global_variables_initializer()
#啟動會話
sess.run(init)

#迭代訓練
for epoch in range(train_epochs):
    loss_sum = 0.0
    for xs,ys in zip(x_data,y_data):
        
        #x_data得到的是一維數組，要變成二維數組；y_data得到的是一個常量，要變成二維數組
        xs = xs.reshape(1,12)
        ys = ys.reshape(1,1)
        # Feed 數據必須和Placeholder 的shape 一致
        _,loss = sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})
        
        loss_sum = loss_sum + loss
    
    #打亂數據順序
    x_data,y_data = shuffle(x_data,y_data)
    
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    loss_average = loss_sum / len(y_data)
    
    print("epoch=",epoch+1,"loss=",loss_average,"b=",b0temp,"w=",w0temp)

 注：Done！

5模型應用

5.1做預測

# 指定一條數據
n = 345
x_test = x_data[n]

x_test = x_test.reshape(1,12)
predict = sess.run(pred,feed_dict={x:x_test})
print("預測值：%f" % predict)

target = y_data[n]
print("標簽值：%f" % target

# 隨機確定一條數據
n = np.random.randint(506)
print(n)
x_test = x_data[n]

x_test = x_test.reshape(1,12)
predict = sess.run(pred,feed_dict={x:x_test})
print("預測值：%f" % predict)

target = y_data[n]
print("標簽值：%f" % target)

 

6可視化訓練過程中的損失值

6.1每輪訓練后添加一個這一輪的Loss值

%matplotlib notebook

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle

# 讀取數據文件
df = pd.read_csv("D:\學習資料\課程學習資料\深度學習\TensorFlow/boston.csv",header = 0)

# 獲取df的值
df = df.values
print(df)

# 將df轉換成np的數組格式 ,內部存儲格式不同，方便以后使用np的功能
df = np.array(df)
print(df)

# 對特征數據 【0到11】列 做 （0-1）歸一化

for i in range(12):
    df[:,i] = (df[:,i] - df[:,i].min()) / (df[:,i].max() - df[:,i].min())

#x_data 為歸一化后的前12列特征數據

x_data = df[:,:12]
#y_data 為最后一列標簽數據

y_data = df[:,12]

#定義特征數據和標簽數據的占位符
#shape中 None 表示行的數量未知，在實際訓練時決定一次代入多少行樣本，從一
#個樣本的隨機SDG到批量SDG都可以
x = tf.placeholder(tf.float32,[None,12],name = "X")  #12個特征數據（12列）
y = tf.placeholder(tf.float32,[None,1],name = "Y")  #1個標簽數據（1列）

# 定義一個命名空間
with tf.name_scope("model"):
    # w 初始化值為shape =  (12,1)的隨機數  stddev為標准差
    w = tf.Variable(tf.random_normal([12,1],stddev = 0.01),name = "w")
    # b 初始化值為 1.0 
    b = tf.Variable(1.0,name = "b")
    #w和x是矩陣相乘，用matmul,不能用mutiply或*
    def model(x,w,b):
        return tf.matmul(x,w) + b
    
    #預測計算操作，前向計算節點
    pred = model(x,w,b)
    
# 迭代輪次
train_epochs = 50

# 學習率
learning_rate = 0.01

#定義均方差損失函數
with tf.name_scope("LossFunction"):
    loss_function = tf.reduce_mean(tf.pow(y -pred,2))
    
# 創建優化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#聲明回話
sess = tf.Session()
#定義初始化變量的操作
init = tf.global_variables_initializer()
#啟動會話
sess.run(init)

# 用於保存 loss值得列表
loss_list = []

#迭代訓練
for epoch in range(train_epochs):
    loss_sum = 0.0
    for xs,ys in zip(x_data,y_data):
        
        #x_data得到的是一維數組，要變成二維數組；y_data得到的是一個常量，要變成二維數組
        xs = xs.reshape(1,12)
        ys = ys.reshape(1,1)
        # Feed 數據必須和Placeholder 的shape 一致
        _,loss = sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})
        
        loss_sum = loss_sum + loss
    
    #打亂數據順序
    x_data,y_data = shuffle(x_data,y_data)
    
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    loss_average = loss_sum / len(y_data)
    
    loss_list.append(loss_average)  # 每輪訓練后添加一個這一輪得loss平均值
    
    print("epoch=",epoch+1,"loss=",loss_average,"b=",b0temp,"w=",w0temp)

6.1.2可視化損失值

plt.figure()
plt.plot(loss_list)

# 指定一條數據
n = 345
x_test = x_data[n]

x_test = x_test.reshape(1,12)
predict = sess.run(pred,feed_dict={x:x_test})
print("預測值：%f" % predict)

target = y_data[n]
print("標簽值：%f" % target)

6.2每步（單個樣本）訓練后添加這個Loss值

%matplotlib notebook

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle

# 讀取數據文件
df = pd.read_csv("D:\學習資料\課程學習資料\深度學習\TensorFlow/boston.csv",header = 0)

# 獲取df的值
df = df.values
print(df)

# 將df轉換成np的數組格式 ,內部存儲格式不同，方便以后使用np的功能
df = np.array(df)
print(df)

# 對特征數據 【0到11】列 做 （0-1）歸一化

for i in range(12):
    df[:,i] = (df[:,i] - df[:,i].min()) / (df[:,i].max() - df[:,i].min())

#x_data 為歸一化后的前12列特征數據

x_data = df[:,:12]
#y_data 為最后一列標簽數據

y_data = df[:,12]

#定義特征數據和標簽數據的占位符
#shape中 None 表示行的數量未知，在實際訓練時決定一次代入多少行樣本，從一
#個樣本的隨機SDG到批量SDG都可以
x = tf.placeholder(tf.float32,[None,12],name = "X")  #12個特征數據（12列）
y = tf.placeholder(tf.float32,[None,1],name = "Y")  #1個標簽數據（1列）

# 定義一個命名空間
with tf.name_scope("model"):
    # w 初始化值為shape =  (12,1)的隨機數  stddev為標准差
    w = tf.Variable(tf.random_normal([12,1],stddev = 0.01),name = "w")
    # b 初始化值為 1.0 
    b = tf.Variable(1.0,name = "b")
    #w和x是矩陣相乘，用matmul,不能用mutiply或*
    def model(x,w,b):
        return tf.matmul(x,w) + b
    
    #預測計算操作，前向計算節點
    pred = model(x,w,b)
    
# 迭代輪次
train_epochs = 50

# 學習率
learning_rate = 0.01

#定義均方差損失函數
with tf.name_scope("LossFunction"):
    loss_function = tf.reduce_mean(tf.pow(y -pred,2))
    
# 創建優化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#聲明回話
sess = tf.Session()
#定義初始化變量的操作
init = tf.global_variables_initializer()
#啟動會話
sess.run(init)
# 用於保存 loss值得列表
loss_list = []

#迭代訓練
for epoch in range(train_epochs):
    loss_sum = 0.0
    for xs,ys in zip(x_data,y_data):
        
        #x_data得到的是一維數組，要變成二維數組；y_data得到的是一個常量，要變成二維數組
        xs = xs.reshape(1,12)
        ys = ys.reshape(1,1)
        # Feed 數據必須和Placeholder 的shape 一致
        _,loss = sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})
        
        loss_sum = loss_sum + loss
        loss_list.append(loss)  # 每步添加一次
    
    #打亂數據順序
    x_data,y_data = shuffle(x_data,y_data)
    
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    loss_average = loss_sum / len(y_data)
    
    print("epoch=",epoch+1,"loss=",loss_average,"b=",b0temp,"w=",w0temp)

6.2.2可視化損失值

plt.figure()
plt.plot(loss_list)

# 指定一條數據
n = 345
x_test = x_data[n]

x_test = x_test.reshape(1,12)
predict = sess.run(pred,feed_dict={x:x_test})
print("預測值：%f" % predict)

target = y_data[n]
print("標簽值：%f" % target)

7加上 TensorBoard 可視化代碼

%matplotlib notebook

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle

# 讀取數據文件
df = pd.read_csv("D:\學習資料\課程學習資料\深度學習\TensorFlow/boston.csv",header = 0)

# 獲取df的值
df = df.values
print(df)

# 將df轉換成np的數組格式 ,內部存儲格式不同，方便以后使用np的功能
df = np.array(df)
print(df)

# 對特征數據 【0到11】列 做 （0-1）歸一化

for i in range(12):
    df[:,i] = (df[:,i] - df[:,i].min()) / (df[:,i].max() - df[:,i].min())

#x_data 為歸一化后的前12列特征數據

x_data = df[:,:12]
#y_data 為最后一列標簽數據

y_data = df[:,12]

#定義特征數據和標簽數據的占位符
#shape中 None 表示行的數量未知，在實際訓練時決定一次代入多少行樣本，從一
#個樣本的隨機SDG到批量SDG都可以
x = tf.placeholder(tf.float32,[None,12],name = "X")  #12個特征數據（12列）
y = tf.placeholder(tf.float32,[None,1],name = "Y")  #1個標簽數據（1列）

# 定義一個命名空間
with tf.name_scope("model"):
    # w 初始化值為shape =  (12,1)的隨機數  stddev為標准差
    w = tf.Variable(tf.random_normal([12,1],stddev = 0.01),name = "w")
    # b 初始化值為 1.0 
    b = tf.Variable(1.0,name = "b")
    #w和x是矩陣相乘，用matmul,不能用mutiply或*
    def model(x,w,b):
        return tf.matmul(x,w) + b
    
    #預測計算操作，前向計算節點
    pred = model(x,w,b)
    
# 迭代輪次
train_epochs = 50

# 學習率
learning_rate = 0.01

#定義均方差損失函數
with tf.name_scope("LossFunction"):
    loss_function = tf.reduce_mean(tf.pow(y -pred,2))
    
# 創建優化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#聲明回話
sess = tf.Session()
#定義初始化變量的操作
init = tf.global_variables_initializer()
#啟動會話
sess.run(init)

# 用於保存 loss值得列表
loss_list = []

#迭代訓練
for epoch in range(train_epochs):
    loss_sum = 0.0
    for xs,ys in zip(x_data,y_data):
        
        #x_data得到的是一維數組，要變成二維數組；y_data得到的是一個常量，要變成二維數組
        xs = xs.reshape(1,12)
        ys = ys.reshape(1,1)
        # Feed 數據必須和Placeholder 的shape 一致
        _,loss = sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})
        
        loss_sum = loss_sum + loss
    
    #打亂數據順序
    x_data,y_data = shuffle(x_data,y_data)
    
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    loss_average = loss_sum / len(y_data)
    
    loss_list.append(loss_average)  # 每輪訓練后添加一個這一輪得loss平均值
    
    print("epoch=",epoch+1,"loss=",loss_average,"b=",b0temp,"w=",w0temp)

8為TensorFlow可視化准備數據

8.1修改代碼

%matplotlib notebook

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle

# 讀取數據文件
df = pd.read_csv("D:\學習資料\課程學習資料\深度學習\TensorFlow/boston.csv",header = 0)

# 獲取df的值
df = df.values
print(df)

# 將df轉換成np的數組格式 ,內部存儲格式不同，方便以后使用np的功能
df = np.array(df)
print(df)

# 對特征數據 【0到11】列 做 （0-1）歸一化

for i in range(12):
    df[:,i] = (df[:,i] - df[:,i].min()) / (df[:,i].max() - df[:,i].min())

#x_data 為歸一化后的前12列特征數據

x_data = df[:,:12]
#y_data 為最后一列標簽數據

y_data = df[:,12]

#定義特征數據和標簽數據的占位符
#shape中 None 表示行的數量未知，在實際訓練時決定一次代入多少行樣本，從一
#個樣本的隨機SDG到批量SDG都可以
x = tf.placeholder(tf.float32,[None,12],name = "X")  #12個特征數據（12列）
y = tf.placeholder(tf.float32,[None,1],name = "Y")  #1個標簽數據（1列）

# 定義一個命名空間
with tf.name_scope("model"):
    # w 初始化值為shape =  (12,1)的隨機數  stddev為標准差
    w = tf.Variable(tf.random_normal([12,1],stddev = 0.01),name = "w")
    # b 初始化值為 1.0 
    b = tf.Variable(1.0,name = "b")
    #w和x是矩陣相乘，用matmul,不能用mutiply或*
    def model(x,w,b):
        return tf.matmul(x,w) + b
    
    #預測計算操作，前向計算節點
    pred = model(x,w,b)
    
# 迭代輪次
train_epochs = 50

# 學習率
learning_rate = 0.01

#定義均方差損失函數
with tf.name_scope("LossFunction"):
    loss_function = tf.reduce_mean(tf.pow(y -pred,2))
    
# 創建優化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#聲明回話
sess = tf.Session()
#定義初始化變量的操作
init = tf.global_variables_initializer()

8.1.1設置日志存儲目錄

# 設置日志存儲目錄
logdir = 'd:/log'

8.1.2創建一個操作，用於記錄損失值loss ，后面在TensorBoard 中SCALARS 欄可見

# 創建一個操作，用於記錄損失值loss ，后面在TensorBoard 中SCALARS 欄可見
sum_loss_op = tf.summary.scalar("loss",loss_function)

8.1.3把所有需要記錄摘要日志文件得合並，方便一次性寫入

#把所有需要記錄摘要日志文件得合並，方便一次性寫入
merged =  tf.summary.merge_all()

#啟動會話
sess.run(init)

 8.1.4創建摘要得文件寫入器（FileWriter）

#創建摘要write，將計算圖寫入摘要，后面的在TensorBoard中GRAPHS可見
writer = tf.summary.FileWriter(logdir,sess.graph)

8.1.5writer.add_summary(summary_str, epoch)

# 用於保存 loss值得列表
loss_list = []

#迭代訓練
for epoch in range(train_epochs):
    loss_sum = 0.0
    for xs,ys in zip(x_data,y_data):
        
        #x_data得到的是一維數組，要變成二維數組；y_data得到的是一個常量，要變成二維數組
        xs = xs.reshape(1,12)
        ys = ys.reshape(1,1)
        # Feed 數據必須和Placeholder 的shape 一致
        _,summary_str,loss = sess.run([optimizer,sum_loss_op,loss_function],feed_dict={x:xs,y:ys})
        
        writer.add_summary(summary_str,epoch)
        loss_sum = loss_sum + loss
    
    #打亂數據順序
    x_data,y_data = shuffle(x_data,y_data)
    
    b0temp = b.eval(session=sess)
    w0temp = w.eval(session=sess)
    loss_average = loss_sum / len(y_data)
    
    loss_list.append(loss_average)  # 每輪訓練后添加一個這一輪得loss平均值
    
    print("epoch=",epoch+1,"loss=",loss_average,"b=",b0temp,"w=",w0temp)

8.2運行TensorBoard

8.2.1打開Anaconda Prompt　　

激活TensorFlow：       Activate tensorflow
進入日志存儲目錄 ：     cd  d:\log
打開TensorBoard：      tensorboard --logdir=d:\log

8.2.2TensorBoard 查看loss　　

 8.2.3TensorBoard查看計算圖