亲宝软件园·资讯

展开

TensorFlow 多元线性回归【波士顿房价】

Pam_sh 人气:0

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查看计算图

加载全部内容

相关教程
猜你喜欢
用户评论