深度学习Day-16：实现天气预测

🍨 本文为：[🔗365天深度学习训练营] 中的学习记录博客
🍖 原作者：[K同学啊 | 接辅导、项目定制]

要求：根据提供的数据集对RainTomorrow进行预测

一、基础配置

语言环境：Python3.7
编译器选择：Pycharm
深度学习环境：TensorFlow2.4.1
数据集：私有数据集

二、前期准备

1.设置GPU

import tensorflow as tf

gpus = tf.config.list_physical_devices("GPU")

if gpus:
    tf.config.experimental.set_memory_growth(gpus[0], True)  #设置GPU显存用量按需使用
    tf.config.set_visible_devices([gpus[0]],"GPU")

# 打印显卡信息，确认GPU可用
print(gpus)

根据个人设备情况，选择使用GPU/CPU进行训练，若GPU可用则输出：

[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

由于在设备上安装的CUDA版本与TensorFlow版本不一致，故这里直接安装了CPU版的TensorFlow，无上述输出。

2.导入数据

本项目所采用的数据集未收录于公开数据中，故需要自己在文件目录中导入相应数据集合，并设置对应文件目录，以供后续学习过程中使用。

运行下述代码：

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense,Activation,Dropout
from tensorflow.keras.callbacks import EarlyStopping

data = pd.read_csv("data/weatherAUS.csv")
df = data.copy()
print(data.head)

得到如下输出：

<bound method NDFrame.head of               Date Location  MinTemp  ...  Temp3pm  RainToday  RainTomorrow
0       2008-12-01   Albury     13.4  ...     21.8         No            No
1       2008-12-02   Albury      7.4  ...     24.3         No            No
2       2008-12-03   Albury     12.9  ...     23.2         No            No
3       2008-12-04   Albury      9.2  ...     26.5         No            No
4       2008-12-05   Albury     17.5  ...     29.7         No            No
...            ...      ...      ...  ...      ...        ...           ...
145455  2017-06-21    Uluru      2.8  ...     22.4         No            No
145456  2017-06-22    Uluru      3.6  ...     24.5         No            No
145457  2017-06-23    Uluru      5.4  ...     26.1         No            No
145458  2017-06-24    Uluru      7.8  ...     26.0         No            No
145459  2017-06-25    Uluru     14.9  ...     20.9         No           NaN

[145460 rows x 23 columns]>

接着，观察所给数据集的分布情况及数据类型：

dfdes = data.describe()
print(dfdes)
print(data.dtypes)

得到如下输出：

             MinTemp        MaxTemp  ...        Temp9am       Temp3pm
count  143975.000000  144199.000000  ...  143693.000000  141851.00000
mean       12.194034      23.221348  ...      16.990631      21.68339
std         6.398495       7.119049  ...       6.488753       6.93665
min        -8.500000      -4.800000  ...      -7.200000      -5.40000
25%         7.600000      17.900000  ...      12.300000      16.60000
50%        12.000000      22.600000  ...      16.700000      21.10000
75%        16.900000      28.200000  ...      21.600000      26.40000
max        33.900000      48.100000  ...      40.200000      46.70000

[8 rows x 16 columns]
Date              object
Location          object
MinTemp          float64
MaxTemp          float64
Rainfall         float64
Evaporation      float64
Sunshine         float64
WindGustDir       object
WindGustSpeed    float64
WindDir9am        object
WindDir3pm        object
WindSpeed9am     float64
WindSpeed3pm     float64
Humidity9am      float64
Humidity3pm      float64
Pressure9am      float64
Pressure3pm      float64
Cloud9am         float64
Cloud3pm         float64
Temp9am          float64
Temp3pm          float64
RainToday         object
RainTomorrow      object
dtype: object

接着，我们对日期这个数据进行拆分，将其分为年、月、日三个数据特征：

首先，我们将data中的Date列转换为日期格式：

data['Date'] = pd.to_datetime(data['Date'])
print(data['Date'])

得到如下输出：

0        2008-12-01
1        2008-12-02
2        2008-12-03
3        2008-12-04
4        2008-12-05
            ...    
145455   2017-06-21
145456   2017-06-22
145457   2017-06-23
145458   2017-06-24
145459   2017-06-25
Name: Date, Length: 145460, dtype: datetime64[ns]

接着，我们在data中新增year、Month、及day列：

data['year'] = data['Date'].dt.year
data['Month'] = data['Date'].dt.month
data['day'] = data['Date'].dt.day
print(data.head)

得到如下输出：

<bound method NDFrame.head of              Date Location  MinTemp  MaxTemp  ...  RainTomorrow  year  Month day
0      2008-12-01   Albury     13.4     22.9  ...            No  2008     12   1
1      2008-12-02   Albury      7.4     25.1  ...            No  2008     12   2
2      2008-12-03   Albury     12.9     25.7  ...            No  2008     12   3
3      2008-12-04   Albury      9.2     28.0  ...            No  2008     12   4
4      2008-12-05   Albury     17.5     32.3  ...            No  2008     12   5
...           ...      ...      ...      ...  ...           ...   ...    ...  ..
145455 2017-06-21    Uluru      2.8     23.4  ...            No  2017      6  21
145456 2017-06-22    Uluru      3.6     25.3  ...            No  2017      6  22
145457 2017-06-23    Uluru      5.4     26.9  ...            No  2017      6  23
145458 2017-06-24    Uluru      7.8     27.0  ...            No  2017      6  24
145459 2017-06-25    Uluru     14.9      NaN  ...           NaN  2017      6  25

[145460 rows x 26 columns]>

之后，将data中Date列删除，并观察处理后的数据集：

data.drop('Date',axis=1,inplace=True)
print(data.columns)

得到如下输出：

Index(['Location', 'MinTemp', 'MaxTemp', 'Rainfall', 'Evaporation', 'Sunshine',
       'WindGustDir', 'WindGustSpeed', 'WindDir9am', 'WindDir3pm',
       'WindSpeed9am', 'WindSpeed3pm', 'Humidity9am', 'Humidity3pm',
       'Pressure9am', 'Pressure3pm', 'Cloud9am', 'Cloud3pm', 'Temp9am',
       'Temp3pm', 'RainToday', 'RainTomorrow', 'year', 'Month', 'day'],
      dtype='object')

三、探索式数据分析（EDA）

1.数据相关性探索

通过下列代码：

plt.figure(figsize=(15,13))
ax = sns.heatmap(data.corr(),square=True,annot=True,fmt='.2f')
ax.set_xticklabels(ax.get_xticklabels(),rotation = 90)
plt.show()

得到如下输出：

其中：

plt.figure(figsize=(15, 13))：创建一个新的图形窗口，并设置窗口大小为宽15英寸、高13英寸；
ax = sns.heatmap(data.corr(), square=True, annot=True, fmt='.2f')：使用Seaborn的heatmap函数，绘制了data数据集中各列之间的相关性热力图。data.corr()计算了数据集中各列的相关系数，square=True参数表示方形格子，annot=True参数表示在每个格子中显示相关系数值，fmt='.2f'表示相关系数值保留两位小数；
ax.set_xticklabels(ax.get_xticklabels(), rotation=90)：设置x轴标签的旋转角度为90度，以便更好地展示标签；

2.探索是否会下雨

通过下列代码：

sns.set(style = "darkgrid")
plt.figure(figsize=(8,7))
sns.countplot(x='RainTomorrow',data=data)
plt.show()

得到如下输出：

通过下列代码：

plt.figure(figsize=(8,7))
sns.countplot(x='RainToday',data=data)
plt.show()

得到如下输出：

通过下列代码：

x = pd.crosstab(data['RainTomorrow'],data['RainToday'])
print(x)

这段代码的作用是统计data数据集中RainTomorrow和RainToday两列的不同取值组合下出现的频数，将结果存储在变量x中，并打印输出这个交叉表。

得到如下输出：

RainToday        No    Yes
RainTomorrow              
No            92728  16858
Yes           16604  14597

通过下列代码：

y = x/x.transpose().sum().values.reshape(2,1)*100
print(y)

在这段代码中，首先对交叉表 x 进行了一系列操作。具体来说，它完成了以下几个步骤：

x.transpose()：对交叉表进行转置操作，即行变成列，列变成行；
x.transpose().sum()：对转置后的交叉表进行求和操作，得到每一列的总和；
.values.reshape(2, 1)：将上一步得到的总和值进行形状变换，变为一个2行1列的二维数组；
x / x.transpose().sum().values.reshape(2, 1)：将交叉表 x 中的每个元素都除以对应的列总和；
* 100：将上一步得到的结果乘以100，以得到百分比形式的结果；

RainToday            No        Yes
RainTomorrow                      
No            84.616648  15.383352
Yes           53.216243  46.783757

可以看出：

如果今天不下雨，那么明天下雨的几率为：53.22%
如果今天下雨，那么明天下雨的几率为：46.78%

通过下列代码：

y.plot(kind = "bar",figsize = (8,7),color = ['#006666','#d279a6'])
plt.show()

得到如下输出：

3.探索地理位置与下雨的关系

通过下列代码：

x = pd.crosstab(data['Location'],data['RainToday'])
y = x/x.transpose().sum().values.reshape(-1,1)*100
y = y.sort_values(by='Yes',ascending=True)

color = ['#cc6699','#006699','#006666','#862d86','#ff9966']
y.Yes.plot(kind="barh",figsize=(15,20),color = color)
plt.show()

这段代码中：

首先，通过pd.crosstab()函数创建了一个交叉表x，用于统计Location和RainToday两列之间的频数；
接着，对交叉表进行归一化处理，将每个单元格的值转换为百分比形式，并按Yes列的值进行升序排序；
然后，定义了一个颜色列表color，包含了用于条形图柱子颜色的几种颜色；
最后，使用y.Yes.plot(kind="barh", figsize=(15, 20), color=color)绘制了水平条形图，其中kind="barh"表示创建水平条形图，figsize=(15, 20)设置了图形的大小为宽度15英寸、高度20英寸，color=color指定了条形的颜色；

得到如下输出：

可以看出：位置影响下雨，不同的地方，下雨时长不同。

4.探索湿度压力与下雨的关系

通过下列代码：

plt.figure(figsize=(8,6))
sns.scatterplot(data=data,x='Pressure9am',y='Pressure3pm',hue='RainTomorrow')
plt.show()

得到如下输出：

通过下列代码：

plt.figure(figsize=(8,6))
sns.scatterplot(data=data,x='Humidity9am',y='Humidity3pm',hue='RainTomorrow')
plt.show()

得到如下输出：

可以看出：低压及高适度对下雨有一定的影响。

5.探索气温与下雨的关系

通过下列代码：

plt.figure(figsize=(8,6))
sns.scatterplot(data=data,x='MaxTemp',y='MinTemp',hue='RainTomorrow')
plt.show()

得到如下输出：

可以看出：当最高气温和最低气温接近时，下雨概率会增加。

四、数据预处理

1.处理缺失值

首先，需要观察不同数据项的缺失情况：

datanull = data.isnull().sum()/data.shape[0]*100
print(datanull)

得到如下输出：

Location          0.000000
MinTemp           1.020899
MaxTemp           0.866905
Rainfall          2.241853
Evaporation      43.166506
Sunshine         48.009762
WindGustDir       7.098859
WindGustSpeed     7.055548
WindDir9am        7.263853
WindDir3pm        2.906641
WindSpeed9am      1.214767
WindSpeed3pm      2.105046
Humidity9am       1.824557
Humidity3pm       3.098446
Pressure9am      10.356799
Pressure3pm      10.331363
Cloud9am         38.421559
Cloud3pm         40.807095
Temp9am           1.214767
Temp3pm           2.481094
RainToday         2.241853
RainTomorrow      2.245978
year              0.000000
Month             0.000000
day               0.000000
dtype: float64

通过下列代码：

lst = ['Evaporation','Sunshine','Cloud9am','Cloud3pm']
for col in lst:
    fill_list = data[col].dropna()
    data[col] = data[col].fillna(pd.Series(np.random.choice(fill_list,size=len(data.index))))

s = (data.dtypes =="object")
object_cols = list(s[s].index)
print(object_cols)

这段代码中：

首先，定义了一个列表lst，其中包含了需要处理缺失值的列名：'Evaporation', 'Sunshine', 'Cloud9am', 'Cloud3pm；
然后，通过循环遍历lst列表中的每个列名，对缺失值进行填充。对于每列，首先创建一个非空值列表fill_list，然后使用np.random.choice()函数从fill_list中随机选择值来填充缺失值，确保填充值来自原始数据中的实际观测值；
最后，通过检查数据框中每列的数据类型是否为对象（字符串类型），将结果存储在Series s中。然后，从布尔Series s中提取出数据类型为对象的列名，形成一个列名列表object_cols，并打印输出该列表；

得到如下输出：

['Location', 'WindGustDir', 'WindDir9am', 'WindDir3pm', 'RainToday', 'RainTomorrow']

通过下列代码：

for i in object_cols:
    data[i].fillna(data[i].mode()[0],inplace=True)

t = (data.dtypes == "float64")
num_cols = list(t[t].index)
print(num_cols)

这段代码中：

首先，通过for循环遍历object_cols列表中的每个列名；
对于每个列，使用data[i]选择该列的数据，并使用data[i].mode()[0]找到该列的众数（出现频率最高的值），并将缺失值填充为该众数。fillna()函数的inplace=True参数表示在原始数据上进行就地修改；
接下来，通过检查数据框中每列的数据类型是否为浮点数（float64），将结果存储在布尔Series t中；
最后，从布尔Series t中提取出数据类型为浮点数的列名，形成一个列名列表num_cols，并打印输出该列表；

得到如下输出：

['MinTemp', 'MaxTemp', 'Rainfall', 'Evaporation', 'Sunshine', 'WindGustSpeed', 'WindSpeed9am', 'WindSpeed3pm', 'Humidity9am', 'Humidity3pm', 'Pressure9am', 'Pressure3pm', 'Cloud9am', 'Cloud3pm', 'Temp9am', 'Temp3pm']

通过下列代码：

for i in num_cols:
    data[i].fillna(data[i].median(),inplace = True)

datanull = data.isnull().sum()
print(datanull)

得到如下输出：

Location         0
MinTemp          0
MaxTemp          0
Rainfall         0
Evaporation      0
Sunshine         0
WindGustDir      0
WindGustSpeed    0
WindDir9am       0
WindDir3pm       0
WindSpeed9am     0
WindSpeed3pm     0
Humidity9am      0
Humidity3pm      0
Pressure9am      0
Pressure3pm      0
Cloud9am         0
Cloud3pm         0
Temp9am          0
Temp3pm          0
RainToday        0
RainTomorrow     0
year             0
Month            0
day              0
dtype: int64

2.构建数据集

通过下列代码：

from sklearn.preprocessing import LabelEncoder

label_enconder = LabelEncoder()
for i in object_cols:
    data[i] = label_enconder.fit_transform(data[i])

X = data.drop(['RainTomorrow','day'],axis =1).values
y = data['RainTomorrow'].values

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size= 0.25 , random_state= 101)

