使用 PyTorch 进行预测分析

2020-04-01 08:00:00 · 飞浪

介绍 PyTorch是一个开源机器学习库，广泛用于开发预测模型。预测建模是使用统计算法预测结果的分析阶段。该模型将包含独立变量的数据作为输入，并使用机器学习算法对目标变量进行预测。统计学

介绍

PyTorch 是一个开源机器学习库，广泛用于开发预测模型。预测建模是使用统计算法预测结果的分析阶段。该模型将包含独立变量的数据作为输入，并使用机器学习算法对目标变量进行预测。统计学家、数据科学和机器学习专业人士经常使用它来进行预测。

在本指南中，您将学习使用Pytorch构建预测模型的基础知识。

数据

在本指南中，您将使用一个虚构的贷款申请人数据集，其中包含 600 个观测值和 8 个变量，如下所述：

Is_graduate：申请人是否为毕业生（“1”）或不是（“0”）。
收入：申请人的年收入（美元）。
Loan_amount：提交申请的贷款金额（以美元计）。
Credit_score：申请人的信用评分是否令人满意（“1”）或不满意（“0”）。
authorization_status：贷款申请是否被批准（“1”）或未被批准（“0”）。
年龄：申请人的年龄。
性别：申请人是女性（“1”）还是男性（“0”）。
投资额：申请人申报的股票和共同基金总投资额（以美元计）。

让我们首先加载基线库。

      import pandas as pd
import numpy as np 
import matplotlib.pyplot as plt
import sklearn

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from math import sqrt
    

安装库后，下一步是加载数据并查看变量的基本统计数据。

      df = pd.read_csv('data.csv') 
print(df.shape)
df.describe()
    

输出：

      (600, 8)


|       	| Is_graduate 	| Income        	| Loan_amount   	| Credit_score 	| Age        	| Sex        	| Investment    	| approval_status 	|
|-------	|-------------	|---------------	|---------------	|--------------	|------------	|------------	|---------------	|-----------------	|
| count 	| 600.000000  	| 600.000000    	| 600.000000    	| 600.000000   	| 600.000000 	| 600.000000 	| 600.000000    	| 600.000000      	|
| mean  	| 0.690000    	| 65861.466667  	| 145511.975833 	| 0.696667     	| 48.701667  	| 0.185000   	| 34417.668333  	| 0.683333        	|
| std   	| 0.462879    	| 48628.106723  	| 86728.364583  	| 0.460082     	| 14.778362  	| 0.388622   	| 29742.580389  	| 0.465564        	|
| min   	| 0.000000    	| 3000.000000   	| 6000.000000   	| 0.000000     	| 22.000000  	| 0.000000   	| 2100.000000   	| 0.000000        	|
| 25%   	| 0.000000    	| 38175.000000  	| 111232.500000 	| 0.000000     	| 35.000000  	| 0.000000   	| 16678.000000  	| 0.000000        	|
| 50%   	| 1.000000    	| 50080.000000  	| 134295.000000 	| 1.000000     	| 49.000000  	| 0.000000   	| 26439.000000  	| 1.000000        	|
| 75%   	| 1.000000    	| 76040.000000  	| 168715.000000 	| 1.000000     	| 61.000000  	| 0.000000   	| 35000.000000  	| 1.000000        	|
| max   	| 1.000000    	| 317370.000000 	| 466660.000000 	| 1.000000     	| 76.000000  	| 1.000000   	| 190422.000000 	| 1.000000        	|
    

数据准备

在启动模型之前，准备数据很重要。下面的代码行创建了特征和响应变量的数组。

      target_column = ['approval_status'] 
predictors = list(set(list(df.columns))-set(target_column))

print(target_column)
print(predictors)
    

输出：

      'approval_status']
 
 ['Sex'

下一步是创建训练和测试数据集。这可以使用下面的代码完成。最后一行代码打印训练集（7 个变量的 420 个观测值）和测试集（7 个变量的 180 个观测值）的形状。

      X = df[predictors].values
y = df[target_column].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 30)
print(X_train.shape); print(X_test.shape)
    

输出：

      (420, 7)
 
 (180, 7)

模型建立

您已创建训练集和测试集并准备训练模型。首先，您需要导入所需的库以使用 Pytorch 库。

      import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
    

