我遇到此错误。请帮帮我。
当我尝试执行代码时，我收到InvalidArgumentError。
我不知道是什么导致了此错误。
我已经多次检查此代码。
甚至我都将其与在线代码进行了比较。但是没有解决方案。
请提出一些使此代码正常工作的方法。
这是代码：-
import numpy as np
import tensorflow as tf
import re
import time
#fetch the dataset
conversations=open('movie_conversations.txt',encoding='utf-8',errors='ignore').read().split('\n')
lines=open('movie_lines.txt',encoding='utf-8',errors='ignore').read().split('\n')
#create dictionary of line id and line
id2line={}
for line in lines:
_line=line.split(' +++$+++ ')
if len(_line) == 5:
id2line[_line[0]]=_line[4]
conversation_ids=[]
for conversation in conversations[:-1]:
_conversation=conversation.split(' +++$+++ ')[-1][1:-1].replace("'","").replace(' ','')
conversation_ids.append(_conversation.split(','))
questions=[]
answers=[]
for conversation in conversation_ids:
for i in range(len(conversation)-1):
questions.append(id2line[conversation[i]])
answers.append(id2line[conversation[i+1]])
def clean_text(text):
text=text.lower()
text=re.sub(r"i'm","i am",text)
text=re.sub(r"he's","he is",text)
text=re.sub(r"she's","she is",text)
text=re.sub(r"that's","that is",text)
text=re.sub(r"what's","what is",text)
text=re.sub(r"where's","where is",text)
text=re.sub(r"\'ll"," will",text)
text=re.sub(r"\'ve"," have",text)
text=re.sub(r"\'d"," would",text)
text=re.sub(r"\'re"," are",text)
text=re.sub(r"won't"," will not",text)
text=re.sub(r"can't"," can not",text)
text=re.sub(r"[-()*/#{}=+\'#@:;<>|.?]","",text)
return text
clean_questions=[]
clean_answers=[]
for question in questions:
clean_questions.append(clean_text(question))
for answer in answers:
clean_answers.append(clean_text(answer))
word2count={}
for question in clean_questions:
for word in question.split():
if word not in word2count:
word2count[word]=1
else:
word2count[word]+=1
for answer in clean_answers:
for word in answer.split():
if word not in word2count:
word2count[word]=1
else:
word2count[word]+=1
threshold=20
word_count=0
question2int={}
answer2int={}
for word,count in word2count.items():
if count >=threshold:
question2int[word]=word_count
word_count+=1
word_count=0
for word,count in word2count.items():
if count >=threshold:
answer2int[word]=word_count
word_count+=1
tokens = ['<PAD>','<EOS>','<OUT>','<SOS>']
for token in tokens:
question2int[token]=len(question2int)+1
for token in tokens:
answer2int[token]=len(answer2int)+1
id2answer={w_id:w for w,w_id in answer2int.items()}
for i in range(len(clean_answers)):
clean_answers[i]+=' <EOS>'
question_into_int=[]
answers_into_int=[]
for question in clean_questions:
ints=[]
for word in question.split():
if word not in question2int:
ints.append(question2int['<OUT>'])
else:
ints.append(question2int[word])
question_into_int.append(ints)
for answer in clean_answers:
ints=[]
for word in answer.split():
if word not in answer2int:
ints.append(answer2int['<OUT>'])
else:
ints.append(answer2int[word])
answers_into_int.append(ints)
sorted_clean_question=[]
sorted_clean_answers=[]
for length in range(1,30+1):
for i in enumerate(question_into_int):
if len(i[1])==length:
sorted_clean_question.append(question_into_int[i[0]])
sorted_clean_answers.append(answers_into_int[i[0]])
def inputs():
inputs=tf.placeholder(tf.int32,shape=[None,None],name='inputs')
targets=tf.placeholder(tf.int32,shape=[None,None],name='targets')
lr=tf.placeholder(tf.float32,name='learning_rate')
keep_prob=tf.placeholder(tf.float32,name='keep_prob')
return inputs,targets,lr,keep_prob
def target_preprocessing(targets,word2int,batch_size):
left=tf.fill([batch_size,1],word2int['<SOS>'])
right=tf.strided_slice(targets,[0,0],[batch_size,-1],[1,1])
return tf.concat([left,right],1)
def encoding_layer(rnn_inputs, rnn_size, num_layers, keep_prob,
source_vocab_size,
encoding_embedding_size):
"""
:return: tuple (RNN output, RNN state)
"""
embed = tf.contrib.layers.embed_sequence(rnn_inputs,
vocab_size=source_vocab_size,
embed_dim=encoding_embedding_size)
stacked_cells = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.DropoutWrapper(tf.contrib.rnn.LSTMCell(rnn_size), keep_prob) for _ in range(num_layers)])
outputs, state = tf.nn.dynamic_rnn(stacked_cells,
embed,
dtype=tf.float32)
return outputs, state
def decoding_layer_infer(encoder_state, dec_cell, dec_embeddings, start_of_sequence_id,
end_of_sequence_id, max_target_sequence_length,
vocab_size, output_layer, batch_size, keep_prob):
"""
Create a inference process in decoding layer
:return: BasicDecoderOutput containing inference logits and sample_id
"""
dec_cell = tf.contrib.rnn.DropoutWrapper(dec_cell,
output_keep_prob=keep_prob)
helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(dec_embeddings,
tf.fill([batch_size], start_of_sequence_id),
end_of_sequence_id)
decoder = tf.contrib.seq2seq.BasicDecoder(dec_cell,
helper,
encoder_state,
output_layer)
outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(decoder,
impute_finished=True,
maximum_iterations=max_target_sequence_length)
return outputs
def decoding_layer_train(encoder_state, dec_cell, dec_embed_input,
target_sequence_length, max_summary_length,
output_layer, keep_prob):
"""
Create a training process in decoding layer
:return: BasicDecoderOutput containing training logits and sample_id
"""
print(target_sequence_length)
dec_cell = tf.contrib.rnn.DropoutWrapper(dec_cell,
output_keep_prob=keep_prob)
# for only input layer
helper = tf.contrib.seq2seq.TrainingHelper(dec_embed_input,
tf.reshape(target_sequence_length,[-1]),time_major=False)
decoder = tf.contrib.seq2seq.BasicDecoder(dec_cell,
helper,
encoder_state,
output_layer)
# unrolling the decoder layer
outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(decoder,
impute_finished=True,
maximum_iterations=max_summary_length)
return outputs
def decoding_layer(dec_input, encoder_state,
target_sequence_length, max_target_sequence_length,
rnn_size,
num_layers, target_vocab_to_int, target_vocab_size,
batch_size, keep_prob, decoding_embedding_size):
"""
Create decoding layer
:return: Tuple of (Training BasicDecoderOutput, Inference BasicDecoderOutput)
"""
target_vocab_size = len(target_vocab_to_int)
dec_embeddings = tf.Variable(tf.random_uniform([target_vocab_size, decoding_embedding_size]))
dec_embed_input = tf.nn.embedding_lookup(dec_embeddings, dec_input)
cells = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.LSTMCell(rnn_size) for _ in range(num_layers)])
with tf.variable_scope("decode"):
output_layer = tf.layers.Dense(target_vocab_size)
train_output = decoding_layer_train(encoder_state,
cells,
dec_embed_input,
target_sequence_length,
max_target_sequence_length,
output_layer,
keep_prob)
with tf.variable_scope("decode", reuse=True):
infer_output = decoding_layer_infer(encoder_state,
cells,
dec_embeddings,
target_vocab_to_int['<SOS>'],
target_vocab_to_int['<EOS>'],
max_target_sequence_length,
target_vocab_size,
output_layer,
batch_size,
keep_prob)
return (train_output, infer_output)
def seq2seq_model(input_data, target_data, keep_prob, batch_size,
target_sequence_length,
max_target_sentence_length,
source_vocab_size, target_vocab_size,
enc_embedding_size, dec_embedding_size,
rnn_size, num_layers, target_vocab_to_int):
"""
Build the Sequence-to-Sequence model
:return: Tuple of (Training BasicDecoderOutput, Inference BasicDecoderOutput)
"""
enc_outputs, enc_states = encoding_layer(input_data,
rnn_size,
num_layers,
keep_prob,
source_vocab_size,
enc_embedding_size)
dec_input = target_preprocessing(target_data,
target_vocab_to_int,
batch_size)
train_output, infer_output = decoding_layer(dec_input,
enc_states,
target_sequence_length,
max_target_sentence_length,
rnn_size,
num_layers,
target_vocab_to_int,
target_vocab_size,
batch_size,
keep_prob,
dec_embedding_size)
return train_output, infer_output
epochs=10
batch_size=64
rnn_size=512
num_layers=1
encoding_embedding_size=decoder_embedding_size=512
learning_rate=0.01
learning_rate_decay=0.9
min_learning_rate=0.0001
keep_probability=0.5
max_target_seq_len=max([len(data) for data in sorted_clean_answers])
tf.reset_default_graph()
session=tf.Session()
inputs_,targets,lr,keep_prob=inputs()
sequence_length=tf.placeholder(tf.int32,None,name='sequence_length')
input_shape=tf.shape(inputs_)
train_predictions,test_predictions=seq2seq_model(tf.reverse(inputs_,[-1]),
targets,
keep_prob,
batch_size,
sequence_length,
max_target_seq_len,
len(question2int),
len(answer2int),
encoding_embedding_size,
decoder_embedding_size,
rnn_size,
num_layers,
answer2int)
training_predictions=tf.identity(train_predictions.rnn_output,name='training_preds')
with tf.name_scope('optimization'):
loss_error=tf.contrib.seq2seq.sequence_loss(training_predictions,targets,tf.ones([input_shape[0],sequence_length]))
optimizer=tf.train.GradientDescentOptimizer(learning_rate)
gradients=optimizer.compute_gradients(loss_error)
clipped_gradients=[(tf.clip_by_value(grad_tensor,-5.,5.),grad_variable) for grad_tensor,grad_variable in gradients if grad_tensor is not None]
optimizer_gradient_clipping=optimizer.apply_gradients(clipped_gradients)
def apply_padding(batch_of_sequences, word2int):
max_sequence_length = max([len(sequence) for sequence in batch_of_sequences])
return [sequence + [word2int['<PAD>']] * (max_sequence_length - len(sequence)) for sequence in batch_of_sequences]
def split_into_batches(questions, answers, batch_size):
for batch_index in range(0, len(questions) // batch_size):
start_index = batch_index * batch_size
questions_in_batch = questions[start_index : start_index + batch_size]
answers_in_batch = answers[start_index : start_index + batch_size]
padded_questions_in_batch = np.array(apply_padding(questions_in_batch, question2int))
padded_answers_in_batch = np.array(apply_padding(answers_in_batch, answer2int))
yield padded_questions_in_batch, padded_answers_in_batch
training_validation_split = int(len(sorted_clean_question) * 0.15)
training_questions = sorted_clean_question[training_validation_split:]
training_answers = sorted_clean_answers[training_validation_split:]
validation_questions = sorted_clean_question[:training_validation_split]
validation_answers = sorted_clean_answers[:training_validation_split]
batch_index_check_training_loss = 100
batch_index_check_validation_loss = ((len(training_questions)) // batch_size // 2) - 1
total_training_loss_error = 0
list_validation_loss_error = []
early_stopping_check = 0
early_stopping_stop = 100
checkpoint = "chatbot_weights.ckpt"
session.run(tf.global_variables_initializer())
for epoch in range(1, epochs + 1):
for batch_index, (padded_questions_in_batch, padded_answers_in_batch) in enumerate(split_into_batches(training_questions, training_answers, batch_size)):
starting_time = time.time()
_, batch_training_loss_error = session.run([optimizer_gradient_clipping, loss_error], {inputs_: padded_questions_in_batch,
targets: padded_answers_in_batch,
lr: learning_rate,
sequence_length: padded_answers_in_batch.shape[1],
keep_prob: keep_probability})
total_training_loss_error += batch_training_loss_error
ending_time = time.time()
batch_time = ending_time - starting_time
if batch_index % batch_index_check_training_loss == 0:
print('Epoch: {:>3}/{}, Batch: {:>4}/{}, Training Loss Error: {:>6.3f}, Training Time on 100 Batches: {:d} seconds'.format(epoch,
epochs,
batch_index,
len(training_questions) // batch_size,
total_training_loss_error / batch_index_check_training_loss,
int(batch_time * batch_index_check_training_loss)))
total_training_loss_error = 0
if batch_index % batch_index_check_validation_loss == 0 and batch_index > 0:
total_validation_loss_error = 0
starting_time = time.time()
for batch_index_validation, (padded_questions_in_batch, padded_answers_in_batch) in enumerate(split_into_batches(validation_questions, validation_answers, batch_size)):
batch_validation_loss_error = session.run(loss_error, {inputs_: padded_questions_in_batch,
targets: padded_answers_in_batch,
lr: learning_rate,
sequence_length: padded_answers_in_batch.shape[1],
keep_prob: 1})
total_validation_loss_error += batch_validation_loss_error
ending_time = time.time()
batch_time = ending_time - starting_time
average_validation_loss_error = total_validation_loss_error / (len(validation_questions) / batch_size)
print('Validation Loss Error: {:>6.3f}, Batch Validation Time: {:d} seconds'.format(average_validation_loss_error, int(batch_time)))
learning_rate *= learning_rate_decay
if learning_rate < min_learning_rate:
learning_rate = min_learning_rate
list_validation_loss_error.append(average_validation_loss_error)
if average_validation_loss_error <= min(list_validation_loss_error):
print('I speak better now!!')
early_stopping_check = 0
saver = tf.train.Saver()
saver.save(session, checkpoint)
else:
print("Sorry I do not speak better, I need to practice more.")
early_stopping_check += 1
if early_stopping_check == early_stopping_stop:
break
if early_stopping_check == early_stopping_stop:
print("My apologies, I cannot speak better anymore. This is the best I can do.")
break
print("Game Over")
我遇到以下错误：-
InvalidArgumentError: indices[32,0] = 9547 is not in [0, 9547)
[[Node: embedding_lookup = GatherV2[Taxis=DT_INT32, Tindices=DT_INT32, Tparams=DT_FLOAT, _class=["loc:@optimization/GradientDescent/update_Variable/ApplyGradientDescent"], _device="/job:localhost/replica:0/task:0/device:CPU:0"](Variable/read, concat, embedding_lookup/axis)]]
Caused by op 'embedding_lookup', defined at:
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/spyder/utils/ipython/start_kernel.py", line 269, in <module>
main()
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/spyder/utils/ipython/start_kernel.py", line 265, in main
kernel.start()
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/ipykernel/kernelapp.py", line 486, in start
self.io_loop.start()
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tornado/platform/asyncio.py", line 127, in start
self.asyncio_loop.run_forever()
File "/home/mayur/Apps/anaconda3/lib/python3.6/asyncio/base_events.py", line 422, in run_forever
self._run_once()
File "/home/mayur/Apps/anaconda3/lib/python3.6/asyncio/base_events.py", line 1432, in _run_once
handle._run()
File "/home/mayur/Apps/anaconda3/lib/python3.6/asyncio/events.py", line 145, in _run
self._callback(*self._args)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tornado/platform/asyncio.py", line 117, in _handle_events
handler_func(fileobj, events)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tornado/stack_context.py", line 276, in null_wrapper
return fn(*args, **kwargs)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py", line 450, in _handle_events
self._handle_recv()
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py", line 480, in _handle_recv
self._run_callback(callback, msg)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py", line 432, in _run_callback
callback(*args, **kwargs)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tornado/stack_context.py", line 276, in null_wrapper
return fn(*args, **kwargs)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/ipykernel/kernelbase.py", line 283, in dispatcher
return self.dispatch_shell(stream, msg)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/ipykernel/kernelbase.py", line 233, in dispatch_shell
handler(stream, idents, msg)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/ipykernel/kernelbase.py", line 399, in execute_request
user_expressions, allow_stdin)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/ipykernel/ipkernel.py", line 208, in do_execute
res = shell.run_cell(code, store_history=store_history, silent=silent)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/ipykernel/zmqshell.py", line 537, in run_cell
return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py", line 2662, in run_cell
raw_cell, store_history, silent, shell_futures)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py", line 2785, in _run_cell
interactivity=interactivity, compiler=compiler, result=result)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py", line 2903, in run_ast_nodes
if self.run_code(code, result):
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py", line 2963, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-9-3bc9cc99bcae>", line 338, in <module>
answer2int)
File "<ipython-input-9-3bc9cc99bcae>", line 302, in seq2seq_model
dec_embedding_size)
File "<ipython-input-9-3bc9cc99bcae>", line 242, in decoding_layer
dec_embed_input = tf.nn.embedding_lookup(dec_embeddings, dec_input)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/embedding_ops.py", line 308, in embedding_lookup
transform_fn=None)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/embedding_ops.py", line 131, in _embedding_lookup_and_transform
result = _clip(array_ops.gather(params[0], ids, name=name),
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/array_ops.py", line 2736, in gather
return gen_array_ops.gather_v2(params, indices, axis, name=name)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/gen_array_ops.py", line 3065, in gather_v2
"GatherV2", params=params, indices=indices, axis=axis, name=name)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py", line 787, in _apply_op_helper
op_def=op_def)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/ops.py", line 3392, in create_op
op_def=op_def)
File "/home/mayur/Apps/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/ops.py", line 1718, in __init__
self._traceback = self._graph._extract_stack() # pylint: disable=protected-access
InvalidArgumentError (see above for traceback): indices[32,0] = 9547 is not in [0, 9547)
[[Node: embedding_lookup = GatherV2[Taxis=DT_INT32, Tindices=DT_INT32, Tparams=DT_FLOAT, _class=["loc:@optimization/GradientDescent/update_Variable/ApplyGradientDescent"], _device="/job:localhost/replica:0/task:0/device:CPU:0"](Variable/read, concat, embedding_lookup/axis)]]