线性回归（Linear Regreesion ）

机器学习之线性回归

一、理论学习

机器学习监督学习算法分为分类算法和回归算法两种，事实上就是依据类别标签分布类型为离散型、连续性而定义的，如果类别标签是离散型的则为分类，对于连续性的标签的映射则为回归。线性回归则是连续性预测变量与输入变量存在线性映射关系。

1、模型

对于输入的n维特征向量X，其与连续变量Y（一维）之间存在某种对应关系，即映射。特征向量X与Y的一阶线性关系表示如下：

此为线性回归的模型，向量表示为：

2、策略

现在的目标是找到合适W向量组合使得此映射关系近似成立，及最小化损失函数（L2损失函数）：

m表示特征向量的数量，上标i标记样本中变量与标签的其中一组映射，此时就变成了联立m组方程求解n+1维的权重向量W。

3、算法

机器学习中通常通过梯度下降法求解最优参数，对损失函数求对应参数的偏导（梯度），然后采用梯度去更新对应参数。我们希望最小化损失函数，可以用过求解损失函数极小值的假设近似得到，此时对损失函数L(W)求偏导，且偏导数要为0：

联立求解n+1个方程组，可以求解得到参数，当然这是最小二乘的解法，机器学习则采用梯度下降法，具体为首先初始化权重参数，然后利用初始化的的参数计算得到结果，随及用到对的求解偏导数更新参数：

二、实现

多种框架实现，顺便学习下不同框架的建模

1、numpy实现

#coding=utf-8

import  numpy as np
import os
import matplotlib.pyplot as plt
import tensorflow as tf
import torch
from torch.autograd import Variable

#numpy
x=np.linspace(-1,1,100)[:,np.newaxis]
noise=np.random.normal(0,0.1,size=x.shape)
#y=np.power(x,2)+noise
y=x+noise

x=np.reshape(x,(100,1))
y=np.reshape(y,(100,1))

# #权值与偏置
weight=np.ones(shape=(1,x.shape[1]))
bias=1

epoch=500
lr=0.1
for i in range(epoch):
    bias_array=np.ones(shape=(y.shape[0],1))*bias
    pred=np.dot(x,weight.T)+bias_array
    loss=np.dot((y-pred).T,(y-pred))/y.shape[0]/2.0
    weight_gradient=-np.dot((y-pred).T,x)/y.shape[0]
    bias_gradient=-np.dot((y-pred).T,bias_array)/y.shape[0]
    weight=weight-lr*weight_gradient
    bias=bias+lr*bias_gradient[0,0]

    print("loss" + loss.__str__())

2、pytorch实现

x_data=torch.from_numpy(x)
y_data=torch.from_numpy(y)

class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.liner=torch.nn.Liner(1,1)
    def forward(self,x):
        pred=self.liner(x)
        return pred

#模型初始化
model=Model()

#定义损失函数类型
criterion = torch.nn.MSELoss(size_average=False) # Defined loss function

#定义优化器类型
optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # Defined optimizer

for epoch in range(100):
    pred=model(x_data)

    loss=criterion(pred,y_data)
    print(epoch,loss)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

3、tensorflow实现

inputx=tf.placeholder(dtype=tf.float32,shape=[None,1])
gy=tf.placeholder(dtype=tf.float32,shape=[None,1])

#权重
w=tf.Variable(tf.random_normal([1,1]))
b=tf.Variable(tf.random_normal([1]))

#前向inference
pred=tf.matmul(inputx,w)+b

#损失
loss=tf.reduce_sum(tf.pow(pred-gy,2))

#训练优化
train_op=tf.train.GradientDescentOptimizer(0.001).minimize(loss)

tf.summary.scalar("loss",loss)
merged = tf.summary.merge_all()

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    for i in range(100):
        _, prednp,lossnp=sess.run([train_op,pred,loss],feed_dict={inputx:x,gy:y})
        print(lossnp)
        WArr, bArr = sess.run([w, b])
        print(WArr, bArr)
        plt.scatter(x, y)
        plt.plot(x, WArr * x + bArr)
        plt.show()

线性回归（Linear Regreesion ）

机器学习之线性回归

猜你喜欢