我们从Python开源项目中，提取了以下23个代码示例，用于说明如何使用torch.nn.functional.elu()。
def forward(self, x): x = F.elu(F.max_pool2d(self.conv1(x), 2)) x = F.elu(F.max_pool2d(self.bn2(self.conv2(x)), 2)) x = F.elu(F.max_pool2d(self.bn3(self.conv3(x)), 2)) x = F.elu(F.max_pool2d(self.bn4(self.conv4(x)), 2)) x = x.view(-1, 750) x = F.relu(self.fc1(x)) x = F.dropout(x, training=self.training) x = self.fc2(x) return F.log_softmax(x)
def forward(self, input): # TODO perhaps add batch normalization or layer normalization x = F.elu(self.conv1(input)) x = F.elu(self.conv2(x)) x = F.elu(self.conv3(x)) # Next flatten the output to be batched into LSTM layers # The shape of x is batch_size, channels, height, width x = self.pre_lstm_bn(x) x = torch.transpose(x, 1, 3) x = torch.transpose(x, 1, 2) x = x.contiguous() x = x.view(x.size(0), self.batch, self.hidden_dim) x, hidden = self.lstm(x, (self.hidden_state, self.cell_state)) self.hidden_state, self.cell_state = hidden x = torch.transpose(x, 2, 1) x = x.contiguous() x = x.view(x.size(0), self.hidden_dim, self.height, self.width) x = self.lstm_batch_norm(x) x = F.elu(self.conv4(x)) x = F.elu(self.conv5(x)) o_begin = self.begin_conv(x) o_end = self.end_conv(x) o_begin = o_begin.view(o_begin.size(0), -1) o_end = o_end.view(o_end.size(0), -1) o_begin = F.log_softmax(o_begin) o_end = F.log_softmax(o_end) return o_begin, o_end
def forward(self, input): x = F.elu(self.conv1(input)) x = F.elu(self.conv2(x)) x = F.elu(self.conv3(x)) # Next flatten the output to be batched into LSTM layers # The shape of x is batch_size, channels, height, width x = self.pre_lstm_bn(x) x = torch.transpose(x, 1, 3) x = torch.transpose(x, 1, 2) x = x.contiguous() x = x.view(x.size(0), self.batch, self.hidden_dim) x, hidden = self.lstm(x, (self.hidden_state, self.cell_state)) self.hidden_state, self.cell_state = hidden x = torch.transpose(x, 2, 1) x = x.contiguous() x = x.view(x.size(0), self.hidden_dim, self.height, self.width) x = self.lstm_batch_norm(x) x = F.elu(self.conv4(x)) x = F.elu(self.conv5(x)) logit = self.move_conv(x) logit = logit.view(logit.size(0), -1) x = self.value_conv(x) x = x.view(x.size(0), self.hidden_dim, self.batch) x = F.max_pool1d(x, self.batch) x = x.squeeze() val = self.value_linear(x) return val, logit
def forward(self, x): x = self.bn(x) x = F.elu(x, inplace=True) x = self.conv(x) if self.dropout is not None: x = self.drop(x) return x
def selu(x): alpha = 1.6732632423543772848170429916717 scale = 1.0507009873554804934193349852946 # noinspection PyTypeChecker return scale * where(x >= 0, x, alpha * F.elu(x))
def selu(x): alpha = 1.6732632423543772848170429916717 scale = 1.0507009873554804934193349852946 return scale * F.elu(x, alpha)
def __init__(self, in_chans, n_classes, input_time_length, final_conv_length, n_filters_time=25, n_filters_spat=25, filter_time_length=10, pool_time_length=3, pool_time_stride=3, n_filters_2=50, filter_length_2=10, n_filters_3=100, filter_length_3=10, n_filters_4=200, filter_length_4=10, first_nonlin=elu, first_pool_mode='max', first_pool_nonlin=identity, later_nonlin=elu, later_pool_mode='max', later_pool_nonlin=identity, drop_prob=0.5, double_time_convs=False, split_first_layer=True, batch_norm=True, batch_norm_alpha=0.1, stride_before_pool=False): if final_conv_length == 'auto': assert input_time_length is not None self.__dict__.update(locals()) del self.self
def forward(self, image_pairs: Variable) -> Variable: arc_out = self.arc(image_pairs) d1 = F.elu(self.dense1(arc_out)) decision = torch.sigmoid(self.dense2(d1)) return decision
def forward(self, inputs): inputs, (hx, cx) = inputs x = F.elu(self.linear1(inputs)) hx, cx = self.lstm(x, (hx, cx)) x = hx return self.critic_linear(x), self.actor_linear(x), (hx, cx)
def forward(self, x): assert x.size(2) == 42 and x.size(3) == 42 x = F.elu(self.conv1(x)) x = F.elu(self.conv2(x)) x = F.elu(self.conv3(x)) x = F.elu(self.conv4(x)) x = x.view(x.size(0), -1) x = self.fc(x) return x
def _get_rnn_output(self, input_word, input_char, mask=None, length=None, hx=None): # hack length from mask # we do not hack mask from length for special reasons. # Thus, always provide mask if it is necessary. if length is None and mask is not None: length = mask.data.sum(dim=1).long() # [batch, length, word_dim] word = self.word_embedd(input_word) # [batch, length, char_length, char_dim] char = self.char_embedd(input_char) char_size = char.size() # first transform to [batch *length, char_length, char_dim] # then transpose to [batch * length, char_dim, char_length] char = char.view(char_size[0] * char_size[1], char_size[2], char_size[3]).transpose(1, 2) # put into cnn [batch*length, char_filters, char_length] # then put into maxpooling [batch * length, char_filters] char, _ = self.conv1d(char).max(dim=2) # reshape to [batch, length, char_filters] char = torch.tanh(char).view(char_size[0], char_size[1], -1) # concatenate word and char [batch, length, word_dim+char_filter] input = torch.cat([word, char], dim=2) # apply dropout input = self.dropout_in(input) # prepare packed_sequence if length is not None: seq_input, hx, rev_order, mask = utils.prepare_rnn_seq(input, length, hx=hx, masks=mask, batch_first=True) seq_output, hn = self.rnn(seq_input, hx=hx) output, hn = utils.recover_rnn_seq(seq_output, rev_order, hx=hn, batch_first=True) else: # output from rnn [batch, length, hidden_size] output, hn = self.rnn(input, hx=hx) output = self.dropout_rnn(output) if self.dense is not None: # [batch, length, tag_space] output = F.elu(self.dense(output)) return output, hn, mask, length
def _get_rnn_output(self, input_word, input_char, mask=None, length=None, hx=None): # [batch, length, word_dim] word = self.word_embedd(input_word) # [batch, length, char_length, char_dim] char = self.char_embedd(input_char) char_size = char.size() # first transform to [batch *length, char_length, char_dim] # then transpose to [batch * length, char_dim, char_length] char = char.view(char_size[0] * char_size[1], char_size[2], char_size[3]).transpose(1, 2) # put into cnn [batch*length, char_filters, char_length] # then put into maxpooling [batch * length, char_filters] char, _ = self.conv1d(char).max(dim=2) # reshape to [batch, length, char_filters] char = torch.tanh(char).view(char_size[0], char_size[1], -1) # concatenate word and char [batch, length, word_dim+char_filter] input = torch.cat([word, char], dim=2) # output from rnn [batch, length, hidden_size] output, hn = self.rnn(input, mask, hx=hx) # apply dropout for the output of rnn output = self.dropout_rnn(output.transpose(1, 2)).transpose(1, 2) if self.dense is not None: # [batch, length, tag_space] output = F.elu(self.dense(output)) return output, hn, mask, length
def forward(self, inputs): inputs, (hx, cx) = inputs x = F.elu(self.conv1(inputs)) x = F.elu(self.conv2(x)) x = F.elu(self.conv3(x)) x = F.elu(self.conv4(x)) x = x.view(-1, 32 * 3 * 3) hx, cx = self.lstm(x, (hx, cx)) x = hx return self.critic_linear(x), self.actor_linear(x), (hx, cx)
def test_elu_inplace_view(self): v = Variable(torch.Tensor([1.0, -1.0, 1.0, -1.0]), requires_grad=True) def func(root): x = root.clone() view = x.narrow(0, 1, 2) res = F.elu(view, inplace=True) self.assertIs(res, view) return x gradcheck(func, [v]) gradgradcheck(func, [v])
def test_elu_inplace_gradgrad(self): v = Variable(torch.randn(8), requires_grad=True) def func(root): x = root.clone() return F.elu(x, inplace=True) gradcheck(func, [v]) gradgradcheck(func, [v])
def forward(self, inputs): inputs, (hx, cx) = inputs # print (inputs.size()) x = F.elu(self.conv1(inputs)) x = F.elu(self.conv2(x)) x = F.elu(self.conv3(x)) x = F.elu(self.conv4(x)) # print (x.size()) # x = x.view(-1, 32 * 3 * 3) x = x.view(-1, 32 * 2 * 2) hx, cx = self.lstm(x, (hx, cx)) x = hx return self.critic_linear(x), self.actor_linear(x), (hx, cx)
def elu(x, alpha=1.): def _elu(x, alpha=alpha): return F.elu(x) return get_op(_elu, arguments=[alpha])(x)
def forward(self, inputs): x = F.elu(self.linear1(inputs)) x = F.elu(self.linear2(x)) x = F.elu(self.linear3(x)) return self.actor_linear(x)
def selu(x, inplace=False): alpha = 1.6732632423543772848170429916717 scale = 1.0507009873554804934193349852946 temp1 = scale * F.relu(x) temp2 = scale * alpha * (F.elu(-1*F.relu(-1*x))) return temp1 + temp2
def _get_rnn_output(self, input_word, input_char, input_pos, mask=None, length=None, hx=None): # [batch, length, word_dim] word = self.word_embedd(input_word) # [batch, length, pos_dim] pos = self.pos_embedd(input_pos) # [batch, length, char_length, char_dim] char = self.char_embedd(input_char) char_size = char.size() # first transform to [batch *length, char_length, char_dim] # then transpose to [batch * length, char_dim, char_length] char = char.view(char_size[0] * char_size[1], char_size[2], char_size[3]).transpose(1, 2) # put into cnn [batch*length, char_filters, char_length] # then put into maxpooling [batch * length, char_filters] char, _ = self.conv1d(char).max(dim=2) # reshape to [batch, length, char_filters] char = torch.tanh(char).view(char_size[0], char_size[1], -1) # apply dropout on input word = self.dropout_in(word) pos = self.dropout_in(pos) char = self.dropout_in(char) # concatenate word and char [batch, length, word_dim+char_filter] input = torch.cat([word, char, pos], dim=2) # output from rnn [batch, length, hidden_size] output, hn = self.rnn(input, mask, hx=hx) # apply dropout for output # [batch, length, hidden_size] --> [batch, hidden_size, length] --> [batch, length, hidden_size] output = self.dropout_out(output.transpose(1, 2)).transpose(1, 2) # output size [batch, length, arc_space] arc_h = F.elu(self.arc_h(output)) arc_c = F.elu(self.arc_c(output)) # output size [batch, length, type_space] type_h = F.elu(self.type_h(output)) type_c = F.elu(self.type_c(output)) # apply dropout # [batch, length, dim] --> [batch, 2 * length, dim] arc = torch.cat([arc_h, arc_c], dim=1) type = torch.cat([type_h, type_c], dim=1) arc = self.dropout_out(arc.transpose(1, 2)).transpose(1, 2) arc_h, arc_c = arc.chunk(2, 1) type = self.dropout_out(type.transpose(1, 2)).transpose(1, 2) type_h, type_c = type.chunk(2, 1) type_h = type_h.contiguous() type_c = type_c.contiguous() return (arc_h, arc_c), (type_h, type_c), hn, mask, length
def decode(self, input_word, input_char, input_pos, mask=None, length=None, hx=None, beam=1, leading_symbolic=0, ordered=True): # reset noise for decoder self.decoder.reset_noise(0) # output from encoder [batch, length_encoder, tag_space] # src_encoding [batch, length, input_size] # arc_c [batch, length, arc_space] # type_c [batch, length, type_space] # hn [num_direction, batch, hidden_size] src_encoding, output_enc, hn, mask, length = self._get_encoder_output(input_word, input_char, input_pos, mask_e=mask, length_e=length, hx=hx) # output size [batch, length_encoder, arc_space] arc_c = F.elu(self.arc_c(output_enc)) # output size [batch, length_encoder, type_space] type_c = F.elu(self.type_c(output_enc)) hn = self._transform_decoder_init_state(hn) batch, max_len_e, _ = src_encoding.size() heads = np.zeros([batch, max_len_e], dtype=np.int32) types = np.zeros([batch, max_len_e], dtype=np.int32) children = np.zeros([batch, 2 * max_len_e - 1], dtype=np.int32) stack_types = np.zeros([batch, 2 * max_len_e - 1], dtype=np.int32) for b in range(batch): sent_len = None if length is None else length[b] # hack to handle LSTM if isinstance(hn, tuple): hx, cx = hn hx = hx[:, b, :].contiguous() cx = cx[:, b, :].contiguous() hx = (hx, cx) else: hx = hn[:, b, :].contiguous() preds = self._decode_per_sentence(src_encoding[b], output_enc[b], arc_c[b], type_c[b], hx, sent_len, beam, ordered, leading_symbolic) if preds is None: preds = self._decode_per_sentence(src_encoding[b], output_enc[b], arc_c[b], type_c[b], hx, sent_len, beam, False, leading_symbolic) hids, tids, sent_len, chids, stids = preds heads[b, :sent_len] = hids types[b, :sent_len] = tids children[b, :2 * sent_len - 1] = chids stack_types[b, :2 * sent_len - 1] = stids return heads, types, children, stack_types
