接下来开始建立我们的PyTorch模型。我们将使用PyTorch实现一个具有批量输入的神经网络回归，具体将涉及以下步骤。

1. 将数据转换为Torch tensors2. 定义模型结构3. 定义损失标准和优化器。4. 创建一个批次的数据加载器5. 跑步训练

3.3.1.数据转换

首先将数据转换为torch tensors

from torch.autograd import Variable

num_features = list(

set(num_cols) - set(['SalePrice', 'Id'])

)

X_train_num_pt = Variable(

torch.cuda.FloatTensor(

X_train[num_features].values

)

)

X_train_cat_pt = Variable(

torch.cuda.LongTensor(

X_train[cat_cols].values

)

)

y_train_pt = Variable(

torch.cuda.FloatTensor(y_train.values)

).view(-1, 1)

X_test_num_pt = Variable(

torch.cuda.FloatTensor(

X_test[num_features].values

)

)

X_test_cat_pt = Variable(

torch.cuda.LongTensor(

X_test[cat_cols].values

).long()

)

y_test_pt = Variable(

torch.cuda.FloatTensor(y_test.values)

).view(-1, 1)

        这可以确保我们将数字和分类数据加载到单独的变量中，类似于NumPy。如果你把数据类型混合在一个变量（数组/矩阵）中，它们就会变成对象。我们希望把数值变量弄成浮点数，把分类变量弄成长（或int），索引我们的类别。我们还将训练集和测试集分开。显然，一个ID变量在模型中不应该是重要的。在最坏的情况下，如果ID与目标有任何相关性，它可能会引入目标泄漏。我们已经把它从这一步的处理中删除了。

3.3.2定义模型架构

class RegressionModel(torch.nn.Module):

def __init__(self, X, num_cols, cat_cols, device=torch.device('cuda'), embed_dim=2, hidden_layer_dim=2, p=0.5):

super(RegressionModel, self).__init__()

self.num_cols = num_cols

self.cat_cols = cat_cols

self.embed_dim = embed_dim

self.hidden_layer_dim = hidden_layer_dim

self.embeddings = [

torch.nn.Embedding(

num_embeddings=len(X[col].unique()),

embedding_dim=embed_dim

).to(device)

for col in cat_cols

]

hidden_dim = len(num_cols) + len(cat_cols) * embed_dim,

# hidden layer

self.hidden = torch.nn.Linear(torch.IntTensor(hidden_dim), hidden_layer_dim).to(device)

self.dropout_layer = torch.nn.Dropout(p=p).to(device)

self.hidden_act = torch.nn.ReLU().to(device)

# output layer

self.output = torch.nn.Linear(hidden_layer_dim, 1).to(device)

def forward(self, num_inputs, cat_inputs):

'''Forward method with two input variables -

numeric and categorical.

'''

cat_x = [

torch.squeeze(embed(cat_inputs[:, i] - 1))

for i, embed in enumerate(self.embeddings)

]

x = torch.cat(cat_x + [num_inputs], dim=1)

x = self.hidden(x)

x = self.dropout_layer(x)

x = self.hidden_act(x)

y_pred = self.output(x)

return y_pred

house_model = RegressionModel(

data_ames, num_features, cat_cols

)

        我们在两个线性层（上的激活函数是整流线性单元激活（ReLU）函数。这里需要注意的是，我们不可能将相同的架构（很容易）封装成一个顺序模型，因为分类和数值类型上发生的操作不同。

3.3.3定义损失准则和优化器

        接下来，定义损失准则和优化器。我们将均方误差（MSE）作为损失，随机梯度下降作为我们的优化算法。

criterion = torch.nn.MSELoss().to(device)

optimizer = torch.optim.SGD(house_model.parameters(), lr=0.001)

3.3.4创建数据加载器

现在，创建一个数据加载器，每次输入一批数据。

data_batch = torch.utils.data.TensorDataset(

X_train_num_pt, X_train_cat_pt, y_train_pt

)

dataloader = torch.utils.data.DataLoader(

data_batch, batch_size=10, shuffle=True

)

我们设置了10个批次的大小，接下来我们可以进行训练了。

