def __init__(self,
encoder,
span_dim=256,
pool_method='avg',
num_labels=1,
just_last_layer=False,
**kwargs):
super(SRLModel, self).__init__()
self.encoder = encoder
self.just_last_layer = just_last_layer
self.pool_method = pool_method
self.num_spans = 2
self.span_net = nn.ModuleDict()
self.span_net['0'] = get_span_module(
method=pool_method,
input_dim=self.encoder.hidden_size,
use_proj=True,
proj_dim=span_dim)
self.span_net['1'] = get_span_module(
method=pool_method,
input_dim=self.encoder.hidden_size,
use_proj=True,
proj_dim=span_dim)
self.pooled_dim = self.span_net['0'].get_output_dim()
self.label_net = nn.Sequential(
nn.Linear(2 * self.pooled_dim, span_dim), nn.Tanh(),
nn.LayerNorm(span_dim), nn.Dropout(0.2),
nn.Linear(span_dim, num_labels), nn.Sigmoid())
self.training_criterion = nn.BCELoss()
def __init__(self,
model='bert',
model_size='base',
just_last_layer=False,
span_dim=256,
pool_method='avg',
fine_tune=False,
num_spans=1,
**kwargs):
super(CorefModel, self).__init__()
self.pool_method = pool_method
self.num_spans = num_spans
self.just_last_layer = just_last_layer
self.encoder = Encoder(model=model,
model_size=model_size,
fine_tune=True,
cased=True)
self.span_net = nn.ModuleDict()
self.span_net['0'] = get_span_module(
method=pool_method,
input_dim=self.encoder.hidden_size,
use_proj=True,
proj_dim=span_dim)
self.pooled_dim = self.span_net['0'].get_output_dim()
self.label_net = nn.Sequential(
nn.Linear(2 * self.pooled_dim, span_dim), nn.Tanh(),
nn.LayerNorm(span_dim), nn.Dropout(0.2), nn.Linear(span_dim, 1),
nn.Sigmoid())
self.training_criterion = nn.BCELoss()
def __init__(self,
encoder,
use_proj,
proj_dim,
hidden_dims,
output_dim,
dropout_ratio=0.2,
pooling_method='avg'):
super(SpanClassifier, self).__init__()
self.span_repr = get_span_module(method=pooling_method,
input_dim=encoder.hidden_size,
use_proj=use_proj,
proj_dim=proj_dim)
input_dim = self.span_repr.get_output_dim()
dims = [input_dim] + hidden_dims + [output_dim]
layers = list()
for i in range(len(dims) - 1):
layers.append(nn.Linear(dims[i], dims[i + 1]))
if i < len(dims) - 2:
layers.append(nn.Tanh())
layers.append(nn.LayerNorm(dims[i + 1]))
layers.append(nn.Dropout(dropout_ratio))
layers.append(nn.Sigmoid())
self.mlp = nn.Sequential(*layers)