回归算法实例一：家庭用电预测——时间与功率、功率与电流、时间与电压之间的关系

╰半夏微凉° 2023-07-12 09:25 41阅读 0赞

> 安装numpy：pip install --index https://pypi.mirrors.ustc.edu.cn/simple/ numpy  
> 安装scipy：pip install --index https://pypi.mirrors.ustc.edu.cn/simple/ scipy  
> 安装matplotlib：pip install --index https://pypi.mirrors.ustc.edu.cn/simple/ matplotlib  
> 安装scikit-learn：pip install --index https://pypi.mirrors.ustc.edu.cn/simple/ scikit-learn  
> 安装pandas：pip install --index https://pypi.mirrors.ustc.edu.cn/simple/ pandas

导入包：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70][]

# 引入所需要的全部包
    from sklearn.model_selection import train_test_split
    from sklearn.linear_model import LinearRegression
    from sklearn.preprocessing import StandardScaler
    import numpy as np
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    import pandas as pd
    from pandas import DataFrame
    import time
    
    # 设置字符集，防止中文乱码
    mpl.rcParams['font.sans-serif']=[u'simHei']
    mpl.rcParams['axes.unicode_minus']=False

#### 数据预处理 ####

# 加载数据，数据字段：日期、时间、有功功率、无功功率、电压、电流、厨房用电功率、洗衣服用电功率、热水器用电功率
    path='datas/household_power_consumption_1000.txt'
    # 没有混合类型的时候可以通过low_memory=False调用更多内存，加快效率
    df = pd.read_csv(path, sep=';', low_memory=False)
    # 获取前五行数据查看
    df.head()

![20200308173446103.png][]

# 查看格式信息
    df.info()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 1][]

# 异常数据处理（异常数据过滤）
    # 替换非法字符为np.nan
    new_df = df.replace('?', np.nan)
    # 只要有一个数据为空，就进行行删除操作
    datas = new_df.dropna(axis=0,how = 'any') 
    # 观察数据的多种统计指标
    datas.describe().T

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 2][]

# 查看格式信息
    new_df.info()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 3][]

#### 时间与功率之间的关系 ####

# 创建一个时间函数格式化字符串
    def date_format(dt):
        import time
        t = time.strptime(' '.join(dt), '%d/%m/%Y %H:%M:%S')
        return (t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec)
    
    # 获取x和y变量，并将时间转换为数值型连续变量
    X = datas.iloc[:,0:2]
    X = X.apply(lambda x: pd.Series(date_format(x)), axis=1)
    Y = datas['Global_active_power']
    
    X.head(2)

![20200308174125960.png][]

# 对数据集进行测试集和训练集划分
    # X：特征矩阵（类型一般是DataFrame）
    # Y：特征对应的Label标签（类型一般是Series）
    # test_size: 对X/Y进行划分的时候，测试集合的数据占比, 是一个(0,1)之间的float类型的值
    # random_state：数据分割是基于随机器进行分割的，该参数给定随机数种子；给一个值（int类型）的作用就是保证每次分割所产生的数据集是完全相同的
    X_train,X_test,Y_train,Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
    
    print(X_train.shape)
    print(X_test.shape)
    print(Y_train.shape)
    print(Y_test.shape)

![20200308174334517.png][]

X_train.describe().T

![20200308174431121.png][]

# 数据标准化
    # StandardScaler：将数据转换为标准差为1的数据集（有一个数据的映射）
    # 如果一个API名字中有fit，那么就有模型训练的含义
    # 如果一个API名字中有transform， 那么就表示对数据具有转换的含义操作
    # 如果一个API名字中有predict，那么就表示进行数据预测，会有一个预测结果输出
    ss = StandardScaler()
    # 训练并转换
    X_train = ss.fit_transform(X_train)
    # 直接使用在模型构建数据上进行一个数据标准化操作
    X_test = ss.transform(X_test) 
    
    pd.DataFrame(X_train).describe().T

![20200308174718685.png][]

# 模型训练
    lr = LinearRegression()
    lr.fit(X_train, Y_train)
    # 模型校验，预测结果
    y_predict = lr.predict(X_test)
    
    print("训练R2:",lr.score(X_train, Y_train))
    print("测试R2:",lr.score(X_test, Y_test))
    mse = np.average((y_predict-Y_test)**2)
    rmse = np.sqrt(mse)
    print("rmse:",rmse)

![20200308174817928.png][]

