我们从Python开源项目中，提取了以下41个代码示例，用于说明如何使用data_utils.GO_ID。
def test(self, sess, token_ids): # We decode one sentence at a time. token_ids = data_utils.padding(token_ids) target_ids = data_utils.padding([data_utils.GO_ID]) y_ids = data_utils.padding([data_utils.EOS_ID]) encoder_inputs, decoder_inputs, _, _ = data_utils.nextRandomBatch([(token_ids, target_ids, y_ids)], batch_size=1) prediction = sess.run(self.prediction, feed_dict={ self.encoder_inputs: encoder_inputs, self.decoder_inputs: decoder_inputs }) pred_max = tf.arg_max(prediction, 1) # prediction = tf.split(0, self.num_steps, prediction) # # This is a greedy decoder - outputs are just argmaxes of output_logits. # outputs = [int(np.argmax(predict)) for predict in prediction] # # If there is an EOS symbol in outputs, cut them at that point. # if data_utils.EOS_ID in outputs: # outputs = outputs[:outputs.index(data_utils.EOS_ID)] return pred_max.eval()
def get_batch(self,data_set,batch_size,random=True): '''get a batch of data from a data_set and do all needed preprocess to make them usable for the model defined above''' if random: seqs = np.random.choice(data_set,size= batch_size) else: seqs = data_set[0:batch_size] encoder_inputs = np.zeros((batch_size,self.max_seq_length),dtype = int) decoder_inputs = np.zeros((batch_size,self.max_seq_length+2),dtype = int) encoder_lengths = np.zeros(batch_size) decoder_weights = np.zeros((batch_size,self.max_seq_length+2),dtype=float) for i,seq in enumerate(seqs): encoder_inputs[i] = np.array(list(reversed(seq))+[data_utils.PAD_ID]*(self.max_seq_length-len(seq))) decoder_inputs[i] = np.array([data_utils.GO_ID]+seq+[data_utils.EOS_ID]+[data_utils.PAD_ID]*(self.max_seq_length-len(seq))) encoder_lengths[i]= len(seq) decoder_weights[i,0:(len(seq)+1)]=1.0 return np.transpose(encoder_inputs), np.transpose(decoder_inputs), encoder_lengths, np.transpose(decoder_weights)
def get_batch(self, features, sentences, lengths): batch_size = len(sentences) encoder_inputs, encoder_lengths, decoder_inputs = [], [], [] feature_pad = np.array([0.0] * self.feature_size) for (vid, sen) in sentences: feature = features[vid] encoder_lengths.append(lengths[vid]) if len(feature) > self.encoder_max_sequence_length: feature = random.sample(feature, self.encoder_max_sequence_length) pad_size = self.encoder_max_sequence_length - len(feature) encoder_inputs.append(feature + [feature_pad] * pad_size) pad_size = self.decoder_max_sentence_length - len(sen) - 2 decoder_inputs.append([data_utils.GO_ID] + sen + [data_utils.EOS_ID] + [data_utils.PAD_ID] * pad_size) batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] for length_idx in xrange(self.encoder_max_sequence_length): batch_encoder_inputs.append(np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(batch_size)], dtype=np.float32)) batch_encoder_lengths = np.array(encoder_lengths) for length_idx in xrange(self.decoder_max_sentence_length): batch_decoder_inputs.append(np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(batch_size, dtype=np.float32) for batch_idx in xrange(batch_size): if length_idx < self.decoder_max_sentence_length - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == self.decoder_max_sentence_length - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_encoder_lengths, batch_decoder_inputs, batch_weights
def get_batch(self, features, sentences): batch_size = len(sentences) encoder_inputs, decoder_inputs = [], [] feature_pad = np.array([0.0] * self.feature_size) for (vid, sen) in sentences: feature = features[vid] if len(feature) > self.encoder_max_sequence_length: feature = random.sample(feature, self.encoder_max_sequence_length) pad_size = self.encoder_max_sequence_length - len(feature) encoder_inputs.append(feature + [feature_pad] * pad_size) pad_size = self.decoder_max_sentence_length - len(sen) - 2 decoder_inputs.append([data_utils.GO_ID] + sen + [data_utils.EOS_ID] + [data_utils.PAD_ID] * pad_size) batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] for length_idx in xrange(self.encoder_max_sequence_length): batch_encoder_inputs.append(np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(batch_size)], dtype=np.float32)) for length_idx in xrange(self.decoder_max_sentence_length): batch_decoder_inputs.append(np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(batch_size, dtype=np.float32) for batch_idx in xrange(batch_size): if length_idx < self.decoder_max_sentence_length - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == self.decoder_max_sentence_length - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_decoder_inputs, batch_weights
def get_batch(self, data, bucket_id): """Get a random batch of data from the specified bucket, prepare for step. To feed data in step(..) it must be a list of batch-major vectors, while data here contains single length-major cases. So the main logic of this function is to re-index data cases to be in the proper format for feeding. Args: data: a tuple of size len(self.buckets) in which each element contains lists of pairs of input and output data that we use to create a batch. bucket_id: integer, which bucket to get the batch for. Returns: The triple (encoder_inputs, decoder_inputs, target_weights) for the constructed batch that has the proper format to call step(...) later. """ encoder_size, decoder_size = self.buckets[bucket_id] encoder_inputs, decoder_inputs = [], [] # Get a random batch of encoder and decoder inputs from data, # pad them if needed, reverse encoder inputs and add GO to decoder. for _ in xrange(self.batch_size): encoder_input, decoder_input = random.choice(data[bucket_id]) # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. for length_idx in xrange(encoder_size): batch_encoder_inputs.append( np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append( np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(self.batch_size, dtype=np.float32) for batch_idx in xrange(self.batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_decoder_inputs, batch_weights
def get_batch(self, bucket_dbs, bucket_id, data): encoder_size, decoder_size = self.buckets[bucket_id] # bucket_db = bucket_dbs[bucket_id] encoder_inputs, decoder_inputs = [], [] for encoder_input, decoder_input in data: # encoder_input, decoder_input = random.choice(data[bucket_id]) # encoder_input, decoder_input = bucket_db.random() encoder_input = data_utils.sentence_indice(encoder_input) decoder_input = data_utils.sentence_indice(decoder_input) # Encoder encoder_pad = [data_utils.PAD_ID] * ( encoder_size - len(encoder_input) ) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) # Decoder decoder_pad_size = decoder_size - len(decoder_input) - 2 decoder_inputs.append( [data_utils.GO_ID] + decoder_input + [data_utils.EOS_ID] + [data_utils.PAD_ID] * decoder_pad_size ) batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # batch encoder for i in range(encoder_size): batch_encoder_inputs.append(np.array( [encoder_inputs[j][i] for j in range(self.batch_size)], dtype=np.int32 )) # batch decoder for i in range(decoder_size): batch_decoder_inputs.append(np.array( [decoder_inputs[j][i] for j in range(self.batch_size)], dtype=np.int32 )) batch_weight = np.ones(self.batch_size, dtype=np.float32) for j in range(self.batch_size): if i < decoder_size - 1: target = decoder_inputs[j][i + 1] if i == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[j] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_decoder_inputs, batch_weights
def create_batches(data): print("generating batches...") batches = [[] for _ in _buckets] for bucket_id in xrange(len(_buckets)): data_bucket = data[bucket_id] encoder_size, decoder_size = _buckets[bucket_id] # shuffle the data data_permute = np.random.permutation(len(data_bucket)) num_batches = math.ceil(len(data_bucket)/FLAGS.batch_size) for b_idx in xrange(num_batches): encoder_inputs, decoder_inputs = [], [] for i in xrange(FLAGS.batch_size): data_idx = data_permute[(b_idx*FLAGS.batch_size+i) % len(data_bucket)] encoder_input, decoder_input = data_bucket[data_idx] # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. for length_idx in xrange(encoder_size): batch_encoder_inputs.append(np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(FLAGS.batch_size)], dtype=np.int32)) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append(np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(FLAGS.batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(FLAGS.batch_size, dtype=np.float32) for batch_idx in xrange(FLAGS.batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) batches[bucket_id].append((batch_encoder_inputs, batch_decoder_inputs, batch_weights)) return batches #----------------------------------------------------- # main training function #-----------------------------------------------------
def get_decode_batch(self, data, bucket_id): """Get sequential batch """ encoder_size, decoder_size = self.buckets[bucket_id] encoder_inputs, decoder_inputs = [], [] this_batch_size = len(data[bucket_id]) ## SHUBHAM - seq_len initialized seq_len = [] # Get a random batch of encoder and decoder inputs from data, # pad them if needed, reverse encoder inputs and add GO to decoder. for sample in data[bucket_id]: encoder_input, decoder_input = sample ## SHUBHAM - Append Entries seq_len.append(len(encoder_input)) # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) ## SHUBHAM - reversing just the input encoder_inputs.append(list(reversed(encoder_input)) + encoder_pad) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. for length_idx in xrange(encoder_size): batch_encoder_inputs.append(np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append(np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(this_batch_size, dtype=np.float32) for batch_idx in xrange(this_batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) ## SHUBHAM - seq_len as nparray and then passing it as well seq_len = np.asarray(seq_len, dtype=np.int64) return batch_encoder_inputs, batch_decoder_inputs, batch_weights, seq_len
def get_batch(self, data, bucket_id): """Get batches """ this_batch_size = len(data[bucket_id]) encoder_size, decoder_size = self.buckets[bucket_id] text_encoder_inputs, speech_encoder_inputs, decoder_inputs = [], [], [] seq_len = [] for sample in data[bucket_id]: text_encoder_input, decoder_input, speech_encoder_input = sample seq_len.append(len(text_encoder_input)) # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(text_encoder_input)) text_encoder_inputs.append(list(reversed(text_encoder_input)) + encoder_pad) # do the same for speech encoder inputs: reverse sequence speech_encoder_inputs.append(np.fliplr(speech_encoder_input).T) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_text_encoder_inputs, batch_speech_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. for length_idx in xrange(encoder_size): batch_text_encoder_inputs.append( np.array([text_encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) for length_idx in xrange(encoder_size * spscale): batch_speech_encoder_inputs.append([speech_encoder_inputs[batch_idx][length_idx, :] for batch_idx in xrange(this_batch_size)]) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append( np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(this_batch_size, dtype=np.float32) for batch_idx in xrange(this_batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) seq_len = np.asarray(seq_len, dtype=np.int64) return batch_text_encoder_inputs, batch_speech_encoder_inputs, batch_decoder_inputs, batch_weights, seq_len
def get_decode_batch(self, data, bucket_id): """Get sequential batch """ encoder_size, decoder_size = self.buckets[bucket_id] encoder_inputs, decoder_inputs = [], [] this_batch_size = len(data[bucket_id]) # Get a random batch of encoder and decoder inputs from data, # pad them if needed, reverse encoder inputs and add GO to decoder. for sample in data[bucket_id]: encoder_input, decoder_input = sample # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. for length_idx in xrange(encoder_size): batch_encoder_inputs.append(np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append(np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(this_batch_size, dtype=np.float32) for batch_idx in xrange(this_batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_decoder_inputs, batch_weights
def get_mix_batch(self, bucketed_data, bucket_id, this_batch_size): """Get a random batch of data from the specified bucket, prepare for step. To feed data in step(..) it must be a list of batch-major vectors, while data here contains single length-major cases. So the main logic of this function is to re-index data cases to be in the proper format for feeding. Args: data: a tuple of size len(self.buckets) in which each element contains lists of pairs of input and output data that we use to create a batch. bucket_id: integer, which bucket to get the batch for. Returns: The triple (encoder_inputs, decoder_inputs, target_weights) for the constructed batch that has the proper format to call step(...) later. """ encoder_size, decoder_size = self.buckets[bucket_id] encoder_inputs, decoder_inputs = [], [] # Get a random batch of encoder and decoder inputs from data, # pad them if needed, reverse encoder inputs and add GO to decoder. for _ in xrange(this_batch_size): encoder_input, decoder_input = random.choice(bucketed_data) # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. for length_idx in xrange(encoder_size): batch_encoder_inputs.append( np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append( np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(this_batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(this_batch_size, dtype=np.float32) for batch_idx in xrange(this_batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_decoder_inputs, batch_weights
def get_batch(self, data, bucket_id): """Get a random batch of data from the specified bucket, prepare for step. To feed data in step(..) it must be a list of batch-major vectors, while data here contains single length-major cases. So the main logic of this function is to re-index data cases to be in the proper format for feeding. Args: data: a tuple of size len(self.buckets) in which each element contains lists of pairs of input and output data that we use to create a batch. bucket_id: integer, which bucket to get the batch for. Returns: The triple (encoder_inputs, decoder_inputs, target_weights) for the constructed batch that has the proper format to call step(...) later. """ encoder_size, decoder_size = self.buckets[bucket_id] encoder_inputs, decoder_inputs = [], [] # Get a random batch of encoder and decoder inputs from data, # pad them if needed, reverse encoder inputs and add GO to decoder. for _ in xrange(self.batch_size): encoder_input, decoder_input = random.choice(data[bucket_id]) # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. #encoder_inputs?shape?(batch_size,encoder_size) #batch_encoder_inputs?shape?(encoder_size,batch_size) for length_idx in xrange(encoder_size): batch_encoder_inputs.append( np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append( np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(self.batch_size, dtype=np.float32) for batch_idx in xrange(self.batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] #????decoder????????target?pad,???????????????????? if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) #shape?(encoder_size,batch_size) return batch_encoder_inputs, batch_decoder_inputs, batch_weights
def evaluate(): with open (os.path.join(FLAGS.data_dir, 'feature.test'), 'rb') as f: feature = cPickle.load(f) with open(os.path.join(FLAGS.data_dir, 'caption.test'), 'rb') as f: sentence = cPickle.load(f) with open (os.path.join(FLAGS.data_dir, 'video.length'), 'rb') as f: length = cPickle.load(f) scorers = [(Bleu(4), ["Bleu_1", "Bleu_2", "Bleu_3", "Bleu_4"]), (Meteor(),"METEOR"), (Rouge(), "ROUGE_L"), (Cider(), "CIDEr")] vocab, re_vocab = data_utils.initialize_vocabulary() GTS = {} RES = {} batch_size = 1 max_meteor = 0 with tf.Session() as sess: model = Seq2Seq(FLAGS.num_units, FLAGS.use_lstm, FLAGS.encoder_max_sequence_length, 1, FLAGS.feature_size, FLAGS.vocab_size, FLAGS.learning_rate, FLAGS.learning_rate_decay_factor, FLAGS.max_gradient_norm, forward_only=True) step = 0 while True: step += FLAGS.steps_per_checkpoint ckpt_path = os.path.join(FLAGS.checkpoint_dir,'ckpt-%d'%step) if os.path.isfile(ckpt_path+'.meta'): model.saver.restore(sess, ckpt_path) cg = CaptionGenerator(model=model,start_id=data_utils.GO_ID,end_id=data_utils.EOS_ID, beam_size=3, max_caption_length=FLAGS.decoder_max_sentence_length, length_normalization_factor=0.0) for vid, _ in feature.iteritems(): feature_inputs, feature_lengths, batch_decoder_inputs, batch_weights = model.get_batch(feature, [(vid, [0])], length) sen = cg.beam_search(sess, feature_inputs, feature_lengths) sen = " ".join([tf.compat.as_str(re_vocab[w]) for w in sen]) print ("%s: %s"%(sen, sentence[vid][9])) GTS[vid] = sentence[vid] RES[vid] = [sen] print('STEP: %d'%step) for scorer, method in scorers: score, scores = scorer.compute_score(GTS, RES) if method == "METEOR" and score > max_meteor: max_meteor = score if isinstance(method, list): for k, v in zip(method, score): print("%s:\t%f"%(k, v)) else: print("%s:\t%f"%(method, score)) sys.stdout.flush() else: break print("Max METEOR:\t%f"%max_meteor)
def evaluate(): with open (os.path.join(FLAGS.data_dir, 'feature.test'), 'rb') as f: feature = cPickle.load(f) with open(os.path.join(FLAGS.data_dir, 'caption.test'), 'rb') as f: sentence = cPickle.load(f) scorers = [(Bleu(4), ["Bleu_1", "Bleu_2", "Bleu_3", "Bleu_4"]), (Meteor(),"METEOR"), (Rouge(), "ROUGE_L"), (Cider(), "CIDEr")] vocab, re_vocab = data_utils.initialize_vocabulary() GTS = {} RES = {} batch_size = 1 max_meteor = 0 with tf.Session() as sess: model = Seq2Seq(FLAGS.num_units, FLAGS.use_lstm, FLAGS.encoder_max_sequence_length, 1, FLAGS.feature_size, FLAGS.vocab_size, FLAGS.learning_rate, FLAGS.learning_rate_decay_factor, FLAGS.max_gradient_norm, forward_only=True) step = 0 while True: step += FLAGS.steps_per_checkpoint ckpt_path = os.path.join(FLAGS.checkpoint_dir,'ckpt-%d'%step) if os.path.isfile(ckpt_path+'.meta'): model.saver.restore(sess, ckpt_path) cg = CaptionGenerator(model=model,start_id=data_utils.GO_ID,end_id=data_utils.EOS_ID, beam_size=3, max_caption_length=FLAGS.decoder_max_sentence_length, length_normalization_factor=0.0) for vid, _ in feature.iteritems(): feature_inputs, batch_decoder_inputs, batch_weights = model.get_batch(feature, [(vid, [0])]) sen = cg.beam_search(sess, feature_inputs) sen = " ".join([tf.compat.as_str(re_vocab[w]) for w in sen]) print ("%s: %s"%(sen, sentence[vid][9])) GTS[vid] = sentence[vid] RES[vid] = [sen] print('STEP: %d'%step) for scorer, method in scorers: score, scores = scorer.compute_score(GTS, RES) if method == "METEOR" and score > max_meteor: max_meteor = score if isinstance(method, list): for k, v in zip(method, score): print("%s:\t%f"%(k, v)) else: print("%s:\t%f"%(method, score)) sys.stdout.flush() else: break print("Max METEOR:\t%f"%max_meteor)
def get_batch(self, train_data, bucket_id): encoder_size, decoder_size = self.buckets[bucket_id] encoder_inputs, decoder_inputs = [], [] batch_source_encoder, batch_source_decoder = [], [] #print("bucket_id: ", bucket_id) for batch_i in xrange(self.batch_size): encoder_input, decoder_input = random.choice(train_data[bucket_id]) batch_source_encoder.append(encoder_input) batch_source_decoder.append(decoder_input) #print("encoder_input: ", encoder_input) encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) #print("encoder_input pad: ", list(reversed(encoder_input + encoder_pad))) #print("decoder_input: ", decoder_input) decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) #print("decoder_pad: ",[data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] for length_idx in xrange(encoder_size): batch_encoder_inputs.append( np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) for length_idx in xrange(decoder_size): batch_decoder_inputs.append( np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) batch_weight = np.ones(self.batch_size, dtype=np.float32) for batch_idx in xrange(self.batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_decoder_inputs, batch_weights, batch_source_encoder, batch_source_decoder
def get_batch(self, train_data, bucket_id, type=0): encoder_size, decoder_size = self.buckets[bucket_id] encoder_inputs, decoder_inputs = [], [] # print("Batch_Size: %s" %self.batch_size) # Get a random batch of encoder and decoder inputs from data, # pad them if needed, reverse encoder inputs and add GO to decoder. batch_source_encoder, batch_source_decoder = [], [] # print("bucket_id: %s" %bucket_id) for batch_i in xrange(self.batch_size): if type == 1: # feed_data = {bucket_id: zip(tokens_a, tokens_b)} encoder_input, decoder_input = train_data[bucket_id][batch_i] elif type == 2: # feed_data = {bucket_id: [(resp_tokens, [])]} encoder_input_a, decoder_input = train_data[bucket_id][0] encoder_input = encoder_input_a[batch_i] elif type == 0: encoder_input, decoder_input = random.choice(train_data[bucket_id]) print("train en: %s, de: %s" % (encoder_input, decoder_input)) batch_source_encoder.append(encoder_input) batch_source_decoder.append(decoder_input) # Encoder inputs are padded and then reversed. encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input)) encoder_inputs.append(list(reversed(encoder_input + encoder_pad))) # Decoder inputs get an extra "GO" symbol, and are padded then. decoder_pad_size = decoder_size - len(decoder_input) - 1 decoder_inputs.append([data_utils.GO_ID] + decoder_input + [data_utils.PAD_ID] * decoder_pad_size) # Now we create batch-major vectors from the data selected above. batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], [] # Batch encoder inputs are just re-indexed encoder_inputs. for length_idx in xrange(encoder_size): batch_encoder_inputs.append( np.array([encoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) # Batch decoder inputs are re-indexed decoder_inputs, we create weights. for length_idx in xrange(decoder_size): batch_decoder_inputs.append( np.array([decoder_inputs[batch_idx][length_idx] for batch_idx in xrange(self.batch_size)], dtype=np.int32)) # Create target_weights to be 0 for targets that are padding. batch_weight = np.ones(self.batch_size, dtype=np.float32) for batch_idx in xrange(self.batch_size): # We set weight to 0 if the corresponding target is a PAD symbol. # The corresponding target is decoder_input shifted by 1 forward. if length_idx < decoder_size - 1: target = decoder_inputs[batch_idx][length_idx + 1] if length_idx == decoder_size - 1 or target == data_utils.PAD_ID: batch_weight[batch_idx] = 0.0 batch_weights.append(batch_weight) return batch_encoder_inputs, batch_decoder_inputs, batch_weights, batch_source_encoder, batch_source_decoder
