def forward(self, head_embed, modifier_embed): """ Do the next LSTM step, and return the hidden state as the new embedding for the reduction Here, note that PyTorch's LSTM wants the input to be a tensor with axis semantics (seq_len, batch_size, input_dimensionality), but we are not minibatching (so batch_size=1) and seq_len=1 since we are only doing 1 timestep NOTE: use utils.concat_and_flatten() like in the MLP Combiner NOTE: Make sure the tensor you hand to your LSTM is the size it wants: (seq_len, batch_size, embedding_dim), which in this case, is (1, 1, embedding_dim) NOTE: If you add more layers to the LSTM (more than 1), your code may break. To fix it, look at the value of self.hidden whenever you have more layers. :param head_embed Embedding of the head word :param modifier_embed Embedding of the modifier """ x = utils.concat_and_flatten([head_embed, modifier_embed]).view(1, 1, -1) y = self.mlplstm(x, self.hidden) out, self.hidden = y return self.hidden[0][0]
def forward(self, inputs): """ NOTE: Use utils.concat_and_flatten to combine all the features into one big row vector. :param inputs A list of autograd.Variables, which are all of the features we will use :return a Variable which is the log probabilities of the actions, of shape (1, 3) (it is a row vector, with an entry for each action) """ # STUDENT inputs = utils.concat_and_flatten(inputs) log_prob = self.model(inputs) return log_prob
def forward(self, head_embed, modifier_embed): """ HINT: use utils.concat_and_flatten() to combine head_embed and modifier_embed into a single tensor. :param head_embed The embedding of the head in the reduction :param modifier_embed The embedding of the modifier in the reduction :return The embedding of the combination as a row vector """ # STUDENT theBigVector = utils.concat_and_flatten([head_embed, modifier_embed]) first = self.firstLayer(theBigVector) tanh = F.tanh(first) return self.secondLayer(tanh)
def forward(self, head_embed, modifier_embed): """ HINT: use utils.concat_and_flatten() to combine head_embed and modifier_embed into a single tensor. :param head_embed The embedding of the head in the reduction :param modifier_embed The embedding of the modifier in the reduction :return The embedding of the combination as a row vector """ # STUDENT inputs = utils.concat_and_flatten([head_embed, modifier_embed]) log_prob = self.model(inputs) return log_prob
def forward(self, head_embed, modifier_embed): """ HINT: use utils.concat_and_flatten() to combine head_embed and modifier_embed into a single tensor. :param head_embed The embedding of the head in the reduction :param modifier_embed The embedding of the modifier in the reduction :return The embedding of the combination as a row vector """ # STUDENT wordembeds = utils.concat_and_flatten([head_embed,modifier_embed]) output = F.tanh(self.linear1(wordembeds)) new_wordembeddings = self.linear2(output) return new_wordembeddings
def forward(self, inputs): """ NOTE: Use utils.concat_and_flatten to combine all the features into one big row vector. :param inputs A list of autograd.Variables, which are all of the features we will use :return a Variable which is the log probabilities of the actions, of shape (1, 3) (it is a row vector, with an entry for each action) """ x = utils.concat_and_flatten(inputs) out = self.afl1(x) out = self.relu(out) out = self.afl2(out) return F.log_softmax(out)
def forward(self, head_embed, modifier_embed): """ HINT: use utils.concat_and_flatten() to combine head_embed and modifier_embed into a single tensor. :param head_embed The embedding of the head in the reduction :param modifier_embed The embedding of the modifier in the reduction :return The embedding of the combination as a row vector """ # STUDENT inp_embed = utils.concat_and_flatten([head_embed, modifier_embed]) hidden = self.fc1(inp_embed) hidden = self.tanh(hidden) output = self.fc2(hidden) return output
def forward(self, inputs): """ NOTE: Use utils.concat_and_flatten to combine all the features into one big row vector. :param inputs A list of autograd.Variables, which are all of the features we will use :return a Variable which is the log probabilities of the actions, of shape (1, 3) (it is a row vector, with an entry for each action) """ # STUDENT input_flat = utils.concat_and_flatten(inputs) ff = self.first(input_flat) relu = F.relu(ff) ss = self.second(relu) return F.log_softmax(ss)
def forward(self, inputs): """ NOTE: Use utils.concat_and_flatten to combine all the features into one big row vector. :param inputs A list of autograd.Variables, which are all of the features we will use :return a Variable which is the log probabilities of the actions, of shape (1, 3) (it is a row vector, with an entry for each action) """ # STUDENT # END STUDENT wordembeds = utils.concat_and_flatten(inputs) output = F.relu(self.linear1(wordembeds)) log_prob = F.log_softmax(self.linear2(output)) return log_prob
def forward(self, inputs): """ NOTE: Use utils.concat_and_flatten to combine all the features into one big row vector. :param inputs A list of autograd.Variables, which are all of the features we will use :return a Variable which is the log probabilities of the actions, of shape (1, 3) (it is a row vector, with an entry for each action) """ # STUDENT inp = utils.concat_and_flatten(inputs) hidden = self.lin1(inp) hidden = self.relu(hidden) output = self.lin2(hidden) output = self.softmax(output) return output
def forward(self, head_embed, modifier_embed): """ HINT: use utils.concat_and_flatten() to combine head_embed and modifier_embed into a single tensor. :param head_embed The embedding of the head in the reduction :param modifier_embed The embedding of the modifier in the reduction :return The embedding of the combination as a row vector """ comb_emb = [] comb_emb.append(head_embed) comb_emb.append(modifier_embed) x = utils.concat_and_flatten(comb_emb) out = self.mlpl1(x) out = self.tanh(out) out = self.mlpl2(out) return out
def forward(self, head_embed, modifier_embed): """ HINT: use utils.concat_and_flatten() to combine head_embed and modifier_embed into a single tensor. :param head_embed The embedding of the head in the reduction :param modifier_embed The embedding of the modifier in the reduction :return The embedding of the combination as a row vector """ # STUDENT flat_input = utils.concat_and_flatten([head_embed, modifier_embed]) iter1 = self.layer1(flat_input) iter2 = self.layer2(iter1) iter3 = self.layer3(iter2) return iter3
def forward(self, inputs): """ NOTE: Use utils.concat_and_flatten to combine all the features into one big row vector. :param inputs A list of autograd.Variables, which are all of the features we will use :return a Variable which is the log probabilities of the actions, of shape (1, 3) (it is a row vector, with an entry for each action) """ # STUDENT flat_input = utils.concat_and_flatten(inputs) iter1 = self.layer1(flat_input) iter2 = self.layer2(iter1) iter3 = self.layer3(iter2) iter4 = self.layer4(iter3) return iter4
def forward(self, head_embed, modifier_embed): embeds = utils.concat_and_flatten([head_embed, modifier_embed]) out = F.tanh(self.linear1(embeds)) new_embeddings = self.linear2(out) return new_embeddings
def forward(self, inputs): embeds = utils.concat_and_flatten(inputs) out = F.relu(self.linear1(embeds)) log_probs = F.log_softmax(self.linear2(out)) return log_probs
def forward(self, head_embed, modifier_embed): embeds = utils.concat_and_flatten([head_embed, modifier_embed]) lstm_out, self.hidden = self.lstm(embeds.view(1, 1, -1), self.hidden) return lstm_out[0]