# 模型保存/持久化
    # 在机器学习部署的时候，实际上其中一种方式就是将模型进行输出；另外一种方式就是直接将预测结果输出
    # 模型输出一般是将模型输出到磁盘文件
    from sklearn.externals import joblib
    
    # 将标准化模型保存
    joblib.dump(ss, "data_ss.model")
    # 将模型保存
    joblib.dump(lr, "data_lr.model")
    
    # 加载标准化模型
    ss = joblib.load("data_ss.model")
    # 加载训练好的模型
    lr = joblib.load("data_lr.model")
    
    # 使用加载的模型进行预测
    data1 = [[2006, 12, 17, 12, 25, 0]]
    data1 = ss.transform(data1)
    print(data1)
    lr.predict(data1)

![20200308174945893.png][]

# 预测值和实际值画图比较
    t=np.arange(len(X_test))
    # 建一个画布，facecolor是背景色
    plt.figure(facecolor='w')
    plt.plot(t, Y_test, 'r-', linewidth=2, label='真实值')
    plt.plot(t, y_predict, 'g-', linewidth=2, label='预测值')
    # 显示图例，设置图例的位置
    plt.legend(loc = 'upper left')
    plt.title("线性回归预测时间和功率之间的关系", fontsize=20)
    plt.grid(b=True)#加网格
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 4][]

#### 功率与电流之间的关系 ####

# 功率和电流之间的关系
    X2 = datas.iloc[:,2:4]
    Y2 = datas.iloc[:,5]
    
    # 数据分割
    X2_train,X2_test,Y2_train,Y2_test = train_test_split(X2, Y2, test_size=0.2, random_state=0)
    
    # 数据归一化
    scaler2 = StandardScaler()
    # 训练并转换
    X2_train = scaler2.fit_transform(X2_train)
    # 直接使用在模型构建数据上进行一个数据标准化操作 
    X2_test = scaler2.transform(X2_test)
    
    # 模型训练
    lr2 = LinearRegression()
    lr2.fit(X2_train, Y2_train)
    
    # 结果预测
    Y2_predict = lr2.predict(X2_test)
    
    # 模型评估
    print("电流预测准确率: ", lr2.score(X2_test,Y2_test))
    print("电流参数:", lr2.coef_)
    
    # 绘制图表
    t=np.arange(len(X2_test))
    plt.figure(facecolor='w')
    plt.plot(t, Y2_test, 'r-', linewidth=2, label=u'真实值')
    plt.plot(t, Y2_predict, 'g-', linewidth=2, label=u'预测值')
    plt.legend(loc = 'lower right')
    plt.title(u"线性回归预测功率与电流之间的关系", fontsize=20)
    plt.grid(b=True)
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 5][]

#### 时间与电压之间的关系 ####

names=['Date', 'Time', 'Global_active_power', 'Global_reactive_power', 'Voltage', 'Global_intensity', 'Sub_metering_1', 'Sub_metering_2', 'Sub_metering_3']
    
    # 时间和电压之间的关系（Linear）
    # 获取x和y变量, 并将时间转换为数值型连续变量
    X3 = datas[names[0:2]]
    X3 = X3.apply(lambda x: pd.Series(date_format(x)), axis=1)
    Y3 = datas[names[4]].values
    
    # 对数据集进行测试集和训练集划分 
    X3_train,X3_test,Y3_train,Y3_test = train_test_split(X3, Y3, test_size=0.2, random_state=0)
    
    # 数据标准化
    ss = StandardScaler()
    # 训练并转换
    X3_train = ss.fit_transform(X3_train)
    # 直接使用在模型构建数据上进行一个数据标准化操作 
    X3_test = ss.transform(X3_test)
    
    # 模型训练
    lr = LinearRegression()
    lr.fit(X3_train, Y3_train)
    
    # 模型校验，预测结果
    y3_predict = lr.predict(X3_test)
    
    # 模型效果
    print("准确率:",lr.score(X3_test, Y3_test))
    
    # 预测值和实际值画图比较
    t=np.arange(len(X3_test))
    plt.figure(facecolor='w')
    plt.plot(t, Y3_test, 'r-', linewidth=2, label=u'真实值')
    plt.plot(t, y3_predict, 'g-', linewidth=2, label=u'预测值')
    plt.legend(loc = 'lower right')
    plt.title(u"线性回归预测时间和电压之间的关系", fontsize=20)
    # 显示网格
    plt.grid(b=True)
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 6][]

#### 时间和电压之间的多项式关系 ####