3.3.5.训练模型

       基本上，我们要在epoch上循环，在每个epoch内推理出性能，计算出误差，优化器根据误差进行调整。这是在没有训练的内循环的情况下，在epochs上的循环。

from tqdm.notebook import trange

train_losses, test_losses = [], []

n_epochs = 30

for epoch in trange(n_epochs):

train_loss, test_loss = 0, 0

# print the errors in training and test:

if epoch % 10 == 0 :

print(

'Epoch: {}/{}\t'.format(epoch, 1000),

'Training Loss: {:.3f}\t'.format(

train_loss / len(dataloader)

),

'Test Loss: {:.3f}'.format(

test_loss / len(dataloader)

)

)

 训练是在这个循环里面对所有批次的训练数据进行的。

for (x_train_num_batch,x_train_cat_batch,y_train_batch) in dataloader:

(x_train_num_batch,x_train_cat_batch, y_train_batch) = (

x_train_num_batch.to(device),

x_train_cat_batch.to(device),

y_train_batch.to(device))

pred_ytrain = house_model.forward(x_train_num_batch, x_train_cat_batch)

loss = torch.sqrt(criterion(pred_ytrain, y_train_batch))

optimizer.zero_grad()

loss.backward()

optimizer.step()

train_loss += loss.item()

with torch.no_grad():

house_model.eval()

pred_ytest = house_model.forward(X_test_num_pt, X_test_cat_pt)

test_loss += torch.sqrt(criterion(pred_ytest, y_test_pt))

train_losses.append(train_loss / len(dataloader))

test_losses.append(test_loss / len(dataloader))

训练结果如下：

我们取 nn.MSELoss 的平方根，因为 PyTorch 中 nn.MSELoss 的定义如下：

<code>opt_SGD = torch.optim.SGD(net_SGD.parameters(), lr=LR)

opt_Momentum = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.6)

opt_RMSprop = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.1)

opt_Adam = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.8, 0.98))

        SGD的工作原理与梯度下降相同，只是它每次只在一个例子上工作。有趣的是，收敛性与梯度下降相似，并且更容易占用计算机内存。

        RMSProp的工作原理是根据梯度符号来调整算法的学习率。最简单的变体是检查最后两个梯度符号，然后调整学习率，如果它们相同，则增加一个分数，如果它们不同，则减少一个分数。

        ADAM是最流行的优化器之一。它是一种自适应学习算法，根据梯度的第一和第二时刻改变学习率。

        Captum是一个工具，可以帮助我们了解在数据集上学习的神经网络模型的来龙去脉。它可以帮助我们学习以下内容。

特征重要性

层级重要性

神经元的重要性

        这在学习可解释的神经网络中是非常重要的。在这里，综合梯度已经被应用于理解特征重要性。之后，还用层传导法来证明神经元的重要性。

五、补充

        既然我们已经定义并训练了我们的神经网络，那么让我们使用 captum 库找到重要的特征和神经元。

from captum.attr import (

IntegratedGradients,

LayerConductance,

NeuronConductance

)

house_model.cpu()

for embedding in house_model.embeddings:

embedding.cpu()

house_model.cpu()

ing_house = IntegratedGradients(forward_func=house_model.forward, )

#X_test_cat_pt.requires_grad_()

X_test_num_pt.requires_grad_()

attr, delta = ing_house.attribute(

X_test_num_pt.cpu(),

target=None,

return_convergence_delta=True,

additional_forward_args=X_test_cat_pt.cpu()

)

attr = attr.detach().numpy()

 现在，我们有了一个NumPy的特征重要性数组。层和神经元的重要性也可以用这个工具获得。让我们来看看我们第一层的神经元importances。我们可以传递house_model.act1，这是第一层线性层上面的ReLU激活函数。

cond_layer1 = LayerConductance(house_model, house_model.act1)

cond_vals = cond_layer1.attribute(X_test, target=None)

cond_vals = cond_vals.detach().numpy()

df_neuron = pd.DataFrame(data = np.mean(cond_vals, axis=0), columns=['Neuron Importance'])

df_neuron['Neuron'] = range(10)

这张图显示了神经元的重要性。显然，一个神经元就是不重要的。我们还可以通过对之前得到的NumPy数组进行排序，看到最重要的变量。