| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
|
|
|
|
| class HandcraftedFilter(nn.Module): |
| def __init__(self, feat_dim, num_relations): |
| super().__init__() |
| self.num_relations = num_relations |
|
|
| self.filter_weights = torch.tensor([1 / 4, 1 / 2, 1, 1 / 2, 1 / 4], |
| dtype=torch.float32) |
| self.expanded_filter_weights = self.filter_weights.view( |
| 1, 1, -1).repeat(feat_dim, 1, 1) |
|
|
| self.fc1 = nn.Linear(feat_dim, feat_dim // 2) |
| self.fc2 = nn.Linear(feat_dim // 2, feat_dim // 4) |
|
|
| self.span_head = nn.Linear(feat_dim // 4, num_relations) |
| self.pred_head = nn.Linear(feat_dim // 4, num_relations) |
|
|
| def forward(self, x): |
| _, _, feat_dim = x.shape |
| x = x.permute(0, 2, 1) |
| filtered_x = F.conv1d(x, |
| self.expanded_filter_weights.to(x.device), |
| padding=2, |
| groups=feat_dim) |
| filtered_x = filtered_x.permute(0, 2, 1) |
|
|
| filtered_x = F.relu(self.fc1(filtered_x)) |
| filtered_x = F.relu(self.fc2(filtered_x)) |
|
|
| span_pred = self.span_head(filtered_x) |
|
|
| relation_pred = self.pred_head(filtered_x) |
| relation_pred = torch.max(relation_pred, dim=1).values |
|
|
| return span_pred, relation_pred |
|
|
|
|
| class Learnable1DConv(nn.Module): |
| def __init__(self, input_dim, num_relations, kernel_size=5, num_layers=1): |
| super(Learnable1DConv, self).__init__() |
| self.num_relations = num_relations |
|
|
| layers = [] |
| for _ in range(num_layers): |
| layers.append( |
| nn.Conv1d(input_dim, |
| input_dim, |
| kernel_size, |
| padding=kernel_size // 2)) |
| layers.append(nn.ReLU()) |
| self.conv_layers = nn.Sequential(*layers) |
|
|
| self.fc1 = nn.Linear(input_dim, input_dim // 2) |
| self.fc2 = nn.Linear(input_dim // 2, input_dim // 4) |
|
|
| self.span_head = nn.Linear(input_dim // 4, num_relations) |
| self.pred_head = nn.Linear(input_dim // 4, num_relations) |
|
|
| def forward(self, x): |
| x = x.permute(0, 2, 1) |
| conv_output = self.conv_layers(x) |
| filtered_x = conv_output.permute(0, 2, 1) |
|
|
| filtered_x = F.relu(self.fc1(filtered_x)) |
| filtered_x = F.relu(self.fc2(filtered_x)) |
| span_pred = self.span_head(filtered_x) |
|
|
| relation_pred = self.pred_head(filtered_x) |
| relation_pred = torch.max(relation_pred, dim=1).values |
|
|
| return span_pred, relation_pred |
|
|
