def call_Decoder(self,nlayer,Elt_state,\ Rlt_top,Rlt_state,epoch): # h = hidden layers R_lt_next = None Elt_state_in = None Decode_lt = None # return hidden layers size: h_l_down_in, h_l_top_out,\ h_l_down_out, h_Elt = self.hidden_layers_selctor(nlayer) if Elt_state is None: Elt_state_in = self.get_init_Elt_tensor(self.error_states[nlayer + 1]) else: Elt_state_in = Elt_state if Rlt_top is None: Decode_lt = Decoder(h_Elt, 0, h_l_down_out,\ self.kernel_size).cuda() Elt_state = self.get_init_Elt_tensor(self.error_states[nlayer + 1]) R_lt_next = Decode_lt(Elt_state_in, None, None) else: Decode_lt = Decoder(h_Elt, Rlt_top.data.size()[1],\ h_l_top_out,self.kernel_size).cuda() R_lt_next = Decode_lt(Elt_state_in,\ Rlt_top,Rlt_state) if self.saveModel == True: if epoch % self.numSaveIter == 0: self.save_models(Decode_lt, epoch, "Decoder") return R_lt_next, Decode_lt.parameters()
def __init__(self, w2i, i2w, embs=None, title_emb = None, info=None): """ Args: args: parameters of the model textData: the dataset object """ super(LSTM_CTE_Model_with_action, self).__init__() print("Model creation...") self.word2index = w2i self.index2word = i2w self.max_length = args['maxLengthDeco'] self.info = info self.NLLloss = torch.nn.NLLLoss(ignore_index=0) self.CEloss = torch.nn.CrossEntropyLoss(ignore_index=0) if embs is not None: self.embedding = nn.Embedding.from_pretrained(embs) else: self.embedding = nn.Embedding(args['vocabularySize'], args['embeddingSize']) if title_emb is not None: self.field_embedding = nn.Embedding.from_pretrained(title_emb) else: self.field_embedding = nn.Embedding(args['TitleNum'], args['embeddingSize']) self.encoder = Encoder(w2i, i2w, bidirectional=True) # self.encoder_answer_only = Encoder(w2i, i2w) self.encoder_no_answer = Encoder(w2i, i2w) self.encoder_pure_answer = Encoder(w2i, i2w) self.decoder_answer = Decoder(w2i, i2w, self.embedding, copy='pure', max_dec_len=10) self.decoder_no_answer = Decoder(w2i, i2w, self.embedding, input_dim = args['embeddingSize']*2,# + args['hiddenSize'] , copy='semi') self.ansmax2state_h = nn.Linear(args['embeddingSize'], args['hiddenSize']*2, bias=False) self.ansmax2state_c = nn.Linear(args['embeddingSize'], args['hiddenSize']*2, bias=False) self.tanh = nn.Tanh() self.relu = nn.ReLU() self.softmax = nn.Softmax(dim=-1) self.sigmoid = nn.Sigmoid() self.att_size_r = 60 # self.grm = GaussianOrthogonalRandomMatrix() # self.att_projection_matrix = Parameter(self.grm.get_2d_array(args['embeddingSize'], self.att_size_r)) self.M = Parameter(torch.randn([args['embeddingSize'], args['hiddenSize']*2,2])) self.shrink_copy_input= nn.Linear(args['hiddenSize']*2, args['hiddenSize'], bias=False) self.emb2hid = nn.Linear(args['embeddingSize'], args['hiddenSize'], bias=False)
def build_decoder(self): decoder = Decoder(input_size=self.input_size, hidden_size=self.sentiment_size, vocab_size=self.vocab_size, max_len=self.max_len, embedding=self.embedding) return decoder
def __init__(self, n_blocks, d_model, d_feature, d_ff, dropout, d_vocab_in, d_vocab_out, max_seq_len=512): '''n_blocks: number of encoder and decoder blocks. d_model: Size of word feature vector d_feature: size of attn head input feature d_ff: size between linear layers''' super(Transformer, self).__init__() self.encoder = Encoder(n_blocks, d_model, d_feature, d_ff, dropout, max_seq_len=512) self.decoder = Decoder(n_blocks, d_model, d_feature, d_ff, dropout, max_seq_len=512) self.encoder_embed = nn.Embedding(d_vocab_in, d_model) self.decoder_embed = nn.Embedding(d_vocab_out, d_model) self.linear = nn.Linear(d_model, d_vocab_out)
def __init__(self, mem_size: int = 10000): """ The following is an abstraction for a bank of values such as valA, which will be used during each cycle. It's set up as an object to avoid circular import. """ self.ValBank = ValBank() """ The following are functional units like memory, registers, or flags """ self.Memory = Memory(mem_size) self.RegisterBank = RegisterBank() self.ZF = CCFlag("ZF") # zero flag self.OF = CCFlag("OF") # overflow flag self.SF = CCFlag("SF") # sign flag self.ErrorFlag = StateFlag("Error Flag", error_lib) self.StateFlag = StateFlag("State Flag", state_lib) self.ALU = ALU(self.ValBank, self.StateFlag, self.ErrorFlag, self.SF, self.OF, self.ZF) """ The following are functional abstractions of operations that the processor performs """ self.Fetcher = Fetcher(self.ValBank, self.RegisterBank, self.Memory, self.StateFlag, self.ErrorFlag) self.Decoder = Decoder(self.ValBank, self.RegisterBank, self.Memory) self.Executor = Executor(self.ValBank, self.ALU, self.OF, self.ZF, self.SF) self.Memorizer = Memorizer(self.ValBank, self.Memory) self.RegWriter = RegWriter(self.RegisterBank, self.ValBank) self.PCUpdater = PCUpdater(self.RegisterBank, self.ValBank)
def __init__(self, input_size, hidden_size, batch_size, learning_rate, num_epoch, method): dataset = Seq2SeqDataset() self.vocab = sorted(set(dataset.full_text)) self.vocab_size = len(self.vocab) self.char2ind, self.ind2char = self.get_vocab() self.input_size = input_size self.hidden_size = hidden_size self.output_size = self.vocab_size self.method = method self.learning_rate = learning_rate self.batch_size = batch_size self.num_epoch = num_epoch self.device = "cuda:0" if torch.cuda.is_available() else "cpu" self.dataloader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=True) self.encoder = Encoder(input_size, hidden_size, self.vocab_size) self.decoder = Decoder(hidden_size, self.output_size, method) self.encoder = self.encoder.to(self.device) self.decoder = self.decoder.to(self.device) self.loss_function = NLLLoss() self.encoder_optim = optim.Adam(self.encoder.parameters(), lr=self.learning_rate) self.decoder_optim = optim.Adam(self.decoder.parameters(), lr=self.learning_rate)
def __init__(self, config): super(Model, self).__init__() self.config = config # 定义嵌入层 self.embedding = Embedding( config.num_vocab, # 词汇表大小 config.embedding_size, # 嵌入层维度 config.pad_id, # pad_id config.dropout) # post编码器 self.post_encoder = Encoder( config.post_encoder_cell_type, # rnn类型 config.embedding_size, # 输入维度 config.post_encoder_output_size, # 输出维度 config.post_encoder_num_layers, # rnn层数 config.post_encoder_bidirectional, # 是否双向 config.dropout) # dropout概率 # response编码器 self.response_encoder = Encoder( config.response_encoder_cell_type, config.embedding_size, # 输入维度 config.response_encoder_output_size, # 输出维度 config.response_encoder_num_layers, # rnn层数 config.response_encoder_bidirectional, # 是否双向 config.dropout) # dropout概率 # 先验网络 self.prior_net = PriorNet( config.post_encoder_output_size, # post输入维度 config.latent_size, # 潜变量维度 config.dims_prior) # 隐藏层维度 # 识别网络 self.recognize_net = RecognizeNet( config.post_encoder_output_size, # post输入维度 config.response_encoder_output_size, # response输入维度 config.latent_size, # 潜变量维度 config.dims_recognize) # 隐藏层维度 # 初始化解码器状态 self.prepare_state = PrepareState( config.post_encoder_output_size + config.latent_size, config.decoder_cell_type, config.decoder_output_size, config.decoder_num_layers) # 解码器 self.decoder = Decoder( config.decoder_cell_type, # rnn类型 config.embedding_size, # 输入维度 config.decoder_output_size, # 输出维度 config.decoder_num_layers, # rnn层数 config.dropout) # dropout概率 # 输出层 self.projector = nn.Sequential( nn.Linear(config.decoder_output_size, config.num_vocab), nn.Softmax(-1))
def __init__(self, vocab_size, embed_size, hidden_size, choose_model, use_gpu, gpu_id): # gpu Setting model = Alex_RNNLM(hidden_size) if choose_model == "Alex_RNNLM": model = Alex_RNNLM(hidden_size) if choose_model == "AlexBn_RNNLM": model = AlexBn_RNNLM(hidden_size) if use_gpu: cuda.get_device(gpu_id).use() model.to_gpu() # Setting Model super(EncoderDecoderAttention, self).__init__( enc=model, im1=links.Linear(IM_SIZE, RESIZE_IM_SIZE), im2=links.Linear(IM_SIZE, RESIZE_IM_SIZE), im3=links.Linear(IM_SIZE, RESIZE_IM_SIZE), att=Attention(hidden_size, RESIZE_IM_SIZE), outay=links.Linear(hidden_size, hidden_size), dec=Decoder(vocab_size, embed_size, hidden_size), ) self.vocab_size = vocab_size self.embed_size = embed_size self.hidden_size = hidden_size self.common_function = CommonFunction() self.use_gpu = use_gpu self.gpu_id = gpu_id self.choose_model = choose_model self.__set_gpu()
def __network(self): """ Define the VAE network """ # Network Construction begins here with tf.variable_scope(self.__scope): # encoder encoder_input = tf.concat([self.depth_map_input, self.foreground_map_input, self.normal_map_input], axis=3) encoder_input = tf.transpose(encoder_input, perm=[0, 3, 1, 2]) # [?, 5, 256, 256] encoder = Encoder(encoder_input/self.__NORMALIZATION_FACTOR, 3, self.__downsampling_factor, self.__width_multiplier, self.__weight_decay, self.__dropout_keep_prob, self.__batchnorm, self.__batchnorm_decay, self.__is_training, self.__data_format, self.__latent_dim) self.z_mu = encoder.shape_mu # [?, latent_dim] self.z_logvar = encoder.shape_logvar # [?, latent_dim] # reparameterization eps = tf.random_normal(shape=tf.shape(self.z_mu), mean=0, stddev=0.01, dtype=tf.float32) # [?, latent_dim] self.z = tf.add(self.z_mu, tf.multiply(tf.sqrt(tf.exp(self.z_logvar)), eps)) # [?, latent_dim] # decoder z = tf.expand_dims(self.z, 1) decoder_input = tf.tile(z, multiples=[1, self.__num_sample_points, 1]) # [?, K, latent_dim] decoder_input = tf.concat([decoder_input, self.samples], axis=2) # [?, K, latent_dim+3] decoder = Decoder(decoder_input) # output sdf values self.sdf_pred = decoder.end_point
def __init__(self, w2i, i2w): """ Args: args: parameters of the model textData: the dataset object """ super(Model, self).__init__() print("Model creation...") self.word2index = w2i self.index2word = i2w self.max_length = args['maxLengthDeco'] self.dtype = 'float32' self.NLLloss = torch.nn.NLLLoss(reduction='none') self.CEloss = torch.nn.CrossEntropyLoss(reduction='none') self.embedding = nn.Embedding(args['vocabularySize'], args['embeddingSize']) self.emo_embedding = nn.Embedding(args['emo_labelSize'], args['embeddingSize']) self.encoder = Encoder(w2i, i2w, self.embedding) self.decoder = Decoder(w2i, i2w, self.embedding) self.tanh = nn.Tanh() self.softmax = nn.Softmax(dim=-1)
def train(iterations, train_file, beam_size): data = prepare_data.read_file(train_file) feature = Feature() decoder = Decoder(beam_size, feature.get_score) for t in range(iterations): count = 0 data_size = len(data) for line in data: y = line.split() z = decoder.beamSearch(line) if z != y: feature.update_weight(y, z) train_seg = ' '.join(z) seg_data_file = '/home/xzt/CWS/train_seg_data/train-seg-data_ model-' + str( t) + '.txt' with open(seg_data_file, 'a') as f: f.write(train_seg + '\n') count += 1 if count % 1000 == 0: print("iter %d , finish %.2f%%" % (t, (count / data_size) * 100)) model_file = open( "/home/xzt/CWS/model_result/model-" + str(t) + "_beam-size-" + str(beam_size) + '.pkl', 'wb') feature.save_model(model_file) model_file.close() f.close() print("segment with model-%d finish" % t) print("iteration %d finish" % t)
def generate_data(filename, version, block_size=16): input_path = os.path.join(PGM_ORIGINAL_PATH, filename + PGM_SUFFIX) if not os.path.exists(BITSTREAM_PATH): os.mkdir(BITSTREAM_PATH) bitstream_path = os.path.join(BITSTREAM_PATH, filename + BITSTREAM_SUFFIX) if not os.path.exists(PGM_RECONSTRUCTION_PATH): os.mkdir(PGM_RECONSTRUCTION_PATH) output_path = os.path.join(PGM_RECONSTRUCTION_PATH, filename + PGM_SUFFIX) df = pd.DataFrame(columns=['bpp', 'db']) for index, quality in enumerate([8, 12, 16, 20, 24]): enc = Encoder(input_path, bitstream_path, block_size, quality, False) enc.encode_image() dec = Decoder(bitstream_path, output_path, pgm=True) dec.decode_all_frames() process = subprocess.run( [PSNR_TOOL_PATH, input_path, output_path, bitstream_path], stdout=subprocess.PIPE, ) stdout = process.stdout.decode("utf-8") bpp, db = stdout.split(' bpp ') bpp, db = float(bpp), float(db.replace(' dB', '')) db = 0.0 if math.isinf(db) else db df.loc[index] = [bpp, db] version_path = os.path.join(DATA_ROOT_PATH, version) print(version) if not os.path.exists(version_path): os.mkdir(version_path) df.to_pickle(os.path.join(version_path, filename + DATA_SUFFIX))
def __init__(self, config: Config): super().__init__() self.cfg = config self.encoder = Encoder(config) # 编码器 self.decoder = Decoder(config) # 解码器 self.final_layer = tf.keras.layers.Dense( config.target_vocab_size) # 最后输出层
def test_avg(iterations, test_file, beam_size): data = prepare_data.read_file(test_file) feature = Feature() decoder = Decoder(beam_size, feature.get_score) count = 0 data_size = len(data) model_file = open( '/home/xzt/CWS/model_result/avg-model_beam-size-' + str(beam_size) + '.pkl', 'rb') feature.load_model(model_file) model_file.close() for line in data: z = decoder.beamSearch(line) seg_data = ' '.join(z) seg_data_file = '/home/xzt/CWS/test_seg_data/avg-test-seg-data' + '_beam-size-' + str( beam_size) + '.txt' with open(seg_data_file, 'a') as f: f.write(seg_data + '\n') count += 1 if count % 1000 == 0: print("segment with avg-model, finish %.2f%%" % ((count / data_size) * 100)) f.close() print("segment with avg model finish")
def __init__(self, vocab_size, max_len, device, num_layers=6, stack_layers=6, d_model=512, num_heads=8, ffn_dim=2048, dropout=0.2): super(Transformer, self).__init__() self.device = device self.encoder = Encoder(vocab_size, max_len, num_layers, d_model, num_heads, ffn_dim, dropout) self.decoder = Decoder(vocab_size, max_len, device, num_layers, d_model, num_heads, ffn_dim, dropout) self.generator = Generator(vocab_size, max_len, device, stack_layers, d_model, num_heads, ffn_dim, dropout) self.embedding = nn.Embedding(vocab_size, d_model) self.linear = nn.Linear(d_model, vocab_size, bias=False) self.softmax = nn.Softmax(dim=2)
def predict(self, y, phi_gmm, encoder_layers, decoder_layers, seed=0): """ Args: y: data to cluster and reconstruct phi_gmm: latent phi param encoder_layers: encoder NN architecture decoder_layers: encoder NN architecture seed: random seed Returns: reconstructed y and most probable cluster allocation """ nb_samples = 1 phi_enc_model = Encoder(layerspecs=encoder_layers) phi_enc = phi_enc_model.forward(y) x_k_samples, log_r_nk, _, _ = e_step(phi_enc, phi_gmm, nb_samples, seed=0) x_samples = subsample_x(x_k_samples, log_r_nk, seed)[:, 0, :] y_recon_model = Decoder(layerspecs=decoder_layers) y_mean, _ = y_recon_model.forward(x_samples) return (y_mean, torch.argmax(log_r_nk, dim=1))
def __init__(self, in_channels, hidden_channels, num_resblocks, res_channels, D, K, beta=0.25, gamma=0.99): """ in_channels: number of channels of the input image hidden_channels: the number of channels that are used by the hidden conv layers num_resblocks: the number of residual blocks used in both the encoder and the decoder res_channels: the number of channels that are used by the residual blocks D: dimensionality of each embedding vector, or embedding_dim in the sonnet's implementation K: the size of the discrete space (the number of embedding vectors), or num_embeddings in the sonnet's implementation beta: the hyperparameter that acts as a weighting to the lost term, or commitment_cost in the sonnet's implementation recommendation from the paper, beta=0.25 gamma: controls the speed of the EMA, or decay in the sonnet's implementation recommendation from the paper, gamma=0.99 """ super(VQVAE, self).__init__() self.encoder = Encoder(in_channels, hidden_channels, num_resblocks, res_channels) # the following is the additional layer added in the author's original implementation # to make sure that the number of channels equals to D (embedding dimension) self.pre_vq = nn.Conv2d(in_channels=hidden_channels, out_channels=D, kernel_size=1, stride=1) self.vectorquantizer = VectorQuantizerEMA(D, K, beta, gamma) self.decoder = Decoder(D, hidden_channels, num_resblocks, res_channels, in_channels)
def test_folder(folder): """ Test all images inside a folder Use Zbar library to test the image. Args: folder: The path of your target folder Returns: (succ, fail, rate): The number of success, failure, and the "success rate" = (succ) / (succ + fail) """ def is_img(path): # Add more extensions if you need img_ext = ['jpg', 'png', 'bmp'] return path.split('.')[-1] in img_ext dc = Decoder() for root, folders, files in os.walk(folder): img_list = [os.path.join(root, file) for file in files if is_img(file)] succ = fail = 0 for img in img_list: pil = Image.open(img).convert('L') code = dc.decode(pil) if len(code) > 0: succ += 1 else: fail += 1 rate = float(succ) / (succ + fail) return (succ, fail, rate)
def __init__(self, args): super(Mem2SeqRunner, self).__init__(args) # Model parameters self.gru_size = 128 self.emb_size = 128 #TODO: Try hops 4 with task 3 self.hops = 3 self.dropout = 0.2 self.encoder = Encoder(self.hops, self.nwords, self.gru_size) self.decoder = Decoder(self.emb_size, self.hops, self.gru_size, self.nwords) self.optim_enc = torch.optim.Adam(self.encoder.parameters(), lr=0.001) self.optim_dec = torch.optim.Adam(self.decoder.parameters(), lr=0.001) if self.loss_weighting: self.optim_loss_weights = torch.optim.Adam([self.loss_weights], lr=0.0001) self.scheduler = lr_scheduler.ReduceLROnPlateau(self.optim_dec, mode='max', factor=0.5, patience=1, min_lr=0.0001, verbose=True) if self.use_cuda: self.cross_entropy = self.cross_entropy.cuda() self.encoder = self.encoder.cuda() self.decoder = self.decoder.cuda() if self.loss_weighting: self.loss_weights = self.loss_weights.cuda()
def __build(self): self.encoder = Encoder(self.src_vocab_size, self.src_emb_dim, self.enc_units) self.decoder = Decoder(self.tgt_vocab_size, self.tgt_emb_dim, self.enc_units, self.dec_units, self.att_units, self.score_type) self.sess = tf.Session()
def make_model(src_vocab, tgt_vocab, N=6, d_model=512, d_ff=2048, h=8, dropout=0.1): "Helper: Construct a model from hyperparameters." c = copy.deepcopy attn = MultiHeadedAttention(h, d_model) ff = PositionwiseFeedForward(d_model, d_ff, dropout) position = PositionalEncoding(d_model, dropout) model = EncoderDecoder( Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N), Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout), N), nn.Sequential(Embeddings(d_model, src_vocab), c(position)), nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)), Generator(d_model, tgt_vocab)) # This was important from their code. # Initialize parameters with Glorot / fan_avg. for p in model.parameters(): if p.dim() > 1: nn.init.xavier_uniform_(p) """https://zhuanlan.zhihu.com/p/74274453 #權值初始化 Xavier均勻分佈""" return model
def __init__(self, vocab_size, embed_size, hidden_size, choose_model, use_gpu, gpu_id): # gpu Setting model = Alex_RNNLM(hidden_size) if choose_model == "Alex_RNNLM": model = Alex_RNNLM(hidden_size) if choose_model == "AlexBn_RNNLM": model = AlexBn_RNNLM(hidden_size) if use_gpu: cuda.get_device(gpu_id).use() model.to_gpu() # Setting Model super(EncoderDecoder, self).__init__( enc=model, dec=Decoder(vocab_size, embed_size, hidden_size), ) self.vocab_size = vocab_size self.embed_size = embed_size self.hidden_size = hidden_size self.common_function = CommonFunction() self.use_gpu = use_gpu self.gpu_id = gpu_id self.choose_model = choose_model self.__set_gpu()
def encoder_decoder(self, inputs): encoded = self.encoder.encoder(inputs, self.target_layer) model = Decoder() decoded, _ = model.decoder(encoded, self.target_layer) decoded_encoded = self.encoder.encoder(decoded, self.target_layer) return encoded, decoded, decoded_encoded
def __init__(self, src_vocab_size: int, tgt_vocab_size: int, encoder_layer_num: int, decoder_layer_num: int, hidden_size: int, feedback_size: int, num_head: int, dropout: float, device: str): super().__init__() self.Encoder = Encoder(src_vocab_size, num_encoder_layer=encoder_layer_num, hidden_size=hidden_size, num_head=num_head, feedward=feedback_size, dropout=dropout, device=device) self.Decoder = Decoder(tgt_vocab_size, num_layer=decoder_layer_num, hiddensize=hidden_size, num_head=num_head, feed_back=feedback_size, dropout=dropout, device=device) Encoder_layer = TransformerEncoderLayer(nhead=8, d_model=512) self.Encoder_off = TransformerEncoder(encoder_layer=Encoder_layer, num_layers=6) Decoder_layer = TransformerDecoderLayer(nhead=8, dim_feedforward=2048, d_model=512) self.Decoder_off = TransformerDecoder(decoder_layer=Decoder_layer, num_layers=6) self.model = tf() self.device = device self.input_embedding = torch.nn.Embedding(src_vocab_size, 512) self.output_embedding = torch.nn.Embedding(tgt_vocab_size, 512) self.positional = Positional_Encoding(512, 512, device) self.linear = torch.nn.Linear(512, tgt_vocab_size)
def __init__(self, cells, heads, seq_len_enc, seq_len_dec, attention_dimensions, vocab_size): super().__init__() self.encoder = Encoder(cells, heads, seq_len_enc, attention_dimensions).to(device) self.decoder = Decoder(cells, heads, seq_len_dec, attention_dimensions, vocab_size).to(device)
def encoder_decoder(self, inputs): encoded = self.encoder.encoder(inputs, self.target_layer) #特征提取 model = Decoder() #生成图像model decoded, _ = model.decoder(encoded, self.target_layer) #生成图像 # 再对生成图像,进行特征提取 decoded_encoded = self.encoder.encoder(decoded, self.target_layer) # 返回值为 a.提取的特征 b.由特征生成的图片 c.由生成图片提取的特征 return encoded, decoded, decoded_encoded
def __init__(self, vocab_size, eos_id=1): super(Seq2Seq, self).__init__() self.vocab_size = vocab_size self.eos_id = eos_id self.encoder = ResNet18(128) self.decoder = Decoder(vocab_size=self.vocab_size, num_layers=0, name='ctc_layer2')
def aptidao(self, cromossomo): decodificacao = Decoder(self.custos, sqrt(self.TAM_CROM)) ''' Transforma as chaves aleatorias em binarios, verifica as restrições e retorna o custo a ser minimizado ''' Z = decodificacao.decode(cromossomo) return Z
def __init__(self, options): super(model, self).__init__() self.enc = UtteranceEncoder(options) self.kvmlookup = KVMemoryReader(options) self.inter_utter_encoder = InterUtteranceEncoder( options.ut_hid_size, options.ut_hid_size, options) self.dec = Decoder(options, options.response_vocab_size) self.kg_predict = KG_embedding(options)
def __init__(self, vocab_size, embed_size, hidden_size): super(EncoderDecoder, self).__init__( enc=Encoder(vocab_size, embed_size, hidden_size), dec=Decoder(vocab_size, embed_size, hidden_size), ) self.vocab_size = vocab_size self.embed_size = embed_size self.hidden_size = hidden_size self.common_function = CommonFunction()