def create_ntee_from_compoents(dir_path): word_dict_path = dir_path + '/dict.word' word_embs_path = dir_path + '/word_embeddings.npy' entity_dict_path = dir_path + '/dict.entity' entity_embs_path = dir_path + '/entity_embeddings.npy' W_path = dir_path + '/W.npy' b_path = dir_path + '/b.npy' print('load voca and embeedings') word_voca, word_embs = utils.load_voca_embs(word_dict_path, word_embs_path) entity_voca, entity_embs = utils.load_voca_embs(entity_dict_path, entity_embs_path) config = { 'word_embeddings': word_embs, 'entity_embeddings': entity_embs, 'word_voca': word_voca, 'entity_voca': entity_voca, 'emb_dims': word_embs.shape[1] } print("word_embs.shape:", word_embs.shape, "entity_embs.shape:", entity_embs.shape) # create model print('create model') model = NTEE(config) W = np.load(W_path) b = np.load(b_path) model.linear.weight = nn.parameter(torch.FloatTensor(W).t()) model.linear.bias = nn.parameter(torch.FloatTensor(b)) return model
def __init__(self, hidden_size): super(Attention, self).__init__() self.weight = nn.parameter(torch.Tensor(hidden_size, hidden_size)) self.weight.data.normal_(mean=0.0, std=0.05) self.bias = nn.parameter(torch.Tensor(hidden_size)) b = np.zeros(hidden_size, dtype=np.float32) self.bias.data.copy_(torch.from_numpy(b)) self.query = nn.Parameter(torch.Tensor(hidden_size)) self.query.data.normal_(mean=0.0, std=0.05)
def __init__(self, channels: int, eps: float=1e-5, affine: bool=True, momentum: float=0.1, ema: bool=True): super.__init__() self.channels = channels self.eps = eps self.momentum = momentum self.ema = ema if self.ema: self.register_buffer('ema_mean', torch.zeros(self.channels)) self.register_buffer('ema_var', torch.ones(self.channels)) if self.affine: self.scale = nn.parameter(torch.ones(self.channels)) self.shift = nn.parameter(torch.zeros(self.channels))
def __init__(self, args, label_number=10): super(NoiseCorrectionLoss, self).__init__() self.big_table = nn.parameter(torch.zeros((label_number, 2))) self.args = args self.classification_loss = ClassificationNoiseCorrectionLoss()
def __init__(self, d_input, d_attn): ''' d_input: the video feature size d_attn: the attn size used in the attention calculation ''' super(StepTopDownAttention, self).__init__() self.w_a = nn.parameter(torch.Tensor(d_attn)) self.f_a = GatedTanhLayer(d_input, d_attn)
def __init__(self, input_dim, out_dim, use_bias=True): super(GraphConvolution, self).__init__() self.input_dim = input_dim self.output_dim = out_dim self.use_bias = use_bias self.weight = nn.Parameter(torch.Tensor(input_dim, out_dim)) if self.use_bias: self.bias = nn.parameter(torch.Tensor(out_dim)) else: self.register_parameter('bias', None) self.reset_parameters()
def __init__(self, hidden_size, method='dot'): super(GlobalAttention, self).__init__() self.hidden_size = hidden_size self.method = method if self.method not in ['dot', 'general', 'concat']: raise ValueError("please input correct method for attention score") if self.method == 'general': self.w_general = nn.Linear(hidden_size, hidden_size) elif self.method == 'concat': self.w_concat = nn.Linear(hidden_size * 2, hidden_size) self.v_concat = nn.parameter(torch.FloatTensor(hidden_size))
def __init__(self, options, weights = None): super(Attention, self).__init__() self.n_encoder = options['n_encoder'] self.n_decoder = options['n_decoder'] self.n_att = options['n_att'] self.layer_en = nn.Linear(self.n_encoder, self.n_att) self.layer_de = nn.Linear(self.n_decoder, self.n_att, bias = False) self.layer_att = nn.Linear(self.n_att, 1) if weights is not None: self.layer_en.weights = nn.Parameter(weights[0]) self.layer_de.weights = nn.Parameter(weights[1]) self.layer_att.weights = nn.parameter(weights[2]) self.fixed = options['fixed'] if self.fixed: self.layer_en.weight.requires_grad = False self.layer_de.weight.requires_grad = False self.layer_att.weight.requires_grad = False
def __init__(self, capsule_num, route_nodes_num, input_channels, output_channels, kernel_size=None, stride=None, iterations=3): super(CapsLayer, self).__init__() self.iterations = iterations self.output_channels = output_channels self.input_channels = input_channels self.route_nodes_num = route_nodes_num self.capsule_num = capsule_num if self.route_nodes_num != -1: #this is digit caps, assign weights for that layer self.weights = nn.parameter( torch.randn(self.capsule_num, self.route_nodes_num, self.input_channels, self.output_channels)) else: #this is primary caps convLayers = [] for i in range(self.capsule_num): convLayers.append( nn.Conv2d(self.input_channels, self.output_channels, kernel_size=kernel_size, stride=stride, padding=0)) self.capsules = convLayers
def __init__(self, lc, lp, lq): super(STResNet, self).__init__() self.wc = nn.Parameter(torch.ones((lc, 20, 20))) self.wp = nn.parameter(torch.ones((lp, 20, 20))) self.wq = nn.Parameter(torch.ones((lq, 20, 20))) pass
def __init__(self, in_features, scale): super(L2Norm, self).__init__() self.weight = nn.parameter(torch.Tensor(in_features)) self.reset_parameter(scale)
def __init__(self, train_beta=False): super(Swish, self).__init__() if train_beta: self.weight = nn.parameter(torch.Tensor([1.])) else: self.weight = 1.0
def __init__(self, input_size, hidden_size): super().__init__() self.input_size_ = input_size self.hidden_size_ = hidden_size #Gate for input self.wii = parameter(torch.Tensor(input_size, hidden_size)) self.whi = parameter(torch.Tensor(hidden_size, hidden_size)) self.bi = parameter(torch.Tensor(hidden_size)) #gate for output self.wio = parameter(torch.Tensor(input_size, hidden_size)) self.who = parameter(torch.Tensor(hidden_size, hidden_size)) self.bo = parameter(torch.Tensor(hidden_size)) #gate for forget self.wif = parameter(torch.Tensor(input_size, hidden_size)) self.whf = parameter(torch.Tensor(hidden_size, hidden_size)) self.bf = parameter(torch.Tensor(hidden_size)) #info carried self.wig = parameter(torch.Tensor(input_size, hidden_size)) self.whg = parameter(torch.Tensor(hidden_size, hidden_size)) self.bg = parameter(torch.Tensor(hidden_size))
def __init__(self, features, eps=1e-6): super(LayerNorm, self).__init__() self.a_2 = nn.parameter(torch.ones(features)) self.b_2 = nn.parameter(torch.zeros(features)) self.eps = eps