scaler = MinMaxScaler()
scaler.fit(X_train)
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

这段代码中：

首先，创建一个LabelEncoder对象label_encoder，用于将对象类型的列进行编码；
通过循环遍历object_cols列表中的每个列名，将每列中的对象类型数据转换为相应的数值编码；
接着，从数据集中提取特征矩阵X和目标变量y。这里将除了'RainTomorrow'和'day'列之外的所有列作为特征，并将'RainTomorrow'列作为目标变量；

除此之外，实现对数据集的划分，具体内容在之前文章中已经阐述，这里不做详细解释。

五、神经网络

1.模型搭建

model = Sequential()
model.add(Dense(units=24,activation='tanh'))
model.add(Dense(units=18,activation='tanh'))
model.add(Dense(units=23,activation='tanh'))
model.add(Dropout(0.5))
model.add(Dense(units=12,activation='tanh'))
model.add(Dropout(0.2))
model.add(Dense(units=1,activation='sigmoid'))

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-4)

model.compile(loss='binary_crossentropy',
              optimizer=optimizer,
              metrics="accuracy")

early_stop = EarlyStopping(monitor='val_loss',
                           mode='min',
                           min_delta=0.001,
                           verbose=1,
                           patience=25,
                           restore_best_weights=True)

2.模型训练

