PyTorch学习日记（二）

        跟着唐宇迪pytorch学习的第二天，今天要用pytorch搭建神经网络进行气温预测。

一、数据展示

        1.1 读取数据：

        使用pandas里的read_csv方法来读取csv数据文件并展示：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.optim as optim
import warnings
import datetime
from sklearn import preprocessing
warnings.filterwarnings("ignore")

features = pd.read_csv('')
print(features.head())                    #查看数据
print("数据维度：",features.shape)    #打印数据维度

        数据如图所示：

        其中数据的各项具体意思是：

        year、month、day、week分别代表那一年月日周几；

        temp_1表示昨天的最高温度，temp_2表示前天的最高温度；average表示在历史中，每一年这一天的平均气温；actual表示当天的真实最高温度，这里相当于是标签值；friend表示你朋友猜测的可能值，这里暂时不管它。

        1.2 数据预处理

        首先将数据转为datetime所需要的标准格式：

years = features['year']            #得到年
months = features['month']         #得到月
days = features['day']             #得到日
#转为datetime所需要的标准格式格式
dates = [str(int(year)) + '-' + str(int(month)) + '-' + str(int(day)) for year,month,day in zip(years,months,days)]
dates = [datetime.datetime.strptime(date,'%Y-%m-%d') for date in dates]

        这里绘制一下图像看看是什么样子的：

#绘制数据图像
plt.style.use('fivethirtyeight')    #指定默认风格
fig, ((ax1, ax2), (ax3,ax4)) = plt.subplots(nrows=2, ncols=2, figsize = (10,10))    #设置布局
fig.autofmt_xdate(rotation=45)

ax1.plot(dates,features['actual'])  #绘制标签
ax1.set_xlabel(''); ax1.set_ylabel('Temperature'); ax1.set_title('Max Temp')

ax2.plot(dates,features['temp_1'])  #绘制昨天的气温
ax2.set_xlabel(''); ax2.set_ylabel('Temperature'); ax2.set_title('Previous Max Temp')

ax3.plot(dates,features['temp_2'])  #绘制前天的气温
ax3.set_xlabel(''); ax3.set_ylabel('Temperature'); ax3.set_title('Two Days Prior Max Temp')

ax4.plot(dates,features['friend'])  #绘制朋友预测
ax4.set_xlabel(''); ax4.set_ylabel('Temperature'); ax4.set_title('Friend')

plt.tight_layout(pad=2)

        由于数据里的week一列是字符串类型的，这里使用独热编码将其转化一下，值得注意的是，这里使用的是pandas里的get_dummies方法，可以直接将数据读入进来然后判断哪些是字符串后编码：

#独热编码
features = pd.get_dummies(features)
print(features.head(5))

        单独提取标签：

#标签
labels = np.array(features['actual'])

#在特征中去掉标签
features = features.drop('actual',axis=1)

#名字单独保存一下，以备后患
feature_list = list(features.columns)

#转换成合适的格式
features = np.array(features)

#标准化，执行后数值浮动范围会变小
input_features = preprocessing.StandardScaler().fit_transform(features)

二、构建网络模型 

        2.1 构建网络（复杂一些的方法）

        将数据转为tensor格式：

x = torch.tensor(input_features,dtype=float)
y = torch.tensor(labels,dtype=float)

        构建隐层（这里bias的数量和相应层的特征数相同），设置学习率和损失函数：

#权重参数初始化
weights = torch.randn((14,128), dtype=float, requires_grad=True)        #14个特征转换为128个隐藏层特征
biases = torch.randn(128, dtype=float, requires_grad=True)              #每个神经元有一个偏置
weights2 = torch.randn((128,1), dtype=float, requires_grad=True)
biases2 = torch.randn(1,dtype=float,requires_grad=True)

learning_rate = 0.001
losses = []

        训练：

for i in range(1000):
    #计算隐层
    hidden = x.mm(weights) + biases
    #加入激活函数
    hidden = torch.relu(hidden)
    #预测结果
    prediction = hidden.mm(weights2) + biases2
    #计算损失
    loss = torch.mean((prediction - y)**2)
    losses.append(loss.data.numpy())                #以上是前向传播过程

    #打印损失值
    if i % 100 == 0:
        print('loss:',loss)
    #反向传播,反向传播后得到的是个参数的梯度值，之后还需要进一步更新参数
    loss.backward()

    #更新参数,沿着梯度的反方向乘过来，这里的-代表反方向
    weights.data.add_(- learning_rate * weights.grad.data)
    biases.data.add_(- learning_rate * biases.grad.data)
    weights.data.add_(- learning_rate * weights2.grad.data)
    biases2.data.add_(- learning_rate * biases2.grad.data)

    #每次迭代都需要清空梯度
    weights.grad.data.zero_()
    biases.grad.data.zero_()
    weights2.grad.data.zero_()
    biases2.grad.data.zero_()

         2.2 更简单的方法

input_size = input_features.shape[1]
hidden_size = 128
output_size = 1
batch_size = 16
my_nn = torch.nn.Sequential(
    torch.nn.Linear(input_size,hidden_size),
    torch.nn.Sigmoid(),
    torch.nn.Linear(hidden_size,output_size),
)
cost = torch.nn.MSELoss(reduction='mean')
optimizer = torch.optim.Adam(my_nn.parameters(),lr=0.001)
losses = []
#训练网络
for i in range(1000):
    batch_loss = []
    #用MINI-Batch方法来训练
    for start in range(0, len(input_features), batch_size):
        end = start + batch_size if start + batch_size < len(input_features) else len(input_features)
        xx = torch.tensor(input_features[start:end], dtype=torch.float,requires_grad=True)
        yy = torch.tensor(labels[start:end],dtype=torch.float,requires_grad=True)
        prediction = my_nn(xx)
        loss = cost(prediction,yy)
        optimizer.zero_grad()
        loss.backward(retain_graph = True)
        optimizer.step()
        batch_loss.append(loss.data.numpy())

    if i % 100 == 0:
        losses.append(np.mean(batch_loss))
        print(i,np.mean(batch_loss))