# Pipeline：管道的意思，将多个操作合并成为一个操作
    # Pipleline总可以给定多个不同的操作，给定每个不同操作的名称即可，执行的时候，按照从前到后的顺序执行
    models = [
        Pipeline([
                ('Poly', PolynomialFeatures()), 					# 给定进行多项式扩展操作， 第一个操作：多项式扩展
                ('Linear', LinearRegression(fit_intercept=False)) 	# 第二个操作，线性回归
            ])
    ]
    model = models[0]
    # 获取x和y变量, 并将时间转换为数值型连续变量
    X4 = datas[names[0:2]]
    X4 = X4.apply(lambda x: pd.Series(date_format(x)), axis=1)
    Y4 = datas[names[4]]
    
    # 对数据集进行测试集和训练集划分
    X4_train,X4_test,Y4_train,Y4_test = train_test_split(X4, Y4, test_size=0.2, random_state=0)
    
    # 数据标准化
    ss = StandardScaler()
    # 训练并转换
    X4_train = ss.fit_transform(X4_train)
    # 直接使用在模型构建数据上进行一个数据标准化操作 
    X4_test = ss.transform(X4_test)
    
    # 模型训练
    t = np.arange(len(X4_test))
    N = 5
    # 1，2，3，4阶
    d_pool = np.arange(1, N, 1)
    m = d_pool.size
    # 颜色
    clrs = []
    for c in np.linspace(16711680, 255, m):
        clrs.append('#%06x' % int(c))
    line_width = 3
    # 创建一个绘图窗口，设置大小，设置颜色
    plt.figure(figsize=(12,6), facecolor='w')
    for i,d in enumerate(d_pool):
        plt.subplot(N-1,1,i+1)
        plt.plot(t, Y4_test, 'r-', label=u'真实值', ms=10, zorder=N)
        # 设置管道对象中的参数值，Poly是在管道对象中定义的操作名称，后面跟参数名称，设置多项式的阶乘；中间是两个下划线
        model.set_params(Poly__degree=d)
        # 模型训练
        model.fit(X4_train, Y4_train)
        # Linear是管道中定义的操作名称，获取线性回归算法模型对象
        lin = model.get_params('Linear')['Linear']
        output = u'%d阶，系数为：' % d
        # 判断lin对象中是否有对应的属性
        if hasattr(lin, 'alpha_'):
            idx = output.find(u'系数')
            output = output[:idx] + (u'alpha=%.6f, ' % lin.alpha_) + output[idx:]
        if hasattr(lin, 'l1_ratio_'):
            idx = output.find(u'系数')
            output = output[:idx] + (u'l1_ratio=%.6f, ' % lin.l1_ratio_) + output[idx:]
        print (output, lin.coef_.ravel())
        
        # 模型结果预测
        y_hat = model.predict(X4_test)
        # 计算评估值
        s = model.score(X4_test, Y4_test)
        
        # 画图
        z = N - 1 if (d == 2) else 0
        label = u'%d阶, 准确率=%.3f' % (d,s)
        plt.plot(t, y_hat, color=clrs[i], lw=line_width, alpha=0.75, label=label, zorder=z)
        plt.legend(loc = 'upper left')
        plt.grid(True)
        plt.ylabel(u'%d阶结果' % d, fontsize=12)
    
    # 预测值和实际值画图比较
    plt.suptitle(u"线性回归预测时间和电压之间的多项式关系", fontsize=20)
    plt.grid(b=True)
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 7][]

# 获取x和y变量，并将时间转换为数值型连续变量
    X5 = datas[names[0:2]]
    X5 = X5.apply(lambda x: pd.Series(date_format(x)), axis=1)
    Y5 = datas[names[4]]
    
    # 对数据集进行测试集合训练集划分
    X5_train,X5_test,Y5_train,Y5_test = train_test_split(X5, Y5, test_size=0.2, random_state=0)
    
    # 数据标准化
    ss = StandardScaler()
    # 训练并转换
    X5_train = ss.fit_transform(X5_train)
    # 直接使用在模型构建数据上进行一个数据标准化操作 
    X5_test = ss.transform(X5_test)
    
    # 多项式扩展
    poly = PolynomialFeatures(degree=3, interaction_only=True)
    train1 = poly.fit_transform(X5_train)
    test1 = poly.transform(X5_test)
    
    # 模型训练
    linear = LinearRegression(fit_intercept=False)
    linear.fit(train1, Y5_train)
    print(linear.score(test1, Y5_test))
    print(linear.coef_)
    print(linear.intercept_)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 8][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200308112611336.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[20200308173446103.png]: https://img-blog.csdnimg.cn/20200308173446103.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200308173555484.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200308173747688.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200308173903964.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[20200308174125960.png]: https://img-blog.csdnimg.cn/20200308174125960.png
[20200308174334517.png]: https://img-blog.csdnimg.cn/20200308174334517.png
[20200308174431121.png]: https://img-blog.csdnimg.cn/20200308174431121.png
[20200308174718685.png]: https://img-blog.csdnimg.cn/20200308174718685.png
[20200308174817928.png]: https://img-blog.csdnimg.cn/20200308174817928.png
[20200308174945893.png]: https://img-blog.csdnimg.cn/20200308174945893.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200308175059873.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200308175225918.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200308191023655.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020030914431885.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200309144854277.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70