点击关注我哦

一篇文章带你亲临Kaggle项目

这篇文章将使用 Kaggle 的 Montréal 自行车道数据集（数据集下载地址：https://www.kaggle.com/pablomonleon/montreal-bike-lanes）来演示 PyTorch 线性回归模型，并用它来回答以下两个问题：

1. 同一天使用不同自行车道的骑车人数之间是否有关系？

2. 根据另一条路上有多少人，你能预测出一条路上会有多少人吗？

检查数据

# Download the data
dataframe = pd.read_csv(DATA_FILENAME)
dataframe.head()

这些行代表了统计的日期，第一行代表了Montreal的自行车道名称，表中的元素值表示某天使用某条车道的自行车的数量。

虽然日期栏可以提供有用的信息，我们不会需要它为我们的回归，因为一个自行车道上的人数是独立的自行车在任何一天。这个自行车道的使用遵循泊松分布。

在一些数据处理之后，我们创建了一个可视化图形来给我们的数据一种直观感觉。如下图所示：

我们可以看到自行车道使用遵循季节性变化，直观看来，图表的左侧数据比较低的原因可能是因为它是冬季。

我们也看到各种颜色的线条趋向于彼此相关，但是从上面的图中很难看出来。

仔细观察第150天到第200天的数据，你会发现一个清晰的模式。我们可以相当自信地回答第一个问题ーー同一天使用不同自行车道的骑车人数之间存在一定的关系。

但是我们又会有一个新的问题：自行车道之间的使用到底有多么密切...

准备模型

在本练习中，我们随机选择1个自行车道作为因变量，并使用其他16个自行车道作为自变量。在这种情况下，TARGET _ COLUMN 是“Parc”自行车道。

# Convert from Pandas dataframe to numpy arrays
inputs = dataframe.drop(TARGET_COLUMN, axis=1).values
targets = dataframe[[TARGET_COLUMN]].values
inputs.shape, targets.shape
((319, 16), (319, 1))

# Convert to PyTorch dataset
dataset = TensorDataset(torch.tensor(inputs, dtype=torch.float32), torch.tensor(targets, dtype=torch.float32))
train_ds, val_ds = random_split(dataset, [255, 64])train_loader = DataLoader(train_ds, batch_size, shuffle=True)
val_loader = DataLoader(val_ds, batch_size*2)

我们将包含16个预测列和1个目标列的319行自行车道数据转换成训练使用的张量数据，并设置训练集和验证集的比例为8:2。

现在数据是 PyTorch 张量，我们可以将数据提供给模型。

模型

class BikeLaneModel(nn.Module):def __init__(self):super().__init__()self.linear = nn.Linear(input_size, output_size)def forward(self, xb):out = self.linear(xb)return outdef training_step(self, batch):inputs, targets = batchout = self(inputs)                   # Generate predictionsloss = F.mse_loss(out, targets)      # Calculate lossreturn lossdef validation_step(self, batch):inputs, targets = batchout = self(inputs)                   # Generate predictions      loss = F.mse_loss(out, targets)      # Calculate lossreturn {'val_loss': loss.detach()}def validation_epoch_end(self, outputs):batch_losses = [x['val_loss'] for x in outputs]epoch_loss = torch.stack(batch_losses).mean()   # Combine lossesreturn {'val_loss': epoch_loss.item()}def epoch_end(self, epoch, result):if epoch % 20 == 0:print("Epoch [{}], val_loss: {:.4f}".format(epoch, result['val_loss']))

这个线性 PyTorch 模型应用一个线性映射来输入数据，并使用均方差(MSE)损失函数。该线性映射将输入参数转换为一个线性方程的权重乘以其参数，再加上偏差，是一个比较常用的线性回归损失函数，可以理解为目标和预测之间的平方差的和，除以元素的数目。

训练模型