您已准备好使用人工神经网络 (ANN) 算法构建预测模型。ANN 的基本架构由三个主要组件组成。

输入层：这是输入训练观测值的地方。
隐藏层：这些是输入层和输出层之间的中间层。模型了解这些层中数据所涉及的关系。
输出层：此层是从前面几层发生的事情中提取最终输出的层。

创建 ANN 模型的第一步是创建一个从nn.Module类继承的类ANN 。下一步是使用__init__()方法定义网络层。

在本例中，模型有四层。每层的第一个参数都是输入大小，在本例中为 7。您将对其余层重复此过程。最后阶段的唯一变化是输出是一个变量，代表目标列。您还将添加一个 dropout 层以避免过度拟合。

定义好层之后，使用def forward(self, x)函数定义它们如何相互作用，如下所示。这意味着您正在构建一个完全连接的前馈神经网络，该网络以前向方式从输入到输出。前向步骤从激活函数relu（即整流线性激活）开始。

对于输出层，您将使用 sigmoid 函数将概率转换为类一和类零。

      class ANN(nn.Module):
    def __init__(self, input_dim = 7, output_dim = 1):
        super(ANN, self).__init__()
        self.fc1 = nn.Linear(input_dim, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 32)
        self.fc4 = nn.Linear(32, 32)
        self.output_layer = nn.Linear(32,1)
        self.dropout = nn.Dropout(0.15)
        
     def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = F.relu(self.fc3(x))
        x = F.relu(self.fc4(x))
        x = self.output_layer(x)
        
        return nn.Sigmoid()(x)
    

现在您已经定义了上述模型的架构，请使用下面的代码实例化该模型。

      model = ANN(input_dim = 7, output_dim = 1)

print(model)

输出：

      ANN(
      (fc1): Linear(in_features=7, out_features=64, bias=True)
      (fc2): Linear(in_features=64, out_features=64, bias=True)
      (fc3): Linear(in_features=64, out_features=32, bias=True)
      (fc4): Linear(in_features=32, out_features=32, bias=True)
      (output_layer): Linear(in_features=32, out_features=1, bias=True)
      (dropout): Dropout(p=0.2, inplace=False)
    )
    

您已经创建了模型，现在需要为 Pytorch 库准备好数据。下面的代码行对训练和测试数组执行转换。

      X_train = torch.from_numpy(X_train)
y_train = torch.from_numpy(y_train).view(-1,1)

X_test = torch.from_numpy(X_test)
y_test = torch.from_numpy(y_test).view(-1,1)

下一步是使这些数据可迭代。简单来说，这意味着模型将迭代数据集以生成预测。您将使用Pytorch 提供的torch.utils API 来执行此任务，如下所示。

      train = torch.utils.data.TensorDataset(X_train,y_train)
test = torch.utils.data.TensorDataset(X_test,y_test)

train_loader = torch.utils.data.DataLoader(train, batch_size = 64, shuffle = True)
test_loader = torch.utils.data.DataLoader(test, batch_size = 64, shuffle = True)
    

模型评估

完全连接的 ANN 已准备好进行预测建模，并且您已将训练和测试数组转换为 Pytorch 所需的格式。下一步是模型评估。这是通过计算损失来完成的，它本质上是测量预测标签和实际标签之间的距离。在本例中，使用nn.BCELoss ( )函数的二元交叉熵损失。您还需要使用随机梯度下降优化器优化网络。这是使用下面的代码行完成的。lr参数指定优化器函数的学习率。

      import torch.optim as optim
loss_fn = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, weight_decay= 1e-6, momentum = 0.8)
    

定义损失函数后，下一步是使用以下代码对训练数据进行模型评估。首先在代码的第一行中定义 epoch，而第二行到第六行创建列表，用于跟踪每个 epoch 中的损失和准确率。从第七行开始的代码用于训练模型，计算每个 epoch 的损失和准确率，最后打印输出。

      # lines 1 to 6
epochs = 2000
epoch_list = []
train_loss_list = []
val_loss_list = []
train_acc_list = []
val_acc_list = []

# lines 7 onwards
model.train() # prepare model for training

