波士顿房价
import matplotlib.pyplot as plt
%matplotlib inline
import tensorflow as tf
import numpy as np
from sklearn.datasets import load_boston
import sklearn.linear_model as sk
boston = load_boston()
features = np.array(boston.data)
labels = np.array(boston.target)
print(boston["DESCR"])
def normalize(dataset):
mu = np.mean(dataset, axis = 0)
sigma = np.std(dataset, axis = 0)
return (dataset-mu)/sigma
n_training_samples = features.shape[0]
n_dim = features.shape[1]
print('The dataset has',n_training_samples,'training samples.')
print('The dataset has',n_dim,'features.')
features_norm = normalize(features)
print(features_norm.shape)
print(labels.shape)
np.random.seed(42)
rnd = np.random.rand(len(features_norm)) < 0.8
train_x = tf.Variable(features_norm[rnd],dtype=tf.float32)
train_y = tf.Variable(labels[rnd],dtype=tf.float32)
test_x = tf.Variable(features_norm[~rnd],dtype=tf.float32)
test_y = tf.Variable(labels[~rnd],dtype=tf.float32)
print(train_x.shape)
print(train_y.shape)
print(test_x.shape)
print(test_y.shape)
train_x.numpy()
train_y.numpy()
test_x.numpy()
test_x.numpy()[1]
test_y.numpy()
# cost_history = np.empty(shape=[0], dtype = float)
# cost_history = np.append(cost_history, cost_)
#设置超参数
learn_rate = 0.01 # 学习率
iter = 2000 # 迭代次数
display_step = 200 # 显示间隔
#设置模型变量初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(13,1),dtype=tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
mse_train = [] # 训练损失，训练误差
mse_test = [] # 测试损失，测试误差
for i in range(0 , iter+1):
with tf.GradientTape() as tape:
PRED_train = tf.matmul(train_x, W)+b
Loss_train = 0.5 * tf.reduce_mean(tf.square(train_y - PRED_train))
mse_train.append(Loss_train)
PRED_test = tf.matmul(test_x, W)+b
Loss_test = 0.5 * tf.reduce_mean(tf.square(test_y - PRED_test))
mse_test.append(Loss_test)
dL_dW,dL_db = tape.gradient(Loss_train,[W,b])
W.assign_sub(learn_rate * dL_dW)
b.assign_sub(learn_rate * dL_db)
# 输出训练误差和测试误差
if i % display_step == 0:
print("i:%i,Train Loss: %f, Test Loss: %f" % (i, Loss_train, Loss_test))
train_x
#开始训练，轮数为epoch，采用SGD随机梯度下降优化方法
W = tf.Variable(np.random.randn(13,1),dtype=tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
train_epochs = 200
learn_rate = 0.01 # 学习率
iter = 200 # 迭代次数
display_step = 200 # 显示间隔
#设置模型变量初始值
np.random.seed(612)
mse_train = [] # 训练损失，训练误差
mse_test = [] # 测试损失，测试误差
#w = tf.Variable(np.random.randn(13,1),tf.float32)
#b = tf.Variable(tf.zeros(1),tf.float32)
batch_size=10
count = tf.Variable(0.0,tf.float32)
optimizer = tf.keras.optimizers.SGD(learn_rate)
total_step = int(train_x.shape[0]/batch_size)
for epoch in range(train_epochs):
for step in range(total_step):
xs= train_x.numpy()[step*batch_size:(step+1)*batch_size,:]
ys= train_y.numpy()[step*batch_size:(step+1)*batch_size]
#计算当前[w,b]的梯度
#delta_w,delta_b = grad(xs,ys,w,b)
with tf.GradientTape() as tape:
PRED_train = tf.matmul(xs, W)+b
Loss_train = 0.5 * tf.reduce_mean(tf.square(ys - PRED_train))
mse_train.append(Loss_train)
dL_dW,dL_db = tape.gradient(Loss_train,[W,b])
W.assign_sub(learn_rate * dL_dW)
b.assign_sub(learn_rate * dL_db)
# grads = grad(xs,ys,w,b)
#delta_w,delta_b = optimizer.apply_gradients(zip(grads,[w,b]))
#change_w = delta_w * learning_rate
#change_b = delta_b * learning_rate
#w.assign_sub(change_w)
#b.assign_sub(change_b)
#计算损失，并保存本次损失计算结果
#loss_ =loss_fun(xs,ys,w,b)
#loss_ =loss_fun(xs,ys,w,b)
#loss.append(loss_)
#训练步数加1
count = count +1
if count % display_count == 0:
print('train epoch : ','%02d'%(epoch+1),'step:%03d' % (count),'loss= ','{:.9f}'.format(Loss_train))
#完成一轮训练后，画图
#plt.plot(x,w.numpy() * x +b.numpy()) #plt.plot(x_data,w.numpy() * x_data +b.numpy())
W
plt.rc('font', family='arial')
plt.rc('xtick', labelsize='x-small')
plt.rc('ytick', labelsize='x-small')
plt.tight_layout()
fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(1, 1, 1)
ax.plot(mse_train, ls='solid', color = 'black')
ax.set_xlabel('epochs', fontsize = 16)
ax.set_ylabel('Cost function $J$ (MSE)', fontsize = 16)
plt.xlim(0,10000)
plt.tick_params(labelsize=16)
b
#pred_y = sess.run(y_, feed_dict = {X: test_x, Y: test_y})
#mse = tf.reduce_mean(tf.square(pred_y - test_y))
pred_y = model(test_x,W,b)
pred_y
test_y
mse = tf.reduce_mean(tf.square(pred_y - test_y))
plt.rc('font', family='arial')
plt.rc('xtick', labelsize='x-small')
plt.rc('ytick', labelsize='x-small')
plt.tight_layout()
fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(1, 1, 1)
ax.scatter(test_y, pred_y, lw = 5)
ax.plot([test_y.numpy().min(), test_y.numpy().max()], [test_y.numpy().min(), test_y.numpy().max()], 'k--', lw = 5)
ax.set_xlabel('Measured Target Value', fontsize = 16)
ax.set_ylabel('Predicted Target Value', fontsize = 16)
plt.tick_params(labelsize=16)
print ('Starting first model')
#cost_history1 = run_linear_model(learning_r = 0.1,
# training_epochs = 10000,
# train_obs = train_x,
# train_labels = train_y,
# debug = True)
#开始训练，轮数为epoch，采用SGD随机梯度下降优化方法
W = tf.Variable(np.random.randn(13,1),dtype=tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
train_epochs = 1000
learn_rate = 0.1 # 学习率
iter = 200 # 迭代次数
display_step = 200 # 显示间隔
#设置模型变量初始值
np.random.seed(612)
mse_train1 = [] # 训练损失，训练误差
mse_test = [] # 测试损失，测试误差
w = tf.Variable(np.random.randn(13,1),tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
batch_size=10
count = tf.Variable(0.0,tf.float32)
optimizer = tf.keras.optimizers.SGD(learn_rate)
total_step = int(train_x.shape[0]/batch_size)
for epoch in range(train_epochs):
for step in range(total_step):
xs= train_x.numpy()[step*batch_size:(step+1)*batch_size,:]
ys= train_y.numpy()[step*batch_size:(step+1)*batch_size]
#计算当前[w,b]的梯度
#delta_w,delta_b = grad(xs,ys,w,b)
with tf.GradientTape() as tape:
PRED_train = tf.matmul(xs, W)+b
Loss_train = 0.5 * tf.reduce_mean(tf.square(ys - PRED_train))
mse_train1.append(Loss_train)
dL_dW,dL_db = tape.gradient(Loss_train,[W,b])
W.assign_sub(learn_rate * dL_dW)
b.assign_sub(learn_rate * dL_db)
# grads = grad(xs,ys,w,b)
#delta_w,delta_b = optimizer.apply_gradients(zip(grads,[w,b]))
#change_w = delta_w * learning_rate
#change_b = delta_b * learning_rate
#w.assign_sub(change_w)
#b.assign_sub(change_b)
#计算损失，并保存本次损失计算结果
#loss_ =loss_fun(xs,ys,w,b)
#loss_ =loss_fun(xs,ys,w,b)
#loss.append(loss_)
#训练步数加1
count = count +1
if count % display_count == 0:
print('train epoch : ','%02d'%(epoch+1),'step:%03d' % (count),'loss= ','{:.9f}'.format(Loss_train))
#完成一轮训练后，画图
#plt.plot(x,w.numpy() * x +b.numpy()) #plt.plot(x_data,w.numpy() * x_data +b.numpy())
print ('Starting second model')
#sess2, cost_history2 = run_linear_model(learning_r = 0.01,
# training_epochs = 10000,
# train_obs = train_x,
# train_labels = train_y,
# #开始训练，轮数为epoch，采用SGD随机梯度下降优化方法
W = tf.Variable(np.random.randn(13,1),dtype=tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
train_epochs = 1000
learn_rate = 0.01 # 学习率
iter = 200 # 迭代次数
display_step = 200 # 显示间隔
#设置模型变量初始值
np.random.seed(612)
mse_train2 = [] # 训练损失，训练误差
mse_test = [] # 测试损失，测试误差
w = tf.Variable(np.random.randn(13,1),tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
batch_size=10
count = tf.Variable(0.0,tf.float32)
optimizer = tf.keras.optimizers.SGD(learn_rate)
total_step = int(train_x.shape[0]/batch_size)
for epoch in range(train_epochs):
for step in range(total_step):
xs= train_x.numpy()[step*batch_size:(step+1)*batch_size,:]
ys= train_y.numpy()[step*batch_size:(step+1)*batch_size]
#计算当前[w,b]的梯度
#delta_w,delta_b = grad(xs,ys,w,b)
with tf.GradientTape() as tape:
PRED_train = tf.matmul(xs, W)+b
Loss_train = 0.5 * tf.reduce_mean(tf.square(ys - PRED_train))
mse_train2.append(Loss_train)
dL_dW,dL_db = tape.gradient(Loss_train,[W,b])
W.assign_sub(learn_rate * dL_dW)
b.assign_sub(learn_rate * dL_db)
# grads = grad(xs,ys,w,b)
#delta_w,delta_b = optimizer.apply_gradients(zip(grads,[w,b]))
#change_w = delta_w * learning_rate
#change_b = delta_b * learning_rate
#w.assign_sub(change_w)
#b.assign_sub(change_b)
#计算损失，并保存本次损失计算结果
#loss_ =loss_fun(xs,ys,w,b)
#loss_ =loss_fun(xs,ys,w,b)
#loss.append(loss_)
#训练步数加1
count = count +1
if count % display_count == 0:
print('train epoch : ','%02d'%(epoch+1),'step:%03d' % (count),'loss= ','{:.9f}'.format(Loss_train))
#完成一轮训练后，画图
#plt.plot(x,w.numpy() * x +b.numpy()) #plt.plot(x_data,w.numpy() * x_data +b.numpy())
print ('Starting third model')
#sess3, cost_history3 = run_linear_model(learning_r = 0.001,
# training_epochs = 10000,
# train_obs = train_x,
# train_labels = train_y,
# debug = True)
#开始训练，轮数为epoch，采用SGD随机梯度下降优化方法
W = tf.Variable(np.random.randn(13,1),dtype=tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
train_epochs = 1000
learn_rate = 0.001 # 学习率
iter = 200 # 迭代次数
display_step = 200 # 显示间隔
#设置模型变量初始值
np.random.seed(612)
mse_train3 = [] # 训练损失，训练误差
mse_test = [] # 测试损失，测试误差
w = tf.Variable(np.random.randn(13,1),tf.float32)
b = tf.Variable(tf.zeros(1),tf.float32)
batch_size=10
count = tf.Variable(0.0,tf.float32)
optimizer = tf.keras.optimizers.SGD(learn_rate)
total_step = int(train_x.shape[0]/batch_size)
for epoch in range(train_epochs):
for step in range(total_step):
xs= train_x.numpy()[step*batch_size:(step+1)*batch_size,:]
ys= train_y.numpy()[step*batch_size:(step+1)*batch_size]
#计算当前[w,b]的梯度
#delta_w,delta_b = grad(xs,ys,w,b)
with tf.GradientTape() as tape:
PRED_train = tf.matmul(xs, W)+b
Loss_train = 0.5 * tf.reduce_mean(tf.square(ys - PRED_train))
mse_train3.append(Loss_train)
dL_dW,dL_db = tape.gradient(Loss_train,[W,b])
W.assign_sub(learn_rate * dL_dW)
b.assign_sub(learn_rate * dL_db)
# grads = grad(xs,ys,w,b)
#delta_w,delta_b = optimizer.apply_gradients(zip(grads,[w,b]))
#change_w = delta_w * learning_rate
#change_b = delta_b * learning_rate
#w.assign_sub(change_w)
#b.assign_sub(change_b)
#计算损失，并保存本次损失计算结果
#loss_ =loss_fun(xs,ys,w,b)
#loss_ =loss_fun(xs,ys,w,b)
#loss.append(loss_)
#训练步数加1
count = count +1
if count % display_count == 0:
print('train epoch : ','%02d'%(epoch+1),'step:%03d' % (count),'loss= ','{:.9f}'.format(Loss_train))
#完成一轮训练后，画图
#plt.plot(x,w.numpy() * x +b.numpy()) #plt.plot(x_data,w.numpy() * x_data +b.numpy())
plt.rc('font', family='arial')
plt.rc('xtick', labelsize='x-small')
plt.rc('ytick', labelsize='x-small')
plt.tight_layout()
fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(1, 1, 1)
ax.plot(mse_train1, ls='solid', color = 'black', label='$\gamma=0.1$')
ax.plot(mse_train2, ls='dashed', color = 'black', label='$\gamma=0.01$')
ax.plot(mse_train3, ls='dotted', color = 'black', label='$\gamma=0.001$')
ax.set_xlabel('epochs', fontsize = 16)
ax.set_ylabel('Cost function $J$ (MSE)', fontsize = 16)
plt.xlim(0,300)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., fontsize = 16)
plt.tick_params(labelsize=16)
lm = sk.LinearRegression()
lm.fit(train_x, train_y)
msetest = np.mean((test_y-lm.predict(test_x))**2)
msetrain = np.mean((train_y-lm.predict(train_x))**2)
print('Train MSE=',msetrain)
print('Test MSE=',msetest)
model = tf.keras.Sequential()
"""添加层:其实就是 wx+b"""
model.add(tf.keras.layers.Dense(1,input_shape = (13,))) #输出是1维数据，输入是14维数据
"""查看网络结构"""
model.summary()
"""编译，配置"""
model.compile(optimizer = 'adam',
loss = 'mse',
metrics=['mae','mse']
)
"""训练数据"""
history = model.fit(train_x.numpy(), train_y.numpy(), epochs = 500)
predict = model.predict(test_x.numpy())
predict