1.线性回归算法
2.简单线性回归算法
3.最小二乘法
4.简单线性回归算法的实现
import numpy as np
import matplotlib.pyplot as plt
x=np.array([1.,2.,3.,4.,5.])
y=np.array([1.,3.,2.,3.,5.])
x_mean=np.mean(x)
y_mean=np.mean(y)
num=0.0
d=0.0
for x_i,y_i in zip(x,y):
num+=(x_i-x_mean)*(y_i-y_mean)
d+=(x_i-x_mean)**2
a=num/d
b=y_mean-a*x_mean
y_hat=a*x+b
plt.scatter(x,y)
plt.plot(x,y_hat,color='r')
plt.axis([0,6,0,6])
plt.show()
print(a)
print(b)
"""调用自己的方法"""
from SimpleLinearRegression import SimpleLinearRegression
x_predict=6
reg=SimpleLinearRegression()
reg.fit(x,y)
print(reg.predict(np.array([x_predict])))
print(reg.a_)
print(reg.b_)自己的线性回归方法
import numpy as np
from metrics import r2_score
class SimpleLinearRegression:
def __init__(self):
"""初始化Simple Linear Regression模型"""
self.a_ = None
self.b_ = None
def fit(self, x_train, y_train):
"""根据训练数据集x_train, y_train训练Simple Linear Regression模型"""
assert x_train.ndim == 1, \
"Simple Linear Regressor can only solve single feature training data."
assert len(x_train) == len(y_train), \
"the size of x_train must be equal to the size of y_train"
x_mean = np.mean(x_train)
y_mean = np.mean(y_train)
# 使用向量化计算a,b
self.a_ = (x_train - x_mean).dot(y_train - y_mean) / (x_train - x_mean).dot(x_train - x_mean)
self.b_ = y_mean - self.a_ * x_mean
return self
def predict(self, x_predict):
"""给定待预测数据集x_predict，返回表示x_predict的结果向量"""
assert x_predict.ndim == 1, \
"Simple Linear Regressor can only solve single feature training data."
assert self.a_ is not None and self.b_ is not None, \
"must fit before predict!"
return np.array([self._predict(x) for x in x_predict])
def _predict(self, x_single):
"""给定单个待预测数据x，返回x的预测结果值"""
return self.a_ * x_single + self.b_
def score(self, x_test, y_test):
"""根据测试数据集 x_test 和 y_test 确定当前模型的准确度"""
y_predict = self.predict(x_test)
return r2_score(y_test, y_predict)
def __repr__(self):
return "SimpleLinearRegression()"
线性回归算法的评测：
"""衡量回归算法的标准"""
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from math import sqrt
boston=datasets.load_boston()
x=boston.data[:,5]
y=boston.target
plt.scatter(x,y)
plt.show()
x=x[y<50.0]
y=y[y<50.0]
plt.scatter(x,y)
plt.show()
"""使用简单的线性回归"""
from model_selection import train_test_split
from SimpleLinearRegression import SimpleLinearRegression
x_train,x_test,y_train,y_test=train_test_split(x,y,seed=666)
reg=SimpleLinearRegression()
reg.fit(x_train,y_train)
plt.scatter(x_train,y_train)
plt.plot(x_train,reg.predict(x_train),color='r')
plt.show()
y_predict=reg.predict(x_test)
"""MSE均方误差"""
mse_test=np.sum((y_predict-y_test)**2)/len(y_test)
print(mse_test)
"""RMSE均方根误差"""
rmse_test=sqrt(mse_test)
print(rmse_test)
"""MAE平均绝对误差"""
mae_test=np.sum(np.absolute(y_predict-y_test))/len(y_test)
print(mse_test)
"""调用自己封装的方法"""
from metrics import mean_absolute_error
from metrics import mean_squared_error
from metrics import root_mean_squared_error
print(mean_squared_error(y_test,y_predict))
print(root_mean_squared_error(y_test,y_predict))
print(mean_absolute_error(y_test,y_predict))
"""使用scikit-learn中的MSE和MAE"""
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
print(mean_squared_error(y_test,y_predict))
print(mean_absolute_error(y_test,y_predict))
"""R Square"""
print(1-mean_squared_error(y_test,y_predict)/np.var(y_test))
多元线性回归和正规方程解
"""实现多元线性回归模型(调用自己的算法)"""
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from model_selection import train_test_split
from LinearRegression import LinearRegression
boston=datasets.load_boston()
X=boston.data
y=boston.target
X=X[y<50.0]
y=y[y<50.0]
x_train,x_test,y_train,y_test=train_test_split(X,y,seed=666)
reg=LinearRegression()
reg.fit_normal(x_train,y_train)
print(reg.intercept_)
print(reg.coef_)
print(reg.score(x_test,y_test))
"""调用scikit-learn中的线性回归算法"""
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.linear_model import LinearRegression
boston=datasets.load_boston()
X=boston.data
y=boston.target
X=X[y<50.0]
y=y[y<50.0]
x_train,x_test,y_train,y_test=train_test_split(X,y,seed=666)
lin_reg=LinearRegression()
lin_reg.fit(x_train,y_train)
print(lin_reg.coef_)
print(lin_reg.intercept_)自己的线性回归算法：
import numpy as np
from metrics import r2_score
class LinearRegression:
def __init__(self):
"""初始化Linear Regression模型"""
self.coef_ = None
self.intercept_ = None
self._theta = None
def fit_normal(self, X_train, y_train):
"""根据训练数据集X_train, y_train训练Linear Regression模型"""
assert X_train.shape[0] == y_train.shape[0], \
"the size of X_train must be equal to the size of y_train"
X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
self._theta = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y_train)
self.intercept_ = self._theta[0]
self.coef_ = self._theta[1:]
return self总结：
