def forward(self, input):
x = F.leaky_relu(self.cbam1(self.conv1(input)), 0.2)
x = F.dropout(x, 0.5)
x = F.leaky_relu(self.cbam2(self.conv2_bn(self.conv2(x))), 0.2)
x = F.dropout(x, 0.5)
x = F.leaky_relu(self.cbam3(self.conv3_bn(self.conv3(x))), 0.2)
x = torch.sigmoid(self.conv4(x)).squeeze()
return x
def forward(self, x):
x = self.avgpooling(x)
x = self.conv(x)
x = torch.flatten(x, start_dim=1)
x = F.dropout(x, 0.5, training=self.training)
x = F.relu(self.fc1(x), inplace=True)
x = F.dropout(x, 0.5, training=self.training)
x = self.fc2(x)
return x
def forward(self, input):
x = input
# This is a hack to get around the fact that the inception net
# provided by torchvision does not provide an attribute of max_pool
# in the inception net constructor
for name, module in self.inception_net.named_children():
if name == 'Conv2d_2b_3x3':
x = self.inception_net.Conv2d_2b_3x3(x)
x = F.max_pool2d(x, kernel_size=3, stride=2)
continue
if name == 'Conv2d_4a_3x3':
x = self.inception_net.Conv2d_4a_3x3(x)
x = F.max_pool2d(x, kernel_size=3, stride=2)
continue
x = module(x)
# Adaptive average pooling for inceptionV3
x = F.adaptive_avg_pool2d(x, (1, 1))
# N x 2048 x 1 x 1
x = F.dropout(x, training=self.training)
# N x 2048 x 1 x 1
x = torch.flatten(x, 1)
# N x 2048
v_out = self.output(self.vowel_output(x))
c_out = self.output(self.consonants_output(x))
return v_out, c_out
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
feature = F.dropout(x, training=self.training)
return self.fc2(feature), feature
def forward(self, x1, x1_f, x1_pos, x1_ner, x1_mask, x2, x2_mask):
"""Inputs:
x1 = document word indices [batch * len_d]
x1_f = document word features indices [batch * len_d * nfeat]
x1_pos = document POS tags [batch * len_d]
x1_ner = document entity tags [batch * len_d]
x1_mask = document padding mask [batch * len_d]
x2 = question word indices [batch * len_q]
x2_mask = question padding mask [batch * len_q]
"""
x1_emb = self.embedding(x1)
x2_emb = self.embedding(x2)
# Dropout on embeddings
if self.opt['dropout_emb'] > 0:
x1_emb = F.dropout(x1_emb, p=self.opt['dropout_emb'],
training=self.training)
x2_emb = F.dropout(x2_emb, p=self.opt['dropout_emb'],
training=self.training)
# Context input 만들기
drnn_input_list = [x1_emb, x1_f]
if self.opt['use_qemb']:
x2_weighted_emb = self.qemb_match(x1_emb, x2_emb, x2_mask)
drnn_input_list.append(x2_weighted_emb)
if self.opt['pos']:
drnn_input_list.append(x1_pos)
if self.opt['ner']:
drnn_input_list.append(x1_ner)
drnn_input = torch.cat(drnn_input_list, 2)
# Context - Bi-LSTM 3Layers
doc_hiddens = self.doc_rnn(drnn_input, x1_mask)
# Qeustion - Bi-LSTM 3Layers, 중요한 토큰에 가중
question_hiddens = self.question_rnn(x2_emb, x2_mask)
if self.opt['question_merge'] == 'avg':
q_merge_weights = layers.uniform_weights(question_hiddens, x2_mask)
elif self.opt['question_merge'] == 'self_attn':
q_merge_weights = self.self_attn(question_hiddens, x2_mask)
question_attn_hidden = layers.weighted_avg(question_hiddens, q_merge_weights)
# start/end points 예측
start_scores = self.start_attn(doc_hiddens, question_attn_hidden, x1_mask)
end_scores = self.end_attn(doc_hiddens, question_attn_hidden, x1_mask)
return start_scores, end_scores
def _setWeights(self):
"""if we want to preserve the CuDNN speed and not reimplement the cell from scratch.
We add a parameter that will contain the raw weights,
and we replace the weight matrix in the LSTM at the beginning of the forward pass."""
for layer in self.layer_names:
raw_w = getattr(self, f'{layer}_raw')
self.module._parameters[layer] = F.dropout(raw_w,
p=self.weight_pro,
training=self.training)
def forward(self, x):
# transform the input
x = self.stn(x)
# Perform the usual forward pass
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
def Conv1d(inputs, conv, batch_norm, is_training, activation=None):
# the Conv1d of pytroch chanages the channels at the 1 dim
# [batch_size, max_time, feature_dims] -> [batch_size, feature_dims, max_time]
inputs = torch.transpose(inputs, 1, 2)
conv1d_output = conv(inputs)
batch_norm_output = batch_norm(conv1d_output)
batch_norm_output = torch.transpose(batch_norm_output, 1, 2)
if activation is not None:
batch_norm_output = activation(batch_norm_output)
return F.dropout(batch_norm_output,
p=hp.dropout_rate,
training=is_training)
def __init__(self, module, weight_prob=[0.], layer_names=[WEIGHT_HH]):
super().__init__()
self.module = module
self.weight_prob = weight_prob
self.layer_names = layer_names
for layer in self.layer_names:
# Makes a copy of the weights of the selected layers.
w = getattr(self.module, layer)
self.register_parameter(f'{layer}_raw', nn.Parameter(w.data))
self.module._parameters[layer] = F.dropout(w,
p=self.weight_prob,
training=False)
def forward(self, samples, **kwargs):
head = samples[:, 0].long()
rel = samples[:, 1].long()
tail = samples[:, 2].long()
year = samples[:, 3]
month = samples[:, 4]
day = samples[:, 5]
h_emb1, r_emb1, t_emb1, h_emb2, r_emb2, t_emb2 = self.get_embedding(
head, rel, tail, year, month, day)
p = self.config.get('model.dropout')
scores = ((h_emb1 * r_emb1) * t_emb1 +
(h_emb2 * r_emb2) * t_emb2) / 2.0
scores = F.dropout(scores, p=p,
training=self.training) # TODO training
scores = torch.sum(scores, dim=1)
return scores, None