history = model.fit(X_train,
                    y_train,
                    validation_data=(X_test,y_test),
                    batch_size=32,
                    epochs=10,
                    verbose = 1)

运行得到如下输出：

Epoch 1/10
3410/3410 [==============================] - 3s 788us/step - loss: 0.4984 - accuracy: 0.7723 - val_loss: 0.3883 - val_accuracy: 0.8310
Epoch 2/10
3410/3410 [==============================] - 4s 1ms/step - loss: 0.4041 - accuracy: 0.8283 - val_loss: 0.3766 - val_accuracy: 0.8365
Epoch 3/10
3410/3410 [==============================] - 4s 1ms/step - loss: 0.3902 - accuracy: 0.8347 - val_loss: 0.3751 - val_accuracy: 0.8382
Epoch 4/10
3410/3410 [==============================] - 4s 1ms/step - loss: 0.3859 - accuracy: 0.8368 - val_loss: 0.3729 - val_accuracy: 0.8384
Epoch 5/10
3410/3410 [==============================] - 4s 1ms/step - loss: 0.3857 - accuracy: 0.8361 - val_loss: 0.3717 - val_accuracy: 0.8386
Epoch 6/10
3410/3410 [==============================] - 4s 1ms/step - loss: 0.3831 - accuracy: 0.8371 - val_loss: 0.3709 - val_accuracy: 0.8392
Epoch 7/10
3410/3410 [==============================] - 4s 1ms/step - loss: 0.3791 - accuracy: 0.8372 - val_loss: 0.3700 - val_accuracy: 0.8401
Epoch 8/10
3410/3410 [==============================] - 3s 968us/step - loss: 0.3803 - accuracy: 0.8381 - val_loss: 0.3700 - val_accuracy: 0.8387
Epoch 9/10
3410/3410 [==============================] - 2s 592us/step - loss: 0.3792 - accuracy: 0.8375 - val_loss: 0.3687 - val_accuracy: 0.8398
Epoch 10/10
3410/3410 [==============================] - 2s 578us/step - loss: 0.3818 - accuracy: 0.8385 - val_loss: 0.3682 - val_accuracy: 0.8404

Process finished with exit code 0

模型训练结果为：val_accuracy = 84.04%

六、模型评估

1.Loss与Accuracy图

import matplotlib.pyplot as plt

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(10)

plt.figure(figsize=(14, 4))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')

plt.show()

得到的可视化结果：

七、个人理解

本项目目标为实现天气预测，需要根据给定的CSV文件来实现该目标。由于CSV为表格类文件，故可能存在数据缺失的情况，因此在进入网络模型训练前需要针对表格中的数据做一定的处理。与之前的项目相比，今天学习到了更多的数据分析理论及数据可视化方法，数据可视化能够更加直观的观察到数据分布情况，使得特征选取的可解释性得到进一步的加强。