def evaluate(model, val_loader):outputs = [model.validation_step(batch) for batch in val_loader]return model.validation_epoch_end(outputs)def fit(epochs, lr, model, train_loader, val_loader, opt_func=torch.optim.SGD):history = []optimizer = opt_func(model.parameters(), lr)for epoch in range(epochs):# Training Phase for batch in train_loader:loss = model.training_step(batch)loss.backward()optimizer.step()optimizer.zero_grad()# Validation phaseresult = evaluate(model, val_loader)model.epoch_end(epoch, result)history.append(result)return history

这个 fit 函数将使用梯度下降算法，并迭代若干个epoch来训练模型。

在每个迭代或epoch上，我们从训练张量数据中随机获取一批训练张量数据，并将其传入模型中。由此产生的损失使我们能够衡量模型和目标之间的“距离”。

借助 loss.backwards ()和 optimizer.step ()两个函数的组合，PyTorch 可以计算损失函数的导数，以确定导数是正还是负，并调整各个参数的权重。

最后，我们为另一轮训练重置优化器，记录我们的进度并重新开始。

history = fit(200, learning_rate, model, train_loader, val_loader)

Epoch [0], val_loss: 269544.1875

Epoch [20], val_loss: 290616.6250

Epoch [40], val_loss: 264596.8750

Epoch [60], val_loss: 240678.6562

Epoch [80], val_loss: 215443.0781

Epoch [100], val_loss: 197642.2188

Epoch [120], val_loss: 180842.4531

Epoch [140], val_loss: 163200.7812

Epoch [160], val_loss: 153161.2969

Epoch [180], val_loss: 141288.9062

losses = [r['val_loss'] for r in [result] + history]
plt.plot(losses, '-x')
plt.xlabel('epoch')
plt.ylabel('val_loss')
plt.title('val_loss vs. epochs')
losses[-1]

131520.3125

训练超过200个epoch后，我们观察到损失逐渐减少，作为权重的参数调整。

评估模型

模型训练后，让我们看一下模型的准确性，以确定我们是否可以使用它来回答我们的第二个问题。下面是进行模型评估的代码：

from sklearn.metrics import r2_scoreresult = model(val_ds[:][0])
pred = result.data[:,0].numpy()
r2 = r2_score(pred,val_ds[:][1])
print(r2)

0.9252106664441485

# Adjusted R2
n = len(val_ds)
1 - ( (1 - r2) * (n - 1) / (n - input_size - 1) )

0.8997504677868373

调整后的 R2是0-1之间的一个值，它可以反映出我们的模型是否适合我们的数据。换句话说，就是以0-100% 的范围内，给出你的模型和因变量之间的关系的强度。最终结果0.89是一个相对比较高的值，这意味着我们的线性回归模型使用16个自行车道作为输入与“Parc”自行车道有很强的关系。

让我们使用我们的模型进行预测，并将其与目标进行比较：

x, target = val_ds[10]
pred = predict_single(x, model)
print("Input: ", x)
print("Target: ", target.item())
print("Prediction:", pred)

Input: tensor([5420., 4273., 5685., 2808., 14., 2216., 2555., 2174., 3908., 4876., 2911., 653., 2554., 3103., 4320., 599.]) Target: 3552.0 Prediction: 3155.875732421875

为了估计使用自行车道的自行车人数，这是一个相当好的预测。

让我们来看看我们的总体预测。

sns.set(color_codes=True)
sns.set_style('ticks')
fig, ax = plt.subplots()
fig.set_size_inches(4,4)
sns.regplot(x='Target', y='Prediction', data=df, ax=ax)
plt.title("Target vs Prediction on validation data set")
plt.show()

将模型的预测与目标进行对比绘图，可以向我们展示：有些预测可能会比实际目标高出很多，但总的来说，预测和目标是相当吻合的。

我们可以非常自信地预测出一条路上会有多少人，只需要知道另一条路上有多少人。

总结

我们使用 PyTorch/线性回归模型分析了 Kaggle中Montréal 自行车道的数据，并可以我们以下两个问题：

1. 在同一天使用不同自行车道的自行车人数之间有很强的相关性；

2. 我们可以根据另一条自行车道上的人数来预测在一条自行车道上会有多少人。

·  END  ·

HAPPY LIFE