class EncoderDecoder(object): def __init__(self, rng, **kwargs): self.n_in_src = kwargs.pop('nembed_src') self.n_in_trg = kwargs.pop('nembed_trg') self.n_hids_src = kwargs.pop('nhids_src') self.n_hids_trg = kwargs.pop('nhids_trg') self.src_vocab_size = kwargs.pop('src_vocab_size') self.trg_vocab_size = kwargs.pop('trg_vocab_size') self.method = kwargs.pop('method') self.dropout = kwargs.pop('dropout') self.maxout_part = kwargs.pop('maxout_part') self.path = kwargs.pop('saveto') self.clip_c = kwargs.pop('clip_c') self.rng = rng self.trng = RandomStreams(rng.randint(1e5)) # added by Zhaopeng Tu, 2016-06-09 self.with_attention = kwargs.pop('with_attention') # added by Zhaopeng Tu, 2016-04-29 self.with_coverage = kwargs.pop('with_coverage') self.coverage_dim = kwargs.pop('coverage_dim') self.coverage_type = kwargs.pop('coverage_type') self.max_fertility = kwargs.pop('max_fertility') if self.coverage_type is 'linguistic': # make sure the dimension of linguistic coverage is always 1 self.coverage_dim = 1 # added by Zhaopeng Tu, 2016-05-30 self.with_context_gate = kwargs.pop('with_context_gate') self.params = [] self.layers = [] self.table_src = LookupTable(self.rng, self.src_vocab_size, self.n_in_src, name='table_src') self.layers.append(self.table_src) self.encoder = BidirectionalEncoder(self.rng, self.n_in_src, self.n_hids_src, self.table_src, name='birnn_encoder') self.layers.append(self.encoder) # added by Longyue self.encoder_hist_1 = Encoder(self.rng, self.n_in_src, self.n_hids_src, self.table_src, name='rnn_encoder_hist_1') self.layers.append(self.encoder_hist_1) self.encoder_hist_2 = Encoder(self.rng, self.n_hids_src, self.n_hids_src, self.table_src, name='rnn_encoder_hist_2') self.layers.append(self.encoder_hist_2) self.table_trg = LookupTable(self.rng, self.trg_vocab_size, self.n_in_trg, name='table_trg') self.layers.append(self.table_trg) self.decoder = Decoder(self.rng, self.n_in_trg, self.n_hids_trg, 2*self.n_hids_src, self.n_hids_src, \ # added by Zhaopeng Tu, 2016-06-09 with_attention=self.with_attention, \ # added by Zhaopeng Tu, 2016-04-29 with_coverage=self.with_coverage, coverage_dim=self.coverage_dim, coverage_type=self.coverage_type, max_fertility=self.max_fertility, \ # added by Zhaopeng Tu, 2016-05-30 with_context_gate=self.with_context_gate, \ maxout_part=self.maxout_part, name='rnn_decoder') self.layers.append(self.decoder) self.logistic_layer = LogisticRegression(self.rng, self.n_in_trg, self.trg_vocab_size) self.layers.append(self.logistic_layer) # added by Zhaopeng Tu, 2016-07-12 # for reconstruction self.with_reconstruction = kwargs.pop('with_reconstruction') if self.with_reconstruction: # added by Zhaopeng Tu, 2016-07-27 self.reconstruction_weight = kwargs.pop('reconstruction_weight') # note the source and target sides are reversed self.inverse_decoder = InverseDecoder(self.rng, self.n_in_src, 2*self.n_hids_src, self.n_hids_trg, \ # added by Zhaopeng Tu, 2016-06-09 with_attention=self.with_attention, \ maxout_part=self.maxout_part, name='rnn_inverse_decoder') self.layers.append(self.inverse_decoder) self.srng = RandomStreams(rng.randint(1e5)) self.inverse_logistic_layer = LogisticRegression( self.rng, self.n_in_src, self.src_vocab_size, name='inverse_LR') self.layers.append(self.inverse_logistic_layer) for layer in self.layers: self.params.extend(layer.params) def build_trainer(self, src, src_mask, src_hist, src_hist_mask, trg, trg_mask, ite): # added by Longyue # checked by Zhaopeng: sentence dim = n_steps, hist_len, batch_size (4, 3, 25) # hist = (bath_size, sent_num, sent_len) --.T--> # hist = (sent_len, sent_num, bath_size) --lookup table--> # (sent_len, sent_num, bath_size, word_emb) --reshape--> # (sent_len, sent_num*bath_size, word_emb) --word-level rnn--> # (sent_len, sent_num*bath_size, hidden_size) --reshape--> # (sent_len, sent_num, bath_size, hidden_size) --[-1]--> # (sent_num, bath_size, hidden_size) --sent-level rnn--> # (sent_num, bath_size, hidden_size) --[-1]--> # (bath_size, hidden_size) = cross-sent context vector annotations_1 = self.encoder_hist_1.apply_1(src_hist, src_hist_mask) annotations_1 = annotations_1[-1] # get last hidden states annotations_2 = self.encoder_hist_2.apply_2(annotations_1) annotations_3 = annotations_2[-1] # get last hidden states #modified by Longyue annotations = self.encoder.apply(src, src_mask, annotations_3) # init_context = annotations[0, :, -self.n_hids_src:] # modification #1 # mean pooling init_context = (annotations * src_mask[:, :, None]).sum(0) / src_mask.sum(0)[:, None] #added by Longyue init_context = concatenate([init_context, annotations_3], axis=annotations_3.ndim - 1) trg_emb = self.table_trg.apply(trg) trg_emb_shifted = T.zeros_like(trg_emb) trg_emb_shifted = T.set_subtensor(trg_emb_shifted[1:], trg_emb[:-1]) # modified by Longyue hiddens, readout, alignment = self.decoder.run_pipeline( state_below=trg_emb_shifted, mask_below=trg_mask, init_context=init_context, c=annotations, c_mask=src_mask, hist=annotations_3) # apply dropout if self.dropout < 1.0: logger.info('Apply dropout with p = {}'.format(self.dropout)) readout = Dropout(self.trng, readout, 1, self.dropout) p_y_given_x = self.logistic_layer.get_probs(readout) self.cost = self.logistic_layer.cost(p_y_given_x, trg, trg_mask) / trg.shape[1] # self.cost = theano.printing.Print('likilihood cost:')(self.cost) # added by Zhaopeng Tu, 2016-07-12 # for reconstruction if self.with_reconstruction: # now hiddens is the annotations inverse_init_context = (hiddens * trg_mask[:, :, None] ).sum(0) / trg_mask.sum(0)[:, None] src_emb = self.table_src.apply(src) src_emb_shifted = T.zeros_like(src_emb) src_emb_shifted = T.set_subtensor(src_emb_shifted[1:], src_emb[:-1]) inverse_hiddens, inverse_readout, inverse_alignment = self.inverse_decoder.run_pipeline( state_below=src_emb_shifted, mask_below=src_mask, init_context=inverse_init_context, c=hiddens, c_mask=trg_mask) # apply dropout if self.dropout < 1.0: # logger.info('Apply dropout with p = {}'.format(self.dropout)) inverse_readout = Dropout(self.srng, inverse_readout, 1, self.dropout) p_x_given_y = self.inverse_logistic_layer.get_probs( inverse_readout) self.reconstruction_cost = self.inverse_logistic_layer.cost( p_x_given_y, src, src_mask) / src.shape[1] # self.reconstruction_cost = theano.printing.Print('reconstructed cost:')(self.reconstruction_cost) self.cost += self.reconstruction_cost * self.reconstruction_weight self.L1 = sum(T.sum(abs(param)) for param in self.params) self.L2 = sum(T.sum(param**2) for param in self.params) params_regular = self.L1 * 1e-6 + self.L2 * 1e-6 # params_regular = theano.printing.Print('params_regular:')(params_regular) # train cost train_cost = self.cost + params_regular # gradients grads = T.grad(train_cost, self.params) # apply gradient clipping here grads = grad_clip(grads, self.clip_c) # updates updates = adadelta(self.params, grads) # train function # modified by Longyue inps = [src, src_mask, src_hist, src_hist_mask, trg, trg_mask] self.train_fn = theano.function(inps, [train_cost], updates=updates, name='train_function') # self.train_fn = theano.function(inps, [train_cost], updates=updates, name='train_function', mode=NanGuardMode(nan_is_error=True, inf_is_error=True, big_is_error=True)) def build_sampler(self): # added by Longyue x_hist = T.ltensor3() x_hist_mask = T.tensor3() annotations_1 = self.encoder_hist_1.apply_1(x_hist, x_hist_mask) annotations_1 = annotations_1[-1] annotations_2 = self.encoder_hist_2.apply_2(annotations_1) annotations_3 = annotations_2[-1] x = T.lmatrix() # Build Networks # src_mask is None c = self.encoder.apply(x, None, annotations_3) #init_context = ctx[0, :, -self.n_hids_src:] # mean pooling init_context = c.mean(0) # added by Longyue init_context = concatenate([init_context, annotations_3], axis=annotations_3.ndim - 1) init_state = self.decoder.create_init_state(init_context) outs = [init_state, c, annotations_3] if not self.with_attention: outs.append(init_context) # compile function print 'Building compile_init_state_and_context function ...' self.compile_init_and_context = theano.function( [x, x_hist, x_hist_mask], outs, name='compile_init_and_context') print 'Done' y = T.lvector() cur_state = T.matrix() # if it is the first word, emb should be all zero, and it is indicated by -1 trg_emb = T.switch(y[:, None] < 0, T.alloc(0., 1, self.n_in_trg), self.table_trg.apply(y)) # added by Zhaopeng Tu, 2016-06-09 # for with_attention=False if self.with_attention and self.with_coverage: cov_before = T.tensor3() if self.coverage_type is 'linguistic': print 'Building compile_fertility ...' fertility = self.decoder._get_fertility(c) fertility = T.addbroadcast(fertility, 1) self.compile_fertility = theano.function( [c], [fertility], name='compile_fertility') print 'Done' else: fertility = None else: cov_before = None fertility = None # apply one step # modified by Zhaopeng Tu, 2016-04-29 # [next_state, ctxs] = self.decoder.apply(state_below=trg_emb, results = self.decoder.apply( state_below=trg_emb, init_state=cur_state, # added by Zhaopeng Tu, 2016-06-09 init_context=None if self.with_attention else init_context, c=c if self.with_attention else None, hist=annotations_3, # added by Longyue one_step=True, # added by Zhaopeng Tu, 2016-04-27 cov_before=cov_before, fertility=fertility) next_state = results[0] if self.with_attention: ctxs, alignment = results[1], results[2] if self.with_coverage: cov = results[3] else: # if with_attention=False, we always use init_context as the source representation ctxs = init_context readout = self.decoder.readout(next_state, ctxs, trg_emb) # maxout if self.maxout_part > 1: readout = self.decoder.one_step_maxout(readout) # apply dropout if self.dropout < 1.0: readout = Dropout(self.trng, readout, 0, self.dropout) # compute the softmax probability next_probs = self.logistic_layer.get_probs(readout) # sample from softmax distribution to get the sample next_sample = self.trng.multinomial(pvals=next_probs).argmax(1) # compile function print 'Building compile_next_state_and_probs function ...' inps = [y, cur_state] if self.with_attention: inps.append(c) else: inps.append(init_context) # added by Longyue inps.append(annotations_3) outs = [next_probs, next_state, next_sample] # added by Zhaopeng Tu, 2016-06-09 if self.with_attention: outs.append(alignment) # added by Zhaopeng Tu, 2016-04-29 if self.with_coverage: inps.append(cov_before) if self.coverage_type is 'linguistic': inps.append(fertility) outs.append(cov) self.compile_next_state_and_probs = theano.function( inps, outs, name='compile_next_state_and_probs') print 'Done' # added by Zhaopeng Tu, 2016-07-18 # for reconstruction if self.with_reconstruction: # Build Networks # trg_mask is None inverse_c = T.tensor3() # mean pooling inverse_init_context = inverse_c.mean(0) inverse_init_state = self.inverse_decoder.create_init_state( inverse_init_context) outs = [inverse_init_state] if not self.with_attention: outs.append(inverse_init_context) # compile function print 'Building compile_inverse_init_state_and_context function ...' self.compile_inverse_init_and_context = theano.function( [inverse_c], outs, name='compile_inverse_init_and_context') print 'Done' src = T.lvector() inverse_cur_state = T.matrix() trg_mask = T.matrix() # if it is the first word, emb should be all zero, and it is indicated by -1 src_emb = T.switch(src[:, None] < 0, T.alloc(0., 1, self.n_in_src), self.table_src.apply(src)) # apply one step # modified by Zhaopeng Tu, 2016-04-29 inverse_results = self.inverse_decoder.apply( state_below=src_emb, init_state=inverse_cur_state, # added by Zhaopeng Tu, 2016-06-09 init_context=None if self.with_attention else inverse_init_context, c=inverse_c if self.with_attention else None, c_mask=trg_mask, one_step=True) inverse_next_state = inverse_results[0] if self.with_attention: inverse_ctxs, inverse_alignment = inverse_results[ 1], inverse_results[2] else: # if with_attention=False, we always use init_context as the source representation inverse_ctxs = init_context inverse_readout = self.inverse_decoder.readout( inverse_next_state, inverse_ctxs, src_emb) # maxout if self.maxout_part > 1: inverse_readout = self.inverse_decoder.one_step_maxout( inverse_readout) # apply dropout if self.dropout < 1.0: inverse_readout = Dropout(self.srng, inverse_readout, 0, self.dropout) # compute the softmax probability inverse_next_probs = self.inverse_logistic_layer.get_probs( inverse_readout) # sample from softmax distribution to get the sample inverse_next_sample = self.srng.multinomial( pvals=inverse_next_probs).argmax(1) # compile function print 'Building compile_inverse_next_state_and_probs function ...' inps = [src, trg_mask, inverse_cur_state] if self.with_attention: inps.append(inverse_c) else: inps.append(inverse_init_context) outs = [ inverse_next_probs, inverse_next_state, inverse_next_sample ] # added by Zhaopeng Tu, 2016-06-09 if self.with_attention: outs.append(inverse_alignment) self.compile_inverse_next_state_and_probs = theano.function( inps, outs, name='compile_inverse_next_state_and_probs') print 'Done' def save(self, path=None): if path is None: path = self.path filenpz = open(path, "w") val = dict([(value.name, value.get_value()) for index, value in enumerate(self.params)]) logger.info("save the model {}".format(path)) numpy.savez(path, **val) filenpz.close() def load(self, path=None): if path is None: path = self.path if os.path.isfile(path): logger.info("load params {}".format(path)) val = numpy.load(path) for index, param in enumerate(self.params): logger.info('Loading {} with shape {}'.format( param.name, param.get_value(borrow=True).shape)) if param.name not in val.keys(): logger.info('Adding new param {} with shape {}'.format( param.name, param.get_value(borrow=True).shape)) continue if param.get_value().shape != val[param.name].shape: logger.info("Error: model param != load param shape {} != {}".format(\ param.get_value().shape, val[param.name].shape)) raise Exception("loading params shape mismatch") else: param.set_value(val[param.name], borrow=True) else: logger.error("file {} does not exist".format(path)) self.save()
class EncoderDecoder(object): def __init__(self, rng, **kwargs): self.n_in_src = kwargs.get('nembed_src') self.n_in_trg = kwargs.get('nembed_trg') self.n_hids_src = kwargs.get('nhids_src') self.n_hids_trg = kwargs.get('nhids_trg') self.src_vocab_size = kwargs.get('src_vocab_size') self.trg_vocab_size = kwargs.get('trg_vocab_size') self.method = kwargs.get('method') self.dropout = kwargs.get('dropout') self.maxout_part = kwargs.get('maxout_part') self.path = kwargs.get('saveto') self.clip_c = kwargs.get('clip_c') self.rng = rng self.trng = RandomStreams(rng.randint(1e5)) # added by Zhaopeng Tu, 2016-04-29 self.with_coverage = kwargs.get('with_coverage') self.coverage_dim = kwargs.get('coverage_dim') self.coverage_type = kwargs.get('coverage_type') self.max_fertility = kwargs.get('max_fertility') if self.coverage_type is 'linguistic': # make sure the dimension of linguistic coverage is always 1 self.coverage_dim = 1 # added by Zhaopeng Tu, 2016-05-30 self.with_context_gate = kwargs.get('with_context_gate') # added by Zhaopeng Tu, 2017-11-29 self.with_layernorm = kwargs.get('with_layernorm', False) self.params = [] self.layers = [] self.table_src = LookupTable(self.rng, self.src_vocab_size, self.n_in_src, name='table_src') self.layers.append(self.table_src) self.encoder = BidirectionalEncoder(self.rng, self.n_in_src, self.n_hids_src, self.table_src, name='birnn_encoder') self.layers.append(self.encoder) self.table_trg = LookupTable(self.rng, self.trg_vocab_size, self.n_in_trg, name='table_trg') self.layers.append(self.table_trg) self.decoder = Decoder(self.rng, self.n_in_trg, self.n_hids_trg, 2*self.n_hids_src, \ maxout_part=self.maxout_part, name='rnn_decoder', \ # added by Zhaopeng Tu, 2016-04-29 with_coverage=self.with_coverage, coverage_dim=self.coverage_dim, coverage_type=self.coverage_type, max_fertility=self.max_fertility, \ # added by Zhaopeng Tu, 2016-05-30 with_context_gate=self.with_context_gate, \ with_layernorm=self.with_layernorm) self.layers.append(self.decoder) self.logistic_layer = LogisticRegression(self.rng, self.n_in_trg, self.trg_vocab_size) self.layers.append(self.logistic_layer) # added by Zhaopeng Tu, 2016-07-12 # for reconstruction self.with_reconstruction = kwargs.get('with_reconstruction') if self.with_reconstruction: # added by Zhaopeng Tu, 2016-07-27 self.reconstruction_weight = kwargs.get('reconstruction_weight') # note the source and target sides are reversed self.inverse_decoder = Decoder(self.rng, self.n_in_src, 2*self.n_hids_src, self.n_hids_trg, \ maxout_part=self.maxout_part, name='rnn_inverse_decoder', \ with_layernorm=self.with_layernorm) self.layers.append(self.inverse_decoder) self.srng = RandomStreams(rng.randint(1e5)) self.inverse_logistic_layer = LogisticRegression( self.rng, self.n_in_src, self.src_vocab_size, name='inverse_LR') self.layers.append(self.inverse_logistic_layer) for layer in self.layers: self.params.extend(layer.params) def build_trainer(self, src, src_mask, trg, trg_mask): annotations = self.encoder.apply(src, src_mask) # init_context = annotations[0, :, -self.n_hids_src:] # modification #1 # mean pooling init_context = (annotations * src_mask[:, :, None]).sum(0) / src_mask.sum(0)[:, None] trg_emb = self.table_trg.apply(trg) trg_emb_shifted = T.zeros_like(trg_emb) trg_emb_shifted = T.set_subtensor(trg_emb_shifted[1:], trg_emb[:-1]) results = self.decoder.run_pipeline(state_below=trg_emb_shifted, mask_below=trg_mask, init_context=init_context, c=annotations, c_mask=src_mask) hiddens, ctxs, readout, alignment = results[:4] # apply dropout if self.dropout < 1.0: logger.info('Apply dropout with p = {}'.format(self.dropout)) readout = Dropout(self.trng, readout, 1, self.dropout) p_y_given_x = self.logistic_layer.get_probs(readout) self.cost = self.logistic_layer.cost(p_y_given_x, trg, trg_mask) / trg.shape[1] # self.cost = theano.printing.Print('likilihood cost:')(self.cost) # added by Zhaopeng Tu, 2016-07-12 # for reconstruction if self.with_reconstruction: # now hiddens is the annotations inverse_init_context = (hiddens * trg_mask[:, :, None] ).sum(0) / trg_mask.sum(0)[:, None] src_emb = self.table_src.apply(src) src_emb_shifted = T.zeros_like(src_emb) src_emb_shifted = T.set_subtensor(src_emb_shifted[1:], src_emb[:-1]) inverse_results = self.inverse_decoder.run_pipeline( state_below=src_emb_shifted, mask_below=src_mask, init_context=inverse_init_context, c=hiddens, c_mask=trg_mask) inverse_hiddens, inverse_ctxs, inverse_readout, inverse_alignment = inverse_results[: 4] # apply dropout if self.dropout < 1.0: # logger.info('Apply dropout with p = {}'.format(self.dropout)) inverse_readout = Dropout(self.srng, inverse_readout, 1, self.dropout) p_x_given_y = self.inverse_logistic_layer.get_probs( inverse_readout) self.reconstruction_cost = self.inverse_logistic_layer.cost( p_x_given_y, src, src_mask) / src.shape[1] # self.reconstruction_cost = theano.printing.Print('reconstructed cost:')(self.reconstruction_cost) self.cost += self.reconstruction_cost * self.reconstruction_weight self.L1 = sum(T.sum(abs(param)) for param in self.params) self.L2 = sum(T.sum(param**2) for param in self.params) params_regular = self.L1 * 1e-6 + self.L2 * 1e-6 # params_regular = theano.printing.Print('params_regular:')(params_regular) # train cost train_cost = self.cost + params_regular # gradients grads = T.grad(train_cost, self.params) # apply gradient clipping here grads = grad_clip(grads, self.clip_c) # train function inps = [src, src_mask, trg, trg_mask] outs = [train_cost] if self.with_layernorm: inps = [src, src_mask, trg, trg_mask] lr = T.scalar(name='lr') print 'Building optimizers...', self.train_fn, self.update_fn = adam(lr, self.params, grads, inps, outs) else: # updates updates = adadelta(self.params, grads) # mode=theano.Mode(linker='vm') for ifelse # Unless linker='vm' or linker='cvm' are used, ifelse will compute both variables and take the same computation time as switch. self.train_fn = theano.function(inps, outs, updates=updates, name='train_function', mode=theano.Mode(linker='vm')) # self.train_fn = theano.function(inps, outs, updates=updates, name='train_function', mode=NanGuardMode(nan_is_error=True, inf_is_error=True, big_is_error=True)) def build_sampler(self): x = T.lmatrix() # Build Networks # src_mask is None c = self.encoder.apply(x, None) #init_context = ctx[0, :, -self.n_hids_src:] # mean pooling init_context = c.mean(0) init_state = self.decoder.create_init_state(init_context) # compile function print 'Building compile_init_state_and_context function ...' self.compile_init_and_context = theano.function( [x], [init_state, c], name='compile_init_and_context') print 'Done' y = T.lvector() cur_state = T.matrix() # if it is the first word, emb should be a1l zero, and it is indicated by -1 trg_emb = T.switch(y[:, None] < 0, T.alloc(0., 1, self.n_in_trg), self.table_trg.apply(y)) # added by Zhaopeng Tu, 2016-06-09 if self.with_coverage: cov_before = T.tensor3() if self.coverage_type is 'linguistic': print 'Building compile_fertility ...' fertility = self.decoder._get_fertility(c) fertility = T.addbroadcast(fertility, 1) self.compile_fertility = theano.function( [c], [fertility], name='compile_fertility') print 'Done' else: fertility = None else: cov_before = None fertility = None # apply one step # modified by Zhaopeng Tu, 2016-04-29 results = self.decoder.apply( state_below=trg_emb, init_state=cur_state, c=c, one_step=True, # added by Zhaopeng Tu, 2016-04-27 cov_before=cov_before, fertility=fertility) next_state, ctxs, alignment = results[:3] idx = 3 if self.with_coverage: cov = results[idx] idx += 1 readout = self.decoder.readout(next_state, ctxs, trg_emb) # maxout if self.maxout_part > 1: readout = self.decoder.one_step_maxout(readout) # apply dropout if self.dropout < 1.0: readout = Dropout(self.trng, readout, 0, self.dropout) # compute the softmax probability next_probs = self.logistic_layer.get_probs(readout) # sample from softmax distribution to get the sample next_sample = self.trng.multinomial(pvals=next_probs).argmax(1) # compile function print 'Building compile_next_state_and_probs function ...' inps = [y, cur_state, c] outs = [next_probs, next_state, next_sample, alignment] # added by Zhaopeng Tu, 2016-04-29 if self.with_coverage: inps.append(cov_before) if self.coverage_type is 'linguistic': inps.append(fertility) outs.append(cov) # mode=theano.Mode(linker='vm') for ifelse # Unless linker='vm' or linker='cvm' are used, ifelse will compute both variables and take the same computation time as switch. self.compile_next_state_and_probs = theano.function( inps, outs, name='compile_next_state_and_probs', mode=theano.Mode(linker='vm')) print 'Done' # added by Zhaopeng Tu, 2016-07-18 # for reconstruction if self.with_reconstruction: # Build Networks # trg_mask is None inverse_c = T.tensor3() # mean pooling inverse_init_context = inverse_c.mean(0) inverse_init_state = self.inverse_decoder.create_init_state( inverse_init_context) outs = [inverse_init_state] # compile function print 'Building compile_inverse_init_state_and_context function ...' self.compile_inverse_init_and_context = theano.function( [inverse_c], outs, name='compile_inverse_init_and_context') print 'Done' src = T.lvector() inverse_cur_state = T.matrix() trg_mask = T.matrix() # if it is the first word, emb should be all zero, and it is indicated by -1 src_emb = T.switch(src[:, None] < 0, T.alloc(0., 1, self.n_in_src), self.table_src.apply(src)) # apply one step # modified by Zhaopeng Tu, 2016-04-29 inverse_results = self.inverse_decoder.apply( state_below=src_emb, init_state=inverse_cur_state, c=inverse_c, c_mask=trg_mask, one_step=True) inverse_next_state, inverse_ctxs, inverse_alignment = inverse_results[: 3] inverse_readout = self.inverse_decoder.readout( inverse_next_state, inverse_ctxs, src_emb) # maxout if self.maxout_part > 1: inverse_readout = self.inverse_decoder.one_step_maxout( inverse_readout) # apply dropout if self.dropout < 1.0: inverse_readout = Dropout(self.srng, inverse_readout, 0, self.dropout) # compute the softmax probability inverse_next_probs, inverse_next_energy = self.inverse_logistic_layer.get_probs( inverse_readout) # sample from softmax distribution to get the sample inverse_next_sample = self.srng.multinomial( pvals=inverse_next_probs).argmax(1) # compile function print 'Building compile_inverse_next_state_and_probs function ...' inps = [src, trg_mask, inverse_cur_state, inverse_c] outs = [ inverse_next_probs, inverse_next_state, inverse_next_sample, inverse_alignment ] self.compile_inverse_next_state_and_probs = theano.function( inps, outs, name='compile_inverse_next_state_and_probs') print 'Done' def save(self, path=None): if path is None: path = self.path filenpz = open(path, "w") val = dict([(value.name, value.get_value()) for index, value in enumerate(self.params)]) logger.info("save the model {}".format(path)) numpy.savez(path, **val) filenpz.close() def load(self, path=None): if path is None: path = self.path if os.path.isfile(path): logger.info("load params {}".format(path)) val = numpy.load(path) for index, param in enumerate(self.params): logger.info('Loading {} with shape {}'.format( param.name, param.get_value(borrow=True).shape)) if param.name not in val.keys(): logger.info('Adding new param {} with shape {}'.format( param.name, param.get_value(borrow=True).shape)) continue if param.get_value().shape != val[param.name].shape: logger.info("Error: model param != load param shape {} != {}".format(\ param.get_value().shape, val[param.name].shape)) raise Exception("loading params shape mismatch") else: param.set_value(val[param.name], borrow=True) else: logger.error("file {} does not exist".format(path)) self.save()