def __init__(self, size: int, self_attn: torch.nn.Module, feed_forward: torch.nn.Module, dropout: float) -> None: super().__init__() self.self_attn = self_attn self.feed_forward = feed_forward self.sublayer = util.clone(SublayerConnection(size, dropout), 2) self.size = size
def __init__(self, vocab: Vocabulary, encoder: Seq2SeqEncoder, yingshe_encoder: Seq2SeqEncoder, attention_decoder: MatrixAttention, regularizer: Optional[RegularizerApplicator] = None) -> None: super().__init__(vocab, regularizer) self.encoder = encoder self.decoder_start_list = clone(attention_decoder, len(defaults.relation2id)) self.decoder_end_list = clone(attention_decoder, len(defaults.relation2id)) self.yingshe_encoder_list = clone(yingshe_encoder, 2) self.valid_metric = SanyuanzuMetric() #TODO()如果验证还是很低,则考虑添加一个新的metric来查看预测的准确率 self.flag = True
def __init__( self, layer: torch.nn.Module, num_layers: int, return_all_layers: bool = False ) -> None: super().__init__() self.layers = util.clone(layer, num_layers) self.norm = LayerNorm(layer.size) self.return_all_layers = return_all_layers
def __init__(self, num_heads: int, input_dim: int) -> None: super(MultiHeadedAttentionWithAttention, self).__init__() assert input_dim % num_heads == 0, "input_dim must be a multiple of num_heads" # assume d_v equals d_k self.d_k = input_dim // num_heads self.num_heads = num_heads # These linear layers project from d_model to h*d_k self.linears = util.clone(nn.Linear(input_dim, input_dim, bias=False), 4)
def __init__( self, vocab: Vocabulary, encoder: Seq2SeqEncoder, one_decoder: Seq2SeqEncoder, many_decoder: Seq2SeqEncoder, span_extractor: SpanExtractor, # to determine mode: str, regularizer: Optional[RegularizerApplicator] = None) -> None: super().__init__(vocab, regularizer) self.encoder = encoder self.one_decoder_list = clone(one_decoder, 2) self.many_decoder_list = clone(many_decoder, 2) self.span_extractor = span_extractor self.valid_metric = SanyuanzuMetric() assert mode in ['s2po', 'o2ps'] self.mode = mode self.flag = True
def __init__(self, num_heads: int, input_dim: int, dropout: float = 0.1) -> None: super().__init__() assert input_dim % num_heads == 0, "input_dim must be a multiple of num_heads" # We assume d_v always equals d_k self.d_k = input_dim // num_heads self.num_heads = num_heads # These linear layers are # [query_projection, key_projection, value_projection, concatenated_heads_projection] self.linears = util.clone(torch.nn.Linear(input_dim, input_dim), 4) self.dropout = torch.nn.Dropout(p=dropout)
def __init__(self, num_heads: int, input_dim: int, dropout: float = 0.1) -> None: super().__init__() assert input_dim % num_heads == 0, "input_dim must be a multiple of num_heads" # We assume d_v always equals d_k self.d_k = input_dim // num_heads self.num_heads = num_heads # These linear layers are # [query_projection, key_projection, value_projection, concatenated_heads_projection] self.linears = util.clone(torch.nn.Linear(input_dim, input_dim), 4) self.dropout = torch.nn.Dropout(p=dropout)
def __init__(self, size: int, self_attn: torch.nn.Module, feed_forward: torch.nn.Module, dropout: float) -> None: super().__init__() self.self_attn = self_attn self.feed_forward = feed_forward self.sublayer = util.clone(SublayerConnection(size, dropout), 2) self.size = size
def __init__( self, vocab: Vocabulary, encoder: Seq2SeqEncoder, first_decoder: Seq2SeqEncoder, second_decoder: Seq2SeqEncoder, third_decoder: Seq2VecEncoder, span_extractor: SpanExtractor, # to determine mode: str, regularizer: Optional[RegularizerApplicator] = None) -> None: super().__init__(vocab, regularizer) self.encoder = encoder self.first_decoder_list = clone(first_decoder, 2) self.second_decoder_list = clone(second_decoder, 2) self.thrid_decoder = third_decoder # 仅作关系判别 self.span_extractor_list = clone(span_extractor, 2) self.valid_metric = SanyuanzuMetric() assert mode in ['sop', 'osp'] self.mode = mode self.flag = True
def __init__(self, self_attn: MultiHeadedAttentionWithAttention, context_attn: MultiHeadedAttentionWithAttention, query_attn: MultiHeadedAttentionWithAttention, feed_forward: F, d_model: int, dropout_rate: float) -> None: super(RWDecoderLayer, self).__init__() self.self_attn = self_attn self.context_attn = context_attn self.query_attn = query_attn self.linear = nn.Linear(2 * d_model, d_model, bias=False) self.feed_forward = feed_forward self.norms = util.clone(nn.LayerNorm(d_model, eps=1e-6), 3) self.dropout = nn.Dropout(dropout_rate)
def __init__( self, size: int, self_attn: MultiHeadedAttention, src_attn: MultiHeadedAttention, feed_forward: F, dropout: float, ) -> None: super().__init__() self.size = size self.self_attn = self_attn self.src_attn = src_attn self.feed_forward = feed_forward self.sublayer = nn_util.clone(SublayerConnection(size, dropout), 3)
def __init__(self, num_heads: int, input_dim: int, width: int, left_to_right: bool, dropout: float = 0.1) -> None: super().__init__() assert input_dim % num_heads == 0, "input_dim must be a multiple of num_heads" # We assume d_v always equals d_k self.d_k = input_dim // num_heads self.num_heads = num_heads self.width = width self.left_to_right = left_to_right # These linear layers are # [query_projection, key_projection, value_projection, concatenated_heads_projection] self.linears = clone(torch.nn.Linear(input_dim, input_dim), 4) self.rel_pos_embeddings = torch.nn.Parameter( torch.randn(num_heads, width + 1, self.d_k) / np.sqrt(self.d_k)) self.dropout = torch.nn.Dropout(p=dropout)
def __init__(self, word_embeddings: TextFieldEmbedder, encoder: Seq2VecEncoder, vocab: Vocabulary) -> None: # We have to pass the vocabulary to the constructor. super().__init__(vocab) self.word_embeddings = word_embeddings # Our model has different encoders for each of the fields (passage, # answer and question). These could theoretically be different for each # field, but for now we're using the same. Hence, we clone the provided # encoder. self.p_encoder, self.q_encoder, self.a_encoder = util.clone(encoder, 3) # We're using a hidden layer to build the output from each encoder. # As this can't really change, it's not passed as input. # The size has to be the size of concatenating the encoder outputs, # since that's how we're combining them in the computation. As they're # the same, just multiply the first encoder output by 3. # The output of the model (which is the output of this layer) has to # have size equal to the number of classes. hidden_dim = self.p_encoder.get_output_dim() * 4 self.hidden2logit = torch.nn.Linear( in_features=hidden_dim, out_features=vocab.get_vocab_size('label'))
def __init__(self, layer: nn.Module, num_layers: int) -> None: super().__init__() self.layers = nn_util.clone(layer, num_layers) self.norm = LayerNorm(layer.size)
def __init__(self, layer: torch.nn.Module, num_layers: int) -> None: super().__init__() self._layers = util.clone(layer, num_layers) self._norm = LayerNorm(layer._size)
def __init__(self, layer: nn.Module, num_layers: int) -> None: super(RWDecoder, self).__init__() self.layers = util.clone(layer, num_layers)
def __init__(self, layer: torch.nn.Module, num_layers: int, return_all_layers: bool = False) -> None: super().__init__() self.layers = util.clone(layer, num_layers) self.norm = LayerNorm(layer.size) self.return_all_layers = return_all_layers