for epoch in range(epochs):
    trainloss = 0.0
    valloss = 0.0
    
    correct = 0
    total = 0
    for data,target in train_loader:
        data = Variable(data).float()
        target = Variable(target).type(torch.FloatTensor)
        optimizer.zero_grad()
        output = model(data)
        predicted = (torch.round(output.data[0]))
        total += len(target)
        correct += (predicted == target).sum()

        loss = loss_fn(output, target)
        loss.backward()
        optimizer.step()
        trainloss += loss.item()*data.size(0)

    trainloss = trainloss/len(train_loader.dataset)
    accuracy = 100 * correct / float(total)
    train_acc_list.append(accuracy)
    trainloss_list.append(train_loss)
    print('Epoch: {} \tTraining Loss: {:.4f}\t Acc: {:.2f}%'.format(
        epoch+1, 
        train_loss,
        accuracy
        ))
    epoch_list.append(epoch + 1)
    

输出：

      #Truncated output for sake of brevity

    Epoch: 1 	Training Loss: 10.3845	 Acc: 62.86%
    Epoch: 2 	Training Loss: 9.0788	 Acc: 67.14%
    Epoch: 3 	Training Loss: 9.0788	 Acc: 67.14%
    Epoch: 4 	Training Loss: 9.0788	 Acc: 67.14%
    Epoch: 5 	Training Loss: 9.0788	 Acc: 67.14%
    
    Epoch: 1996 	Training Loss: 9.0788	 Acc: 67.14%
    Epoch: 1997 	Training Loss: 9.0788	 Acc: 67.14%
    Epoch: 1998 	Training Loss: 9.0788	 Acc: 67.14%
    Epoch: 1999 	Training Loss: 9.0788	 Acc: 67.14%
    Epoch: 2000 	Training Loss: 9.0788	 Acc: 67.14%
    

输出显示训练数据的准确率约为 67%。现在，您将使用以下代码行评估测试数据的模型性能。

      correct = 0
total = 0
valloss = 0
model.eval() 

with torch.no_grad():
    for data, target in test_loader:
        data = Variable(data).float()
        target = Variable(target).type(torch.FloatTensor)

        output = model(data)
        loss = loss_fn(output, target)
        valloss += loss.item()*data.size(0)
        
        predicted = (torch.round(output.data[0]))
        total += len(target)
        correct += (predicted == target).sum()
    
    valloss = valloss/len(test_loader.dataset)
    accuracy = 100 * correct/ float(total)
    print(accuracy)
    

输出：

      0.7111111450195312

以上输出显示测试集准确率为 71%。您可以进一步微调算法以提高模型性能。

结论

在本指南中，您学习了如何使用高性能深度学习库 Pytorch 执行预测分析。

要了解有关使用 Pytorch 进行数据科学的更多信息，请参阅指南《使用 PyTorch 构建深度学习网络》。

要了解有关使用 Python 进行数据科学的更多信息，请参阅以下指南。

_{免责声明：本内容来源于第三方作者授权、网友推荐或互联网整理，旨在为广大用户提供学习与参考之用。所有文本和图片版权归原创网站或作者本人所有，其观点并不代表本站立场。如有任何版权侵犯或转载不当之情况，请与我们取得联系，我们将尽快进行相关处理与修改。感谢您的理解与支持！}

_查看原文

技术指南

阅读全文

使用 PyTorch 进行预测分析

杭州电子商务研究院

4年前 · 面向社会、服务行业、政产学研结合、整合资源、和谐发展

import pandas as pd import numpy as np import matplotlib.pyplot as plt import sklearn from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error from math import sqrt

(600, 8) | | Is_graduate | Income | Loan_amount | Credit_score | Age | Sex | Investment | approval_status | |------- |------------- |--------------- |--------------- |-------------- |------------ |------------ |--------------- |----------------- | | count | 600.000000 | 600.000000 | 600.000000 | 600.000000 | 600.000000 | 600.000000 | 600.000000 | 600.000000 | | mean | 0.690000 | 65861.466667 | 145511.975833 | 0.696667 | 48.701667 | 0.185000 | 34417.668333 | 0.683333 | | std | 0.462879 | 48628.106723 | 86728.364583 | 0.460082 | 14.778362 | 0.388622 | 29742.580389 | 0.465564 | | min | 0.000000 | 3000.000000 | 6000.000000 | 0.000000 | 22.000000 | 0.000000 | 2100.000000 | 0.000000 | | 25% | 0.000000 | 38175.000000 | 111232.500000 | 0.000000 | 35.000000 | 0.000000 | 16678.000000 | 0.000000 | | 50% | 1.000000 | 50080.000000 | 134295.000000 | 1.000000 | 49.000000 | 0.000000 | 26439.000000 | 1.000000 | | 75% | 1.000000 | 76040.000000 | 168715.000000 | 1.000000 | 61.000000 | 0.000000 | 35000.000000 | 1.000000 | | max | 1.000000 | 317370.000000 | 466660.000000 | 1.000000 | 76.000000 | 1.000000 | 190422.000000 | 1.000000 |

