电力数据分析:数据检查、规律探索和线性回归预测
整理自 data_analysis.ipynb,保留原代码顺序和逻辑。
说明整理为中文注释,便于按段复制和发布;数据文件位于项目根目录。
01. 读取数据、建立时间索引并检查数据完整性
解析 UTC 时间后,对整张表排序,再将 time 设置成索引。
检查缺失比例、全空列、内容重复的列,以及相邻时间间隔。
df.T.duplicated() 检查重复列;mod_df 是筛选后的新表,原 df 仍保留这些列。
按行统计缺失字段数,观察多字段是否在相同时间共同缺失。
保留 notebook 中展示表格的 display 用法。
from IPython.display import display
import pandas as pd
df = pd.read_csv('energy_dataset.csv')
df["time"] = pd.to_datetime(df["time"],utc=True)
df = df.sort_values("time",ascending=True).set_index("time")
null_count = df.isnull().sum()/df.shape[0]
df = df.dropna(how="all",axis=1)
print(df.shape)
display(df.describe())
df.index.duplicated().any()
repeat = df.T.duplicated()
mod_df = df.loc[:,~repeat]
repeated_columns = df.columns[repeat]
print(f"repeated columns are {repeated_columns}")
times = df.index.to_series().diff().dropna()
if len(times.unique())==1:
print("time deltas are all the same")
if times.eq(pd.Timedelta("1 hour")).all():
print("time delta is 1hour")
else:
print(times.unique())
bar_na = df.isnull().sum(axis=1)
bar_na.value_counts().index
print(bar_na.value_counts()[bar_na.value_counts().index>0])
total_load_actual_missing = df["total load actual"].isnull()
print(total_load_actual_missing.sum())
import matplotlib.pyplot as plt
fig,ax = plt.subplots(2,1,figsize=(16,16))
total_load_actual_missing_df = total_load_actual_missing[total_load_actual_missing]
missing_df = bar_na[bar_na>0]
ax[1].scatter(total_load_actual_missing_df.index,total_load_actual_missing_df)
ax[0].scatter(missing_df.index,missing_df)
plt.show()
print(total_load_actual_missing_df.index)
print("common large missing point is ",missing_df[missing_df>1].index.intersection(total_load_actual_missing_df.index))
02. 日内规律:按小时计算平均负荷
index.hour 提取 0—23 点;结果汇总所有日期,展示典型的日内变化。
daily_load = df.groupby(df.index.hour)["total load actual"].mean()
fig,ax = plt.subplots(figsize=(16,8))
ax.bar(daily_load.index,daily_load)
ax.set_title("daily trend")
ax.set_xlabel("time")
ax.set_ylabel("total_load_actual")
plt.show()
03. 星期规律:比较周一到周日的平均负荷
day_name() 返回星期名称,reindex() 按周一到周日排列。
week_order = [
"Monday", "Tuesday", "Wednesday", "Thursday",
"Friday", "Saturday", "Sunday"
]
week_load = df.groupby(df.index.day_name())["total load actual"].mean().reindex(week_order)
fig,ax = plt.subplots(figsize=(16,8))
ax.bar(week_load.index,week_load)
ax.set_title("week_order trend")
ax.set_xlabel("time")
ax.set_ylabel("total_load_actual")
plt.show()
04. 月份规律:比较不同月份的平均负荷
index.month 提取 1—12 月,跨年份汇总同一个月份。
month_load = df.groupby(df.index.month)["total load actual"].mean()
fig,ax = plt.subplots(figsize=(16,8))
ax.bar(month_load.index,month_load)
ax.set_title("month_load trend")
ax.set_xlabel("time")
ax.set_ylabel("total_load_actual")
plt.show()
05. 月中日期规律:按每月第几天分组
index.day 表示每月第 1—31 天,不是连续日期。
若需要每天一个均值,应使用 resample("D").mean()。
daily_load = df.groupby(df.index.day)["total load actual"].mean()
fig,ax = plt.subplots(figsize=(16,8))
ax.bar(daily_load.index,daily_load)
ax.set_title("month_load trend")
ax.set_xlabel("time")
ax.set_ylabel("total_load_actual")
plt.show()
06. 月份箱线图:比较负荷分布和波动
pandas 的 boxplot 按 month 分组,底层绘图仍使用 Matplotlib。
plot_df = df.copy()
plot_df['month'] = plot_df.index.month
ax = plot_df.boxplot(column="total load actual",by="month")
07. 负荷预测误差与价格差:散点图和相关系数
load_error = 实际负荷 - 预测负荷;price_gap = 实际价格 - 日前价格。
散点图的实际横轴为 load_error,纵轴为 price_gap。
Pearson 用于观察线性相关,Spearman 用于观察秩相关;相关不直接代表因果。
load_error = df['total load actual'] - df['total load forecast']
price_gap = df["price actual"] - df['price day ahead']
fig, ax = plt.subplots()
ax.scatter(load_error, price_gap,
s=12, alpha=0.25, color="tab:blue", edgecolors="none")
ax.set(title="Actual load vs actual price (sample)",
xlabel="Actual load", ylabel="Actual price")
ax.set_xlim(-5000,5000)
ax.grid(alpha=0.2)
fig.tight_layout()
plt.show()
print("pearson correlation is", load_error.corr(price_gap))
print("spearman correlation is", load_error.corr(price_gap,method="spearman"))
08. 五分位分组:比较各组价格差
qcut 按负荷预测误差的分位数分成五组。
分别查看 price_gap 的均值、中位数和样本数量。
five_parts = pd.qcut(load_error,5)
predict_df = pd.DataFrame({"load_error":load_error,"price_gap":price_gap,"five":five_parts},index=load_error.index)
x = predict_df.groupby("five")["price_gap"].agg(["mean","median","size"])
fig, axes = plt.subplots(3, 1, figsize=(12, 6), sharex=True)
axes[0].bar([1,2,3,4,5], x.iloc[:,0], color="tab:blue", width=0.65)
axes[1].bar([1,2,3,4,5], x.iloc[:,1], color="tab:blue", width=0.65)
axes[2].bar([1,2,3,4,5], x.iloc[:,2], color="tab:blue", width=0.65)
axes[0].set(title="Mean", xlabel="quantile", ylabel="Mean load")
axes[1].set(title="Median", xlabel="quantile", ylabel="Median load",ylim=(5,8))
axes[2].set(title="Size", xlabel="quantile", ylabel="Size load")
fig.tight_layout()
plt.show()
09. 极端样本:查看价格差绝对值最大的十个时刻
使用绝对值选出极端时刻,再通过 loc 回到原始表调查相关字段。
s = price_gap.abs().nlargest(10)
largest_index = s.index
display(df.loc[largest_index,:])
第五题:用线性回归预测下一小时的实际电价
任务: 在小时 t 结束时,利用当时已经知道的信息,预测 t+1 小时的 price actual。
练习假设截至 t 的实际价格和负荷都已发布;真实业务需要进一步确认发布时间。
这是每小时更新输入、预测下一小时的滚动一步预测,不是在年初一次预测全年。
第一版只用四个特征,显式写列名,便于检查有没有把目标或未来实际值放进去:
price_now:当前小时价格;是,按本题假设
price_lag1:前一小时价格;是
load_now:当前小时实际负荷;是,按本题假设
target_hour:下一小时是几点(UTC);是,日历信息可提前知道
先执行前面读取 CSV、建立 df 的代码,再按顺序执行本节。
这一部分单独创建 model_df,保留前面的 EDA 数据。
5.1 构造特征 X 和目标 y,检查时间对应关系
shift(1) 取上一行,构造历史价格;shift(-1) 取下一行,构造预测目标。
先检查时间连续,再 shift;先构造特征,再按时间切分。
target_time 是目标所属时间,后续按它划分训练、验证和测试集。
缺失目标和必要历史价格的行移除;少量负荷缺失留到训练阶段填补。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from sklearn.linear_model import LinearRegression
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_absolute_error, mean_squared_error
model_source = df[["price actual", "total load actual"]].copy().sort_index()
assert isinstance(model_source.index, pd.DatetimeIndex), "先把 time 转成时间索引"
assert model_source.index.tz is not None, "时间索引需要时区,本题使用 UTC"
model_source.index = model_source.index.tz_convert("UTC")
assert model_source.index.is_unique, "存在重复时间,需要先检查"
gaps = model_source.index.to_series().diff().dropna()
assert len(gaps) > 0 and gaps.eq(pd.Timedelta(hours=1)).all(), "时间必须按小时连续"
model_df = pd.DataFrame(index=model_source.index)
model_df["price_now"] = model_source["price actual"]
model_df["price_lag1"] = model_source["price actual"].shift(1)
model_df["load_now"] = model_source["total load actual"]
model_df["target_time"] = model_df.index + pd.Timedelta(hours=1)
model_df["target_hour"] = model_df["target_time"].dt.hour
model_df["target"] = model_source["price actual"].shift(-1)
model_df = model_df.dropna(subset=["price_now", "price_lag1", "target"])
feature_columns = ["price_now", "price_lag1", "load_now", "target_hour"]
print("Samples:", len(model_df))
print("Missing feature values:")
display(model_df[feature_columns].isna().sum().to_frame("missing_count"))
display(model_df[["target_time"] + feature_columns + ["target"]].head(6))
5.2 按目标时间切分,X 保持 DataFrame,y 使用 Series
2015—2016 年:训练。
2017 年:验证。
2018 年:最终测试。
使用布尔条件时, & 两边的比较表达式需要分别加括号:
(time >= start) & (time < end)。
按 target_time 分组也避免把下一年首个目标误放进上一年的训练集。
每行特征的 index 仍然是信息时刻 t,比 target_time 早一小时。
train_mask = (
(model_df["target_time"] >= "2015-01-01")
& (model_df["target_time"] < "2017-01-01")
)
val_mask = (
(model_df["target_time"] >= "2017-01-01")
& (model_df["target_time"] < "2018-01-01")
)
test_mask = (
(model_df["target_time"] >= "2018-01-01")
& (model_df["target_time"] < "2019-01-01")
)
train_df = model_df.loc[train_mask].copy()
val_df = model_df.loc[val_mask].copy()
test_df = model_df.loc[test_mask].copy()
X_train = train_df[feature_columns]
y_train = train_df["target"]
X_val = val_df[feature_columns]
y_val = val_df["target"]
X_test = test_df[feature_columns]
y_test = test_df["target"]
split_summary = pd.DataFrame([
{"split": name, "samples": len(part),
"first_target": part["target_time"].min(),
"last_target": part["target_time"].max()}
for name, part in [("train", train_df), ("validation", val_df), ("test", test_df)]
]).set_index("split")
display(split_summary)
print("X_train:", type(X_train).name, X_train.shape)
print("y_train:", type(y_train).name, y_train.shape)
5.3 训练线性回归,在验证集上和基准比较
基准预测:下一小时价格等于当前小时价格,即 prediction = price_now。
LinearRegression 不能直接接收缺失值。这里用训练集各列的中位数填补:
make_pipeline(SimpleImputer(...), LinearRegression()) 把填补和模型接在一起。
model.fit(X_train, y_train):先从训练集学习填补值,再拟合回归系数。
model.predict(X_val):沿用训练时的填补值,预测验证集,不会用验证集重新计算中位数。
MAE 是平均绝对误差;RMSE 对较大的误差更敏感。两者都越小越好,单位与价格相同。
def regression_metrics(y_true, y_pred):
return {
"MAE": mean_absolute_error(y_true, y_pred),
"RMSE": np.sqrt(mean_squared_error(y_true, y_pred)),
}
Pipeline 仍然使用相同的 fit / predict 接口
model = make_pipeline(
SimpleImputer(strategy="median"),
LinearRegression(),
)
model.fit(X_train, y_train)
val_baseline_pred = X_val["price_now"].to_numpy()
val_linear_pred = model.predict(X_val)
val_results = pd.DataFrame({
"Current-price baseline": regression_metrics(y_val, val_baseline_pred),
"Linear regression": regression_metrics(y_val, val_linear_pred),
}).T
display(val_results.round(4))
val_mae_improvement = (
1 - val_results.loc["Linear regression", "MAE"]
/ val_results.loc["Current-price baseline", "MAE"]
) * 100
print(f"Validation MAE improvement vs baseline: {val_mae_improvement:.2f}%")
print("Positive means lower MAE; negative means worse than the baseline.")
model.named_steps
5.4 看线性模型到底学到了什么
形式是:预测价格 = 截距 + 每个特征 × 对应系数。
named_steps["linearregression"] 取出 Pipeline 中的线性回归部分。
coef_ 是系数,intercept_ 是截距;末尾下划线通常表示拟合后得到的属性。
系数描述的是其他输入保持不变时的拟合关系;不直接代表因果作用。
特征单位不同,而且价格历史之间可能相关,因此不要仅按系数绝对值排名“重要性”。
这里用数字表示小时,是便于入门的简化;之后可以探索周期编码或类别编码。
linear_step = model.named_steps["linearregression"]
coefficient_table = pd.DataFrame({
"feature": feature_columns,
"coefficient": linear_step.coef_,
}).set_index("feature")
display(coefficient_table.round(6))
print("Intercept:", round(linear_step.intercept_, 6))
5.5 固定方案,用训练集和验证集合并重训,再评估测试集
这一版固定使用以上四个特征和普通线性回归。验证结果用于判断它相对基准的表现。
之后若要改变特征或模型,先在验证阶段比较;测试结果用于报告最终表现。
合并训练集和验证集后,重新创建 final_model,填补值和回归系数都只从这两部分学习。
测试集不参与拟合。两种方法在相同测试样本上比较。
train_val_df = pd.concat([train_df, val_df]).sort_index()
final_model = make_pipeline(
SimpleImputer(strategy="median"),
LinearRegression(),
)
final_model.fit(train_val_df[feature_columns], train_val_df["target"])
test_baseline_pred = X_test["price_now"].to_numpy()
test_linear_pred = final_model.predict(X_test)
test_results = pd.DataFrame({
"Current-price baseline": regression_metrics(y_test, test_baseline_pred),
"Linear regression": regression_metrics(y_test, test_linear_pred),
}).T
display(test_results.round(4))
test_mae_improvement = (
1 - test_results.loc["Linear regression", "MAE"]
/ test_results.loc["Current-price baseline", "MAE"]
) * 100
print(f"Test MAE improvement vs baseline: {test_mae_improvement:.2f}%")
用目标时刻做索引,画图时真实值和预测值对应同一个小时
test_predictions = pd.DataFrame({
"Actual": y_test.to_numpy(),
"Baseline": test_baseline_pred,
"Linear regression": test_linear_pred,
}, index=pd.DatetimeIndex(test_df["target_time"], name="target_time"))
display(test_predictions.head())
5.6 画连续一周的结果,再检查哪些小时误差较大
这里画 2018 年 1 月 1—7 日(UTC)。三条线分别是真实价格、基准和线性回归。
单周曲线用来检查局部形态,整体效果仍看完整测试集的 MAE / RMSE。
最后的分组表按目标小时汇总线性模型的绝对误差,用来寻找后续研究方向。
prediction_week = test_predictions.loc["2018-01-01":"2018-01-07"]
fig, ax = plt.subplots(figsize=(13, 4.5))
ax.plot(prediction_week.index, prediction_week["Actual"],
color="black", linewidth=1.5, label="Actual")
ax.plot(prediction_week.index, prediction_week["Baseline"],
color="tab:orange", linestyle=":", alpha=0.8, label="Current-price baseline")
ax.plot(prediction_week.index, prediction_week["Linear regression"],
color="tab:blue", linestyle="--", alpha=0.85, label="Linear regression")
ax.xaxis.set_major_locator(mdates.DayLocator(interval=1))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%m-%d"))
ax.set(title="One-hour-ahead price predictions: Jan 1-7, 2018 (UTC)",
xlabel="Target date (UTC)", ylabel="Price")
ax.legend(ncol=3, frameon=False)
ax.grid(axis="y", alpha=0.2)
fig.tight_layout()
plt.show()
test_abs_error = (
test_predictions["Actual"] - test_predictions["Linear regression"]
).abs()
hourly_error = (
test_abs_error.groupby(test_abs_error.index.hour)
.agg(["mean", "count"])
.rename(columns={"mean": "MAE", "count": "samples"})
)
hourly_error.index.name = "target_hour_UTC"
display(hourly_error.sort_values("MAE", ascending=False).head(6).round(4))
Top comments (0)