机器学习——线性回归

导入类库

from sklearn.externals import joblib
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
from sklearn import neighbors
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import sklearn.preprocessing as sp
import sklearn.pipeline as pl

小知识

# np.column_stack：取行排列数组
# np.vstack：取列排列数组
# a = np.array([1,2])
# b = np.array([3,4])
# print(np.vstack((a,b)))
# array([[1, 2],[3, 4]])
# print(np.column_stack((a,b)))
# array([[1, 3],[2, 4]])

获取波士顿房价数据

# 获取波士顿房价数据
lb = load_boston()
# 将房价数据转换为每行包括影响因素和房价的DataFrame
df = pd.DataFrame(np.column_stack((lb.data, lb.target)),
                  columns=['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',
                           'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV'])
cols = ['LSTAT', 'INDUS', 'NOX', 'RM', 'MEDV']
print(df)
print(df[cols])

多变量图

def pairplot_analyse():
    '''
    style:whitegrid-白色网格图   darkgrid-黑色网格图  ticks-散点图   dark white
    context：notebook    paper   talk    poster      # size: paper < talk < poster < notebook
    palette：调色板
    kind：使用回归
    diag_kind：改变对角图
    markers：改变点形状
    :return:
    '''
    sns.set(style='dark', context='notebook')
    sns.pairplot(df[cols], height=2, palette='husl', kind='reg', diag_kind='kde', markers='+')
    plt.tight_layout()
    plt.show()

热点图

def heatmap_analyse():
    '''
    cbar：柱子
    annot：标记
    square：方形
    fmt：数据格式
    yticklabels：y轴标签
    xticklabels：x轴标签
    :return:
    '''
    # 计算皮尔逊相关系数
    corr = np.corrcoef(df[cols].values.T)
    # 生成热点图
    hm = sns.heatmap(corr, cbar=True, annot=True, square=True, fmt='.2f', annot_kws={'size': 15}, yticklabels=cols,
                     xticklabels=cols)
    plt.show()

回归方法是一种对数值型连续随机变量进行预测和建模的监督学习算法。使用案例一般包括房价预测、股票走势或测试成绩等连续变化的案例；

回归任务的特点是标注的数据集具有数值型的目标变量。也就是说，每一个观察样本都有一个数值型的标注真值以监督算法。

线性回归

def bostn_linear():
    '''
    线性回归直接预测房子价格
    :return:
    '''

    # 获取数据
    lb = load_boston()

    # 分割数据集为训练集和测试集 test_size:分割比例
    x_train, x_test, y_train, y_test = train_test_split(lb.data, lb.target, test_size=0.25)

    # print(y_train, y_test)
    # 特征值和目标值是都必须进行标准化处理，实例化两个标准化API
    std_x = StandardScaler()

    x_train = std_x.fit_transform(x_train)
    # 用转化训练集的标准归一化测试集：上是fit_transform,下是transform
    x_test = std_x.transform(x_test)

    # 目标值
    std_y = StandardScaler()
    # -1表示自动识别行数
    y_train = std_y.fit_transform(y_train.reshape(-1, 1))
    y_test = std_y.transform(y_test.reshape(-1, 1))

    # estimator
    # 正规方程求解方式预测结果
    # 创建线性回归对象
    lr = LinearRegression()
    # 训练数据
    lr.fit(x_train, y_train)
    print(lr.coef_)  # 权值

    # 保存训练好的模型
    joblib.dump(lr, './test.pkl')

    # 预测测试集的房子价格
    # y_lr_predict = std_y.inverse_transform(lr.predict(x_test))
    orgin = std_y.inverse_transform(y_test[3])  # 转换成原格式
    print('orgin value is:::::', orgin)
    y_lr_predict = std_y.inverse_transform(lr.predict(np.array([x_test[3]])))  # predict参数是二维数组

    print('正规方程测试集里面每个房子的预测价格：', y_lr_predict)
    # print('正规方程R2评分：', r2_score(std_y.inverse_transform(y_test), y_lr_predict))
    # print('正规方程R2评分：', r2_score(orgin, y_lr_predict))     #r2_score，参数1：原测试数据，参数2：预测数据

原图像与预测图像对比

def log_fit():
    x = np.linspace(0, 20, 50)
    y = x ** 3 + np.random.random(50, ) * 100
    # pf = sp.PolynomialFeatures(3)

    lr = LinearRegression()
    # modle = pl.make_pipeline(pf,lr)
    lr.fit(x.reshape(-1, 1), y)
    x_predict = lr.predict(x.reshape(-1, 1))
    print(x_predict)

    plt.scatter(x, y)  # 曲线：原曲线
    plt.scatter(x, x_predict, c='r')  # 直线：预测曲线
    plt.show()

房价预测实例

def test_fj():
    X = np.array([[500, 3, 0.3], [1000, 1, 0.6], [750, 2, 0.3], [600, 5, 0.2], [1200, 1, 0.6]], dtype=float)
    Y = np.array([10000, 9000, 8000, 12000, 8500], dtype=float)

    x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.25)
    print(x_train, x_test)
    print('===================================================')
    print(y_train, y_test)

    std_x = StandardScaler()
    x_train = std_x.fit_transform(x_train)
    x_test = std_x.transform(x_test)

    std_y = StandardScaler()
    y_train = std_y.fit_transform(y_train.reshape(-1, 1))
    y_test = std_y.transform(y_test.reshape(-1, 1))

    lr = LinearRegression()
    lr.fit(x_train, y_train)
    print(lr.coef_)

    # orign = std_y.inverse_transform(y_test[1])
    # print('orign is value:::::',orign)
    # y_lr_predict = std_y.inverse_transform(lr.predict(np.array([x_test[1]])))
    y_lr_predict = std_y.inverse_transform(lr.predict(x_test))

    print('房价：', y_lr_predict)
    print('评分：', r2_score(std_y.inverse_transform(y_test), y_lr_predict))


def price_predict():
    # 数据有三个特征：距离地铁距离、附近小学、小区绿化率
    X = np.array([[500, 3, 0.3], [1000, 1, 0.6], [750, 2, 0.3], [600, 5, 0.2], [1200, 1, 0.6]], dtype=float)
    # 具有三个特征的房屋对应的房价
    Y = np.array([10000, 9000, 8000, 12000, 8500], dtype=float)

    std_x = StandardScaler()
    x_train = std_x.fit_transform(X)

    std_y = StandardScaler()
    y_train = std_y.fit_transform(Y.reshape(-1, 1))
    # 构建线性预测模型
    lr = LinearRegression()
    # 模型在历史数据上进行训练，Y.reshape(-1,1)将Y变为二维数组，fit函数参数要求是二维数组
    lr.fit(x_train, y_train.reshape(-1, 1))
    # 使用训练模型预测新房屋价格
    distance = input('请输入新房屋距离地铁的距离：')
    school = input('请输入附近小学数量：')
    green = input('请输入小区绿化率：')
    x_predict = std_x.transform(np.array([[distance, school, green]], dtype=float))
    print(std_y.inverse_transform(lr.predict(x_predict)))
    # print(lr.predict(np.array([[distance, school, green]], dtype=float)))
    # print(lr.predict(np.array([[1300, 3, 0.4]])))


if __name__ == '__main__':
    pairplot_analyse()
    # heatmap_analyse()
    # bostn_linear()
    # log_fit()
    # test_fj()
    # price_predict()
    pass

 线性回归的几个特点： 
1. 建模速度快，不需很复杂的计算，数据量大的情况下依然运行速度很快； 
2. 可以根据系数给出每个变量的理解和解释 ；
3. 对异常值敏感。