X = df[predictors].values y = df[target_column].values X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 30) print(X_train.shape); print(X_test.shape)

class ANN(nn.Module): def __init__(self, input_dim = 7, output_dim = 1): super(ANN, self).__init__() self.fc1 = nn.Linear(input_dim, 64) self.fc2 = nn.Linear(64, 64) self.fc3 = nn.Linear(64, 32) self.fc4 = nn.Linear(32, 32) self.output_layer = nn.Linear(32,1) self.dropout = nn.Dropout(0.15) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.dropout(x) x = F.relu(self.fc3(x)) x = F.relu(self.fc4(x)) x = self.output_layer(x) return nn.Sigmoid()(x)

ANN( (fc1): Linear(in_features=7, out_features=64, bias=True) (fc2): Linear(in_features=64, out_features=64, bias=True) (fc3): Linear(in_features=64, out_features=32, bias=True) (fc4): Linear(in_features=32, out_features=32, bias=True) (output_layer): Linear(in_features=32, out_features=1, bias=True) (dropout): Dropout(p=0.2, inplace=False) )

train = torch.utils.data.TensorDataset(X_train,y_train) test = torch.utils.data.TensorDataset(X_test,y_test) train_loader = torch.utils.data.DataLoader(train, batch_size = 64, shuffle = True) test_loader = torch.utils.data.DataLoader(test, batch_size = 64, shuffle = True)

# lines 1 to 6 epochs = 2000 epoch_list = [] train_loss_list = [] val_loss_list = [] train_acc_list = [] val_acc_list = [] # lines 7 onwards model.train() # prepare model for training for epoch in range(epochs): trainloss = 0.0 valloss = 0.0 correct = 0 total = 0 for data,target in train_loader: data = Variable(data).float() target = Variable(target).type(torch.FloatTensor) optimizer.zero_grad() output = model(data) predicted = (torch.round(output.data[0])) total += len(target) correct += (predicted == target).sum() loss = loss_fn(output, target) loss.backward() optimizer.step() trainloss += loss.item()*data.size(0) trainloss = trainloss/len(train_loader.dataset) accuracy = 100 * correct / float(total) train_acc_list.append(accuracy) trainloss_list.append(train_loss) print('Epoch: {} \tTraining Loss: {:.4f}\t Acc: {:.2f}%'.format( epoch+1, train_loss, accuracy )) epoch_list.append(epoch + 1)

#Truncated output for sake of brevity Epoch: 1 Training Loss: 10.3845 Acc: 62.86% Epoch: 2 Training Loss: 9.0788 Acc: 67.14% Epoch: 3 Training Loss: 9.0788 Acc: 67.14% Epoch: 4 Training Loss: 9.0788 Acc: 67.14% Epoch: 5 Training Loss: 9.0788 Acc: 67.14% Epoch: 1996 Training Loss: 9.0788 Acc: 67.14% Epoch: 1997 Training Loss: 9.0788 Acc: 67.14% Epoch: 1998 Training Loss: 9.0788 Acc: 67.14% Epoch: 1999 Training Loss: 9.0788 Acc: 67.14% Epoch: 2000 Training Loss: 9.0788 Acc: 67.14%

correct = 0 total = 0 valloss = 0 model.eval() with torch.no_grad(): for data, target in test_loader: data = Variable(data).float() target = Variable(target).type(torch.FloatTensor) output = model(data) loss = loss_fn(output, target) valloss += loss.item()*data.size(0) predicted = (torch.round(output.data[0])) total += len(target) correct += (predicted == target).sum() valloss = valloss/len(test_loader.dataset) accuracy = 100 * correct/ float(total) print(accuracy)