import numpy as np
from matplotlib import pyplot as plt
def load_data():
datafile = "./housing.data"
data = np.fromfile(datafile,sep=" ")
feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE','DIS',
'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]
feature_num = len(feature_names)
data = data.reshape([data.shape[0] // feature_num, feature_num])
ratio = 0.8
offset = int(data.shape[0] * ratio)
training_data = data[:offset]
maximums, minimums = training_data.max(axis=0), training_data.min(axis=0)
# 对数据进行归一化处理,使用训练集的极值
for i in range(feature_num):
data[:, i] = (data[:, i] - minimums[i]) / (maximums[i] - minimums[i])
# 训练集和测试集的划分
training_data = data[:offset]
test_data = data[offset:]
return training_data,test_data
class Network():
def __init__(self,num_of_weights):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性，设置固定的随机数种子
np.random.seed(0)
self.w = np.random.randn(num_of_weights,1)
self.b = 0
def forward(self,x):
# x -> (1,13) , w-> (13,1)
z = np.dot(x,self.w) + self.b
return z
def loss(self,z,y):
error = z-y
loss = np.mean(error * error)
return loss
def gradient(self,x,y):
z = self.forward(x)
gradient_w = (z-y)*x
gradient_w = np.mean(gradient_w,axis=0)
gradient_w = gradient_w[:,np.newaxis]
gradient_b = (z-y)
gradient_b = np.mean(gradient_b)
return gradient_w,gradient_b
def update(self,gradient_w,gradient_b,eta=0.01):
self.w = self.w - eta*gradient_w
self.b = self.b - eta*gradient_b
def train_gd(self,x,y,iterations=100,eta = 0.01):
losses = []
for i in range(iterations):
z = self.forward(x)
L = self.loss(z,y)
gradient_w, gradient_b = self.gradient(x,y)
self.update(gradient_w,gradient_b,eta)
losses.append(L)
if (i+1)%10 == 0:
print("iter {},loss {}".format(i,L))
return losses
def train_sgd(self,training_data,num_epochs,batch_size=10,eta=0.01):
n= len(training_data)
losses = []
for epoch_id in range(num_epochs):
# 在每轮迭代开始之前，将训练数据的顺序进行随机打乱
# 然后再按照每次取出batch_size条数据的方式取出
np.random.shuffle(training_data)
# 将训练数据进行拆分，每个mini_batch包含batch_size条数据
mini_batches = [training_data[k:k+batch_size] for k in range(0,n,batch_size)]
for iter_id,mini_batch in enumerate(mini_batches):
x = mini_batch[:,:-1]
y = mini_batch[:,-1:]
a = self.forward(x)
loss = self.loss(a,y)
gradient_w, gradient_b = self.gradient(x,y)
self.update(gradient_w,gradient_b,eta)
losses.append(loss)
print("Epoch {:3d} / iter {:3d},loss = {:.4f}".format(epoch_id,iter_id,loss))
return losses
def valid(self,test_data):
x = test_data[:,:-1]
y = test_data[:,-1:]
a = self.forward(x)
loss = self.loss(a,y)
return loss
def main():
# 获取数据
train_data ,test_data = load_data()
x = train_data[:,:-1]
y = train_data[:,-1:]
# 创建网络
net = Network(13)
num_iterations = 1000
# 启动训练
losses = net.train_gd(x,y,iterations=num_iterations,eta=0.01)
#losses = net.train_sgd(train_data,num_iterations,batch_size=10,eta=0.01)
print("valid loss: {:.4f}".format(net.valid(test_data)))
# 画出损失函数的变化趋势
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x,plot_y)
plt.show()
if __name__ == "__main__":
main()
