使用 Numpy 手动实现深度学习 -- 线性回归

概述

以房价预测为例，使用numpy实现深度学习网络--线性回归代码。
数据链接：https://pan.baidu.com/s/1pY5gc3g8p-IK3AutjSUUMA
提取码：l3oo

导入库

import numpy as np
import matplotlib.pyplot as plt

加载数据

def LoadData():
    #读取数据
    data = np.fromfile( './housing.data', 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( [-1, feature_num] )

    #计算数据最大值、最小值、平均值
    data_max = data.max( axis=0 )
    data_min = data.min( axis=0 )
    data_avg = data.sum( axis=0 ) / data.shape[0]

    #对数据进行归一化处理
    for i in range( feature_num ):
        data[:, i] = ( data[:, i] - data_avg[i] ) / ( data_max[i] - data_min[i] )

    #划分训练集和测试集
    ratio = 0.8
    offset = int( data.shape[0] * ratio )
    train_data = data[ :offset ]
    data_test = data[ offset: ]

    return data_train, data_test

模型设计

class Network( object ):
    '''
    线性回归神经网络类
    '''
    def __init__( self, num_weights ):
        '''
        初始化权重和偏置
        '''
        self.w = np.random.randn( num_weights, 1 ) #随机初始化权重
        self.b = 0.

    def Forward( self, x ):
        '''
        前向训练：计算预测值
        '''
        y_predict = np.dot( x, self.w ) + self.b #根据公式，计算预测值
        return y_predict

    def Loss( self, y_predict, y_real ):
        '''
        计算损失值：均方误差法
        '''
        error = y_predict - y_real #误差
        cost = np.square( error ) #代价函数：误差求平方
        cost = np.mean( cost ) #求代价函数的均值（即：MSE法求损失）
        return cost

    def Gradient( self, x, y_real ):
        '''
        根据公式，计算权重和偏置的梯度
        '''
        y_predict = self.Forward( x ) #计算预测值
        gradient_w = ( y_predict - y_real ) * x #根据公式，计算权重的梯度
        gradient_w = np.mean( gradient_w, axis=0 ) #计算每一列的权重的平均值
        gradient_w = gradient_w[:, np.newaxis] #reshape

        gradient_b = ( y_predict - y_real ) #根据公式，计算偏置的梯度
        gradient_b = np.mean( gradient_b ) #计算偏置梯度的平均值

        return gradient_w, gradient_b

    def Update( self, gradient_w, gradient_b, learning_rate=0.01 ):
        '''
        梯度下降法：更新权重和偏置
        '''
        self.w = self.w - gradient_w * learning_rate #根据公式，更新权重
        self.b = self.b - gradient_b * learning_rate #根据公式，更新偏置

    def Train( self, x, y, num_iter=100, learning_rate=0.01 ):
        '''
        使用梯度下降法，训练模型
        '''
        losses = []

        for i in range( num_iter ): #迭代计算更新权重、偏置
            #计算预测值
            y_predict = self.Forward( x )
            #计算损失
            loss = self.Loss( y_predict, y )
            #计算梯度
            gradient_w, gradient_b = self.Gradient( x, y )
            #根据梯度，更新权重和偏置
            self.Update( gradient_w, gradient_b, learning_rate )

            #打印模型当前状态
            losses.append( loss )
            if ( i+1 ) % 10 == 0:
                print( 'iter = {}, loss = {}'.format( i+1, loss ) )

        return losses

模型训练

#获取数据
train_data, test_data = LoadData()
x_data = train_data[:, :-1]
y_data = train_data[:, -1:]

#创建网络
net = Network( 13 )
num_interator = 1000
learning_rate = 0.01

#进行训练
losses = net.Train( x_data, y_data, num_interator, learning_rate )

#画出损失函数变化趋势
plot_x = np.arange( num_interator )
plot_y = losses
plt.plot( plot_x, plot_y )
plt.show()

训练结果