def build_model(self):
self.Encoder = Encoder(self.in_channels, self.storing_channels,
self.nf).to(self.device)
self.Decoder = Decoder(self.storing_channels, self.in_channels,
self.nf).to(self.device)
self.Disciminator = Discriminator().to(self.device)
self.load_model()
def __init__(self, args):
super(Seq2Seq, self).__init__()
self.beam = args.beam
self.encoder = Encoder(args)
self.decoder = Decoder(args)
def _initialize_layers(self, input_data_size, layer_list=None):
prev_output_size = input_data_size
for ind, layer_size in enumerate(layer_list):
# Create an Encoder and Decoder for each element in the layer list.
# For encoders, output size is the current element of layer list.
# For decoders, output size is equal to the *input* size of the Encoder at this layer.
# because Decoder(Encoder(data)) == data
self.encode_layers.append(
Encoder(layer_size, name="Encoder_Layer_" + str(ind)))
if ind == 0:
self.decode_layers.append(
Decoder(prev_output_size,
name="Decoder_Layer_" + str(ind),
end=True))
else:
self.decode_layers.append(
Decoder(prev_output_size,
name="Decoder_Layer_" + str(ind)))
self.layer_sizes.append((prev_output_size, layer_size))
# Build checkpoint directories for each layer.
cpt_dirname = FLAGS.checkpoint_dir + self.get_layer_checkpoint_dirname(
ind)
if not path.isdir(cpt_dirname):
makedirs(cpt_dirname)
prev_output_size = layer_size
def __init__(self,
vocab_size_src: int,
vocab_size_trg: int,
eos_int: int,
sos_int: int,
dim_embed_src: int = 512,
src_map_i2c: Union[Dict[int, str], None] = None,
trg_map_i2c: Union[Dict[int, str], None] = None,
dim_embed_trg: int = 512,
num_neurons_encoder: int = 512,
num_neurons_decoder: int = 512,
optim: object = GradientDescentMomentum):
assert dim_embed_trg == num_neurons_decoder, (
"For weight tying, the number of neurons in the decoder has to be" +
"the same as the number of dimensions in the embedding")
# These don't have to be equal. If they aren't, you will need an
# additional weight matrix after the encoder to project down or
# up to the dimensionality of the decoder, adding extra complexity.
# Kept symmetric for simplicities sake
assert num_neurons_decoder == num_neurons_encoder, (
"Currently this model only supports symmetric decoders and encoders"
)
self.src_dim = vocab_size_src
self.trg_map_i2c = trg_map_i2c
self.src_map_i2c = src_map_i2c
self.optim = optim
self.encoder = Encoder(vocab_size_src, dim_embed_src,
num_neurons_encoder, optim)
self.decoder = Decoder(vocab_size_trg, dim_embed_trg,
num_neurons_decoder, optim)
self.eos_int = eos_int
self.sos_int = sos_int
def __init__(self, activate_encoder):
super(Tacotron3, self).__init__()
if activate_encoder:
self.encoder = Encoder()
else:
self.encoder = SimpleEncoder()
self.decoder = Decoder(activate_encoder)
self.postnet = Postnet()
def __init__(self, config):
super().__init__()
self.decoder = Decoder.build({**config["decoder"], "rename": True})
self.soft_mem_mask = config["decoder"]["mem_mask"] == "soft"
if self.soft_mem_mask:
self.mem_encoder = Encoder.build(config["mem_encoder"])
self.mem_decoder = Decoder.build(config["mem_decoder"])
self.decoder.mem_encoder = self.mem_encoder
self.decoder.mem_decoder = self.mem_decoder
self.beam_size = config["test"]["beam_size"]
def __init__(self, config):
super().__init__()
self.decoder = Decoder.build({**config["decoder"]})
self.subtype = config["decoder"]["type"] in ["XfmrSubtypeDecoder"]
self.soft_mem_mask = config["decoder"]["mem_mask"] == "soft"
if self.soft_mem_mask:
self.mem_encoder = Encoder.build(config["mem_encoder"])
self.mem_decoder = Decoder.build(config["mem_decoder"])
self.decoder.mem_encoder = self.mem_encoder
self.decoder.mem_decoder = self.mem_decoder
self.beam_size = config["test"]["beam_size"]
def __init__(self):
super(Tacotron2, self).__init__()
self.embedding = nn.Embedding(hps.n_symbols,
hps.character_embedding_dim)
std = sqrt(2.0 / (hps.n_symbols + hps.character_embedding_dim))
val = sqrt(3.0) * std
self.embedding.weight.data.uniform_(-val, val)
self.encoder = Encoder()
self.decoder = Decoder()
self.postnet = PostNet()
def __init__(self,
gen_emb,
domain_emb,
ae_nums,
as_nums,
ds_nums,
iters=15,
dropout=0.5,
use_transission=True):
"""
:param gen_emb: 通用词向量权重
:param domain_emb: 领域词向量权重
:param ae_nums: aspect和opinion word抽取的标签种类
:param as_nums: aspect sentiment种类
:param ds_nums: doc sentiment种类
:param iters: message passing轮数
:param dropout:
:param use_opinion: AE和AS之间是否建立联系
"""
super(NewImn, self).__init__()
self.iters = iters
self.use_transission = use_transission
self.dropout = nn.Dropout(dropout)
# f_s
self.general_embedding = torch.nn.Embedding(gen_emb.shape[0],
gen_emb.shape[1])
self.general_embedding.weight = torch.nn.Parameter(gen_emb,
requires_grad=False)
self.domain_embedding = torch.nn.Embedding(domain_emb.shape[0],
domain_emb.shape[1])
self.domain_embedding.weight = torch.nn.Parameter(domain_emb,
requires_grad=False)
self.encoder_shared = MultiLayerCNN(400, 0, dropout=dropout)
# f_ae
self.encoder_aspect = nn.GRU(256,
128,
num_layers=1,
batch_first=True,
bidirectional=True)
# self.encoder_aspect = MultiLayerCNN(256,2,dropout=dropout)
self.decoder_aspect = Decoder(912, ae_nums)
# f_as
self.encoder_sentiment = nn.GRU(661,
256,
num_layers=1,
batch_first=True,
bidirectional=True)
self.decoder_sentiment = Decoder(768, as_nums)
# update
self.update = nn.Linear(256 + as_nums + ae_nums, 256)
def __init__(self, config: HiDDenConfiguration, noiser: Noiser):
super(EncoderDecoder, self).__init__()
self.encoder = Encoder(config)
self.noiser = noiser
self.decoder = Decoder(config)
def __init__(self,
num_encoder,
num_decoder,
d_model,
num_heads,
dff,
inp_max_seq_len,
tar_max_seq_len,
inp_vocab_size,
tar_vocab_size,
rate=0.1):
super(Transformer, self).__init__()
encoder_params = {
"num_encoder": num_encoder,
"num_heads": num_heads,
"d_model": d_model,
"dff": dff,
"max_seq_len": inp_max_seq_len,
"vocab_size": inp_vocab_size,
"rate": rate
}
self.encoder = Encoder(**encoder_params)
decoder_params = {
"num_decoder": num_decoder,
"num_heads": num_heads,
"d_model": d_model,
"dff": dff,
"max_seq_len": tar_max_seq_len,
"vocab_size": tar_vocab_size,
"rate": rate
}
self.decoder = Decoder(**decoder_params)
self.final_dense = keras.layers.Dense(tar_vocab_size)
def __init__(self, embedding_info: Dict, encoder_info: Dict,
decoder_info: Dict, hidden_states: Dict, token_to_id: Dict,
type_to_id: Dict, label_to_id: Dict):
super().__init__()
self.embedding_info = embedding_info
self.encoder_info = encoder_info
self.decoder_info = decoder_info
self.hidden_states = hidden_states
self.token_to_id = token_to_id
self.type_to_id = type_to_id
self.label_to_id = label_to_id
self.embedding = Embedding(h_emb=self.hidden_states['embedding'],
token_to_id=self.token_to_id,
type_to_id=self.type_to_id,
**self.embedding_info)
self.encoder = Encoder(h_emb=self.hidden_states['embedding'],
h_enc=self.hidden_states['encoder'],
**self.encoder_info)
self.decoder = Decoder(h_enc=self.hidden_states['encoder'],
h_dec=self.hidden_states['decoder'],
label_to_id=self.label_to_id,
**self.decoder_info)
def make_model(src_vocab,
tgt_vocab,
N=6,
d_model=512,
d_ff=2048,
h=8,
dropout=0.1):
c = copy.deepcopy
attn = MultiHeadedAttention(h, d_model).to(args.device)
ff = PositionwiseFeedForward(d_model, d_ff, dropout).to(args.device)
position = PositionalEncoding(d_model, dropout).to(args.device)
model = Transformer(
Encoder(
EncoderLayer(d_model, c(attn), c(ff), dropout).to(args.device),
N).to(args.device),
Decoder(
DecoderLayer(d_model, c(attn), c(attn), c(ff),
dropout).to(args.device), N).to(args.device),
nn.Sequential(
Embeddings(d_model, src_vocab).to(args.device), c(position)),
nn.Sequential(
Embeddings(d_model, tgt_vocab).to(args.device), c(position)),
Generator(d_model, tgt_vocab)).to(args.device)
# 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)
return model.to(args.device)
def build_transformer(source_vocab,
target_vocab,
trg_pad_idx,
src_pad_idx,
num_layers=6,
num_attention_layers=8,
d_model=512,
d_ff=2048,
dropout=0.1):
# we can do a shared vocab here to share the weights for two embeddings and outputgenerator projection
positional_encoder = PositionalEncoder(d_model, dropout)
encoder = Encoder(num_layers,
num_attention_layers,
d_model,
d_ff,
dropout=dropout)
decoder = Decoder(num_layers,
num_attention_layers,
d_model,
d_ff,
dropout=dropout)
source_embedding = nn.Sequential(
Embedder(source_vocab, d_model, src_pad_idx),
copy.deepcopy(positional_encoder))
target_embedding = nn.Sequential(
Embedder(target_vocab, d_model, trg_pad_idx),
copy.deepcopy(positional_encoder))
generator = OutputGenerator(d_model, target_vocab)
model = Transformer(encoder, decoder, generator, source_embedding,
target_embedding, trg_pad_idx, src_pad_idx)
for p in model.parameters():
if p.dim() > 1:
nn.init.xavier_uniform(p)
return model
def __init__(self, src_pad_idx, trg_pad_idx, trg_sos_idx, enc_voc_size,
dec_voc_size, d_model, n_head, max_len, ffn_hidden, n_layers,
drop_prob, device):
super().__init__()
self.src_pad_idx = src_pad_idx
self.trg_pad_idx = trg_pad_idx
self.trg_sos_idx = trg_sos_idx
self.device = device
self.encoder = Encoder(d_model=d_model,
n_head=n_head,
max_len=max_len,
ffn_hidden=ffn_hidden,
enc_voc_size=enc_voc_size,
drop_prob=drop_prob,
n_layers=n_layers,
device=device)
self.decoder = Decoder(d_model=d_model,
n_head=n_head,
max_len=max_len,
ffn_hidden=ffn_hidden,
dec_voc_size=dec_voc_size,
drop_prob=drop_prob,
n_layers=n_layers,
device=device)
def __init__(self, latent_dim: int = 128, image_channels: int = 3):
super().__init__()
self.latent_dim = latent_dim
self.encoder = Encoder(in_channels=image_channels,
latent_dim=latent_dim)
self.decoder = Decoder(latent_dims=latent_dim,
out_channels=image_channels,
image_size=(72, 72))
def __init__(self, embed_dims, num_chars, encoder_dims, decoder_dims,
n_mels, fft_bins, postnet_dims, encoder_K, lstm_dims,
postnet_K, num_highways, dropout, speaker_latent_dims,
speaker_encoder_dims, n_speakers, noise_latent_dims,
noise_encoder_dims):
super().__init__()
self.n_mels = n_mels
self.lstm_dims = lstm_dims
self.decoder_dims = decoder_dims
# Standard Tacotron #############################################################
self.encoder = Encoder(embed_dims, num_chars, encoder_dims, encoder_K,
num_highways, dropout)
self.encoder_proj = nn.Linear(decoder_dims, decoder_dims, bias=False)
self.decoder = Decoder(n_mels, decoder_dims, lstm_dims,
speaker_latent_dims, noise_latent_dims)
self.postnet = CBHG(postnet_K, n_mels + noise_latent_dims,
postnet_dims, [256, n_mels + noise_latent_dims],
num_highways)
self.post_proj = nn.Linear(postnet_dims * 2, fft_bins, bias=False)
# VAE Domain Adversarial ########################################################
if hp.encoder_model == "CNN":
self.speaker_encoder = CNNEncoder(n_mels, speaker_latent_dims,
speaker_encoder_dims)
self.noise_encoder = CNNEncoder(n_mels, noise_latent_dims,
noise_encoder_dims)
elif hp.encoder_model == "CNNRNN":
self.speaker_encoder = CNNRNNEncoder(n_mels, speaker_latent_dims,
speaker_encoder_dims)
self.noise_encoder = CNNRNNEncoder(n_mels, noise_latent_dims,
noise_encoder_dims)
self.speaker_speaker = Classifier(speaker_latent_dims, n_speakers)
self.speaker_noise = Classifier(speaker_latent_dims, 2)
self.noise_speaker = Classifier(noise_latent_dims, n_speakers)
self.noise_noise = Classifier(noise_latent_dims, 2)
## speaker encoder prior
self.speaker_latent_loc = nn.Parameter(
torch.zeros(speaker_latent_dims), requires_grad=False)
self.speaker_latent_scale = nn.Parameter(
torch.ones(speaker_latent_dims), requires_grad=False)
self.speaker_latent_prior = dist.Independent(
dist.Normal(self.speaker_latent_loc, self.speaker_latent_scale), 1)
## noise encoder prior
self.noise_latent_loc = nn.Parameter(torch.zeros(noise_latent_dims),
requires_grad=False)
self.noise_latent_scale = nn.Parameter(torch.ones(noise_latent_dims),
requires_grad=False)
self.noise_latent_prior = dist.Independent(
dist.Normal(self.noise_latent_loc, self.noise_latent_scale), 1)
#################################################################################
self.init_model()
self.num_params()
self.register_buffer("step", torch.zeros(1).long())
self.register_buffer("r", torch.tensor(0).long())
def generate_caption(self, img_path, beam_size=2):
"""Caption generator
Args:
image_path: path to the image
Returns:
caption: caption, generated for a given image
"""
# TODO: to avoid specify model again use frozen graph
g = tf.Graph()
# change some Parameters
self.params.sample_gen = self.gen_method
try:
os.path.exists(img_path)
except:
raise ValueError("Image not found")
with g.as_default():
# specify rnn_placeholders
ann_lengths_ps = tf.placeholder(tf.int32, [None])
captions_ps = tf.placeholder(tf.int32, [None, None])
images_ps = tf.placeholder(tf.float32, [None, 224, 224, 3])
with tf.variable_scope("cnn"):
image_embeddings = vgg16(images_ps, trainable_fe=True,
trainable_top=True)
features = image_embeddings.fc2
# image fesatures [b_size + f_size(4096)] -> [b_size + embed_size]
images_fv = tf.layers.dense(features, self.params.embed_size,
name='imf_emb')
# will use methods from Decoder class
decoder = Decoder(images_fv, captions_ps,
ann_lengths_ps, self.params, self.data_dict)
with tf.variable_scope("decoder"):
_, _ = decoder.decoder() # for initialization
# if use cluster vectors
if self.params.use_c_v:
# cluster vectors from "Diverse and Accurate Image Description.." paper.
c_i = tf.placeholder(tf.float32, [None, 90])
c_i_emb = tf.layers.dense(c_i, self.params.embed_size,
name='cv_emb')
# map cluster vectors into embedding space
decoder.c_i = c_i_emb
decoder.c_i_ph = c_i
# image_id
im_id = [img_path.split('/')[-1]]
saver = tf.train.Saver(tf.trainable_variables())
with tf.Session(graph=g) as sess:
saver.restore(sess, self.checkpoint_path)
if self.params.use_c_v:
c_v = self._c_v_generator(image)
else:
c_v = None
im_shape = (224, 224) # VGG16
image = np.expand_dims(load_image(img_path, im_shape), 0)
if self.gen_method == 'beam_search':
sent = decoder.beam_search(sess, im_id, image,
images_ps, c_v,
beam_size=beam_size)
elif self.gen_method == 'greedy':
sent, _ = decoder.online_inference(sess, im_id, image,
images_ps, c_v=c_v)
return sent
def _make_model(self):
# embedding
embedding = nn.Embedding(num_embeddings=self._config.vocab_size,
embedding_dim=self._config.embed_size)
embedding.weight.data.copy_(
torch.from_numpy(np.load(self._config.embedding_file_name)))
embedding.weight.requires_grad = False
# encoder
encoder = Encoder(rnn_type=self._config.rnn_type,
embed_size=self._config.embed_size,
hidden_size=self._config.hidden_size,
num_layers=self._config.num_layers,
bidirectional=self._config.bidirectional,
dropout=self._config.dropout)
# birdge
bridge = Bridge(rnn_type=self._config.rnn_type,
hidden_size=self._config.hidden_size,
bidirectional=self._config.bidirectional)
# decoder rnn cell
if self._config.rnn_type == 'LSTM':
rnn_cell = MultiLayerLSTMCells(
input_size=2 * self._config.embed_size,
hidden_size=self._config.hidden_size,
num_layers=self._config.num_layers,
dropout=self._config.dropout)
else:
rnn_cell = MultiLayerGRUCells(input_size=2 *
self._config.embed_size,
hidden_size=self._config.hidden_size,
num_layers=self._config.num_layers,
dropout=self._config.dropout)
# attention
if self._config.attention_type == 'Dot':
attention = DotAttention()
elif self._config.attention_type == 'ScaledDot':
attention = ScaledDotAttention()
elif self._config.attention_type == 'Additive':
attention = AdditiveAttention(query_size=self._config.hidden_size,
key_size=self._config.hidden_size)
elif self._config.attention_type == 'Multiplicative':
attention = MultiplicativeAttention(
query_size=self._config.hidden_size,
key_size=self._config.hidden_size)
elif self._config.attention_type == 'MLP':
attention = MultiLayerPerceptronAttention(
query_size=self._config.hidden_size,
key_size=self._config.hidden_size,
out_size=1)
else:
raise ValueError('No Supporting.')
# decoder
decoder = Decoder(embedding, rnn_cell, attention,
self._config.hidden_size)
# model
model = Seq2Seq(embedding, encoder, bridge, decoder)
return model
class Tacotron3(nn.Module):
def __init__(self, activate_encoder):
super(Tacotron3, self).__init__()
if activate_encoder:
self.encoder = Encoder()
else:
self.encoder = SimpleEncoder()
self.decoder = Decoder(activate_encoder)
self.postnet = Postnet()
def forward(self, inputs):
mel_source, mel_lengths, embedding, mel_target = inputs
mel_lengths = mel_lengths.data
encoder_outputs = self.encoder(mel_source, embedding)
mel_outputs, alignments = self.decoder(encoder_outputs, mel_target,
mel_lengths)
end_padding_ind = get_reverse_mask(mel_lengths)
mel_outputs_postnet = self.postnet(mel_outputs)
# FIX This sollution is ugleh - is there a better way?
mel_outputs = mel_outputs.permute(0, 2, 1)
mel_outputs[end_padding_ind, :] = 0
mel_outputs = mel_outputs.permute(0, 2, 1)
mel_outputs_postnet = mel_outputs_postnet.permute(0, 2, 1)
mel_outputs_postnet[end_padding_ind, :] = 0
mel_outputs_postnet = mel_outputs_postnet.permute(0, 2, 1)
mel_outputs_postnet = mel_outputs + mel_outputs_postnet
return mel_outputs, mel_outputs_postnet, alignments
def inference(self, inputs):
mel_source, mel_lengths, embedding, _ = inputs
encoder_outputs = self.encoder(mel_source, embedding)
mel_outputs, _ = self.decoder.inference(encoder_outputs)
end_padding_ind = get_reverse_mask(mel_lengths)
mel_outputs_postnet = self.postnet(mel_outputs)
# FIX This sollution is ugleh - is there a better way?
mel_outputs = mel_outputs.permute(0, 2, 1)
mel_outputs[end_padding_ind, :] = 0
mel_outputs = mel_outputs.permute(0, 2, 1)
mel_outputs_postnet = mel_outputs_postnet.permute(0, 2, 1)
mel_outputs_postnet[end_padding_ind, :] = 0
mel_outputs_postnet = mel_outputs_postnet.permute(0, 2, 1)
mel_outputs_postnet = mel_outputs + mel_outputs_postnet
return mel_outputs_postnet
def __init__(self):
super(Model, self).__init__()
self.encoder = Encoder()
self.decoder = Decoder()
self.embeds = nn.Embedding(config.vocab_size, config.emb_dim)
tools.init_wt_normal(self.embeds.weight)
self.encoder = get_cuda(self.encoder)
self.decoder = get_cuda(self.decoder)
self.embeds = get_cuda(self.embeds)
def __init__(self,
config: HiDDenConfiguration,
noiser: Noiser,
apply_quantization: bool = False):
# TODO: consider adding quantization after the noiser if the parameter value us true
# TODO: consider making quantization part of noise configuration
super(EncoderDecoder, self).__init__()
self.encoder = Encoder(config)
self.noiser = noiser # TODO: we were passing device to Noiser
self.decoder = Decoder(config)
def initialize(self, batch):
'''
param:
batch: Batch object
'''
with tf.variable_scope('inference') as scope:
linear_targets = batch._lin_targets
is_training = linear_targets is not None
batch_size = batch.get_size()
# Encoder
encoder = Encoder(is_training=is_training)
encoder_outputs = encoder.encode(batch.get_embedds(),
batch.get_input_lengths())
# Decoder
if is_training:
helper = TrainingHelper(batch.get_inputs(),
batch.get_mel_targets(),
self._hparams.num_mels,
self._hparams.outputs_per_step)
else:
helper = TestingHelper(batch_size, self._hparams.num_mels,
self._hparams.outputs_per_step)
decoder = Decoder(helper, is_training=is_training)
mel_outputs, lin_outputs, final_decoder_state = decoder.decode(
encoder_outputs, batch_size)
# Alignments
alignments = tf.transpose(
final_decoder_state[0].alignment_history.stack(), [1, 2, 0])
self.inputs, self.input_lengths, self.mel_targets, self.linear_targets = batch.get_all(
)
self.mel_outputs = mel_outputs
self.linear_outputs = lin_outputs
self.alignments = alignments
self.global_step = tf.Variable(0,
name='global_step',
trainable=False)
def __init__(self, cfg):
super(CenterNet, self).__init__()
self.backbone = ResNet(cfg.slug)
if cfg.fpn:
self.fpn = FPN(self.backbone.outplanes)
self.upsample = Decoder(
self.backbone.outplanes if not cfg.fpn else 2048, cfg.bn_momentum)
self.head = Head(channel=cfg.head_channel, num_classes=cfg.num_classes)
self._fpn = cfg.fpn
self.down_stride = cfg.down_stride
self.score_th = cfg.score_th
self.CLASSES_NAME = cfg.CLASSES_NAME
def build_pred(self):
self.logger.info("Building model...")
self.encoder = Encoder(self._config)
self.decoder = Decoder(self._config, self._vocab.n_tok,
self._vocab.id_end)
self._add_placeholders_op()
self._add_pred_op()
self._add_loss_op()
self.init_session()
self.logger.info("- done.")
def __init__(self,
vocab_size,
embed_size,
hidden_size,
rnn_type='LSTM',
num_layers=1,
bidirectional=False,
attention_type='Bilinear',
dropout=0):
super(Seq2Seq, self).__init__()
self.embedding = nn.Embedding(num_embeddings=vocab_size,
embedding_dim=embed_size)
self.encoder = Encoder(embed_size=embed_size,
hidden_size=hidden_size,
rnn_type=rnn_type,
num_layers=num_layers,
bidirectional=bidirectional,
dropout=dropout)
self.decoder = Decoder(embedding=self.embedding,
hidden_size=hidden_size,
rnn_type=rnn_type,
num_layers=num_layers,
attention_type=attention_type,
dropout=dropout)
def build_decoder(hidden_size: int, embedding_dim: int, vocab_size: int):
assert embedding_dim == hidden_size, (
f"Different embedding_dim and hidden_size not implemented")
decoder_layer = LSTMLayer(input_size=hidden_size, hidden_size=hidden_size)
generator = Generator(hidden_size, embedding_dim)
vocab_predictor = VocabPredictor(hidden_size, vocab_size)
word_attention = AdditiveAttention(hidden_size, bias=True)
agent_attention = AdditiveAttention(hidden_size, bias=True)
return Decoder(decoder_layer=decoder_layer, vocab_predictor=vocab_predictor,
generator=generator, word_attention=word_attention,
agent_attention=agent_attention)
class Seq2Seq(nn.Module):
def __init__(self, args):
super(Seq2Seq, self).__init__()
self.beam = args.beam
self.encoder = Encoder(args)
self.decoder = Decoder(args)
def forward(self, input_words, output_words, train=True):
#Encoderに投げる
encoder_outputs, encoder_hidden = self.encoder(
input_words) #(batch,seq_len,hidden_size*2)
output=self.decoder(encoder_outputs,encoder_hidden,output_words,train) if self.beam==False else \
self.decoder.beam_decode(encoder_outputs,encoder_hidden,output_words,train)
return output
def build_train(self, config):
"""Builds model"""
self.logger.info("Building model...")
self.encoder = Encoder(self._config)
self.decoder = Decoder(self._config, self._vocab.n_tok,
self._vocab.id_end)
self._add_placeholders_op()
self._add_pred_op()
self._add_loss_op()
self._add_train_op(config.lr_method, self.lr, self.loss, config.clip)
self.init_session()
self.logger.info("- done.")
def __init__(self, device):
super().__init__()
#Declare hyperparameters
self.device = device
self.encoder = Encoder(device).to(self.device)
self.reduce_state = ReduceState(device).to(self.device)
self.decoder = Decoder(device).to(self.device)
self.decoder.embedding.weight = self.encoder.embedding.weight
#self.max_text = config.max_text
self.max_sum = config.max_sum
self.SP_index = config.SP_index
#self.EP_index = config.EP_index
self.is_coverage = config.coverage
self.hidden_dim = config.hid_dim
