title: How to fix AttributeError: module 'tensorflow' has no attribute 'reset_default_graph'
body: <p>I'm trying to build an ai based chatbot based on a tutorial, they're using python 3.5 and tensorflow 1.0.0. </p>
  
  <p>I have crossed checked everything, my virtual environment is running from inside the anaconda explorer. I even ran it from the terminal and activated it. I'm importing everything correctly and all. Although I installed tensorflow 1.0.0 using anaconda terminal with virtual env activated, when I look it up in anacoda it says 1.1.0. I don't know if there is major difference in there or not, so that thing i'm not sure about.
  Upon running this code
  <strong>tf.reset_default_graph()
  session = tf.InteractiveSession()</strong>
  Instead of spyder successfully running, it shows an error that AttributeError: module 'tensorflow' has no attribute 'reset_default_graph'.</p>
  
  <pre><code>import numpy as np
  import tensorflow as tf
  import re
  import time 
  ### Phase 1: Data Preprocessing ###
  
  # Importing the dataset
  lines = open('movie_lines.txt', encoding = 'utf-8', errors = 'ignore').read().split('\n')
  conversations = open('movie_conversations.txt', encoding = 'utf-8', errors = 'ignore').read().split('\n')
  
  # Creating a dictionary that maps each line with its id
  id_to_line = {}
  for line in lines:
      _line = line.split(' +++$+++ ')
      if len(_line) == 5:
          id_to_line[_line[0]] = _line[4]
  
  # Creating a list of conversations
  conversations_ids = []
  for conversation in conversations[:-1]:
      _conversation = conversation.split(' +++$+++ ')[-1][1:-1].replace("'", "").replace(" ", "")
      conversations_ids.append(_conversation.split(','))
  
  # Getting questions and answers seperately
  questions= []
  answers = []
  for conversation in conversations_ids:
      for i in range(len(conversation) - 1):
          questions.append(id_to_line[conversation[i]])
          answers.append(id_to_line[conversation[i]])
  
  # Cleaning Texts by removing apostrophes and putting everything in lowercase
  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"how's", "how is", text)
      text = re.sub(r"\'ll", " will", text)
      text = re.sub(r"\'ve", " have", text)
      text = re.sub(r"\'re", " are", text)
      text = re.sub(r"\'d", " would", text)
      text = re.sub(r"n't", " not", text)
      text = re.sub(r"won't", "will not", text)
      text = re.sub(r"can't", "cannot", text)
      text = re.sub(r"[-()\"#/@;:&lt;&gt;{}`+=~|.!?,]", "", text)
      return text
  
  # Cleaning Questions
  clean_questions = []
  for question in questions:
      clean_questions.append(clean_text(question))
  
  # Cleaning Answers
  clean_answers = []
  for answer in answers:
      clean_answers.append(clean_text(answer))
  
  # Filtering out the questions and answers that are too short or too long    
  short_questions = []
  short_answers = []
  i = 0
  for question in clean_questions:
      if 2 &lt;= len(question.split()) &lt;= 25:
          short_questions.append(question)
          short_answers.append(clean_answers[i])
      i += 1
  clean_questions = []
  clean_answers = []
  i = 0
  for answer in short_answers:
      if 2 &lt;= len(answer.split()) &lt;= 25:
          clean_answers.append(answer)
          clean_questions.append(short_questions[i])
      i += 1
  
  
  # Creating a Dictionary to map each word to its number of occurences
  word_to_count = {}
  for question in clean_questions:
      for word in question.split():
          if word not in word_to_count:
              word_to_count[word] = 1
          else:
              word_to_count[word] += 1
  
  for answer in clean_answers:
      for word in answer.split():
          if word not in word_to_count:
              word_to_count[word] = 1
          else:
              word_to_count[word] += 1
  
  # Doing Tokenization &amp; Filtering non-frequent words
  threshold = 20
  ques_words_to_int = {}
  word_count = 0
  for word, count in word_to_count.items():
      if count &gt;= threshold:
          ques_words_to_int[word] = word_count
          word_count += 1
  
  ans_words_to_int = {}
  word_count = 0
  for word, count in word_to_count.items():
      if count &gt;= threshold:
          ans_words_to_int[word] = word_count
          word_count += 1 
  
  # Adding last tokens to above two Dictionaries
  tokens = ['&lt;PAD&gt;', '&lt;EOS&gt;', '&lt;OUT&gt;', '&lt;SOS&gt;']
  for token in tokens:
      ques_words_to_int[token] = len(ques_words_to_int) + 1
  for token in tokens:
      ans_words_to_int[token] = len(ans_words_to_int) + 1
  
  # Creating Inverse Dictionary of ans_words_to_int
  ans_ints_to_word = {w_i: w for w, w_i in ans_words_to_int.items()}
  
  # Adding &lt;EOS&gt; to end of every answer for SEQ2SEQ Decoding
  for i in range(len(clean_answers)):
      clean_answers[i] += ' &lt;EOS&gt;'
  
  # Translating all ques &amp; ans into int &amp; replacing all words, filtered out by &lt;OUT&gt;
  ques_into_int = []
  for question in clean_questions:
      ints = []
      for word in question.split():
          if word not in ques_words_to_int:
              ints.append(ques_words_to_int['&lt;OUT&gt;'])
          else:
              ints.append(ques_words_to_int[word])
      ques_into_int.append(ints)
  
  ans_into_int = []
  for answer in clean_answers:
      ints = []
      for word in answer.split():
          if word not in ans_words_to_int:
              ints.append(ans_words_to_int['&lt;OUT&gt;'])
          else:
              ints.append(ans_words_to_int[word])
      ans_into_int.append(ints)
  
  # Sorting ques &amp; ans by length of questions
  sorted_clean_questions = []
  sorted_clean_answers = []
  for length in range(1, 25):
      for i in enumerate(ques_into_int):
          if len(i[1]) == length:
              sorted_clean_questions.append(ques_into_int[i[0]])
              sorted_clean_answers.append(ans_into_int[i[0]])
  
  ### Phase 2: Building SEQ2SEQ Model ###
  
  # Creating placeholders for inputs and targets
  def model_inputs():
      inputs = tf.placeholder(tf.int32, [None, None], name = 'input')
      targets = tf.placeholder(tf.int32, [None, None], name = 'input')
      lr = tf.placeholder(tf.float32, name = 'Learning_rate')
      keep_prob = tf.placeholder(tf.float32, name = 'Keep_prob')
      return inputs, targets, lr, keep_prob
  
  # Preprocessing the targets
  def preprocess_targets(targets, word_to_int, batch_size):
      left_side = tf.fill([batch_size, 1], word_to_int['&lt;SOS&gt;'])
      right_side = tf.strided_slice(targets, [0,0], [batch_size, -1], [1,1])
      preprocessed_targets = tf.concat([left_side, right_side], 1)
      return preprocessed_targets
  
  # Creating the Encoder RNN Layer
  def encoder_rnn_layer(rnn_inputs, rnn_size, num_layers, keep_prob, sequence_length):
      lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)
      lstm_dropout = tf.contrib.rnn.DropoutWrapper(lstm, input_keep_prob = keep_prob)
      encoder_cell = tf.contrib.rnn.MultiRNNCell([lstm_dropout] * num_layers)
      _, encoder_state = tf.nn.bidirectional_dynamic_rnn(cell_fw = encoder_cell,
                                                         cell_bw = encoder_cell,
                                                         sequence_length = sequence_length,
                                                         inputs = rnn_inputs,
                                                         dtype = tf.float32)
      return encoder_state
  
  # Decoding the Training Set
  def decode_training_set(encoder_state, decoder_cell, decoder_embedded_input, sequence_length, decoding_scope, output_function, keep_prob, batch_size):
      attention_states = tf.zeros([batch_size, 1, decoder_cell.output_size])
      attention_keys, attention_values, attention_score_function, attention_construct_function = tf.contrib.seq2seq.prepare_attention(attention_states, attention_option = "bahdanau", num_units = decoder_cell.output_size)
      training_decoder_function = tf.contrib.seq2seq.attention_decoder_fn_train(encoder_state[0],
                                                                                attention_keys,
                                                                                attention_values,
                                                                                attention_score_function,
                                                                                attention_construct_function,
                                                                                name = "attn_dec_train")
      decoder_output, decoder_final_state, decoder_final_context_state = tf.contrib.seq2seq.dynamic_rnn_decoder(decoder_cell,
                                                                                                                training_decoder_function,
                                                                                                                decoder_embedded_input,
                                                                                                                sequence_length,
                                                                                                                scope = decoding_scope)
      decoder_output_dropout = tf.nn.dropout(decoder_output, keep_prob)
      return output_function(decoder_output_dropout)
  
  # Decoding the test/validation set
  def decode_test_set(encoder_state, decoder_cell, decoder_embeddings_matrix, sos_id, eos_id, maximum_length, num_words, decoding_scope, output_function, keep_prob, batch_size):
      attention_states = tf.zeros([batch_size, 1, decoder_cell.output_size])
      attention_keys, attention_values, attention_score_function, attention_construct_function = tf.contrib.seq2seq.prepare_attention(attention_states, attention_option = "bahdanau", num_units = decoder_cell.output_size)
      test_decoder_function = tf.contrib.seq2seq.attention_decoder_fn_inference(output_function,
                                                                                encoder_state[0],
                                                                                attention_keys,
                                                                                attention_values,
                                                                                attention_score_function,
                                                                                attention_construct_function,
                                                                                decoder_embeddings_matrix,
                                                                                sos_id,
                                                                                eos_id,
                                                                                maximum_length,
                                                                                num_words,
                                                                                name = "attn_dec_inf")
      test_predictions, decoder_final_state, decoder_final_context_state = tf.contrib.seq2seq.dynamic_rnn_decoder(decoder_cell,
                                                                                                                  test_decoder_function,
                                                                                                                  scope = decoding_scope)
      return test_predictions
  
  # Creating the Decoder RNN
  def decoder_rnn(decoder_embedded_input, decoder_embeddings_matrix, encoder_state, num_words, sequence_length, rnn_size, num_layers, word_to_int, keep_prob, batch_size):
      with tf.variable_scope("decoding") as decoding_scope:
          lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)
          lstm_dropout = tf.contrib.rnn.DropoutWrapper(lstm, input_keep_prob = keep_prob)
          decoder_cell = tf.contrib.rnn.MultiRNNCell([lstm_dropout] * num_layers)
          weights = tf.truncated_normal_initializer(stddev = 0.1)
          biases = tf.zeros_initializer()
          output_function = lambda x: tf.contrib.layers.fully_connected(x,
                                                                        num_words,
                                                                        None,
                                                                        scope = decoding_scope,
                                                                        weights_initializer = weights,
                                                                        biases_initializer = biases)
          training_predictions = decode_training_set(encoder_state,
                                                     decoder_cell,
                                                     decoder_embedded_input,
                                                     sequence_length,
                                                     decoding_scope,
                                                     output_function,
                                                     keep_prob,
                                                     batch_size)
          decoding_scope.reuse_variables()
          test_predictions = decode_test_set(encoder_state,
                                             decoder_cell,
                                             decoder_embeddings_matrix,
                                             word_to_int['&lt;SOS&gt;'],
                                             word_to_int['&lt;EOS&gt;'],
                                             sequence_length - 1,
                                             num_words,
                                             decoding_scope,
                                             output_function,
                                             keep_prob,
                                             batch_size)
      return training_predictions, test_predictions
  
  # Building the SEQ2SEQ Model
  def seq2seq_model(inputs, targets, keep_prob, batch_size, sequence_length, answers_num_words, questions_num_words, encoder_embedding_size, decoder_embedding_size, rnn_size, num_layers, ques_words_to_int):
      encoder_embedded_input = tf.contrib.layers.embed_sequence(inputs,
                                                                answers_num_words + 1,
                                                                encoder_embedding_size,
                                                                initializer = tf.random_uniform_initializer(0, 1))
      encoder_state = encoder_rnn_layer(encoder_embedded_input, rnn_size, num_layers, keep_prob, sequence_length)
      preprocessed_targets = preprocess_targets(targets, ques_words_to_int, batch_size)
      decoder_embeddings_matrix = tf.Variable(tf.random_uniform([questions_num_words + 1, decoder_embedding_size], 0, 1))
      decoder_embedded_input = tf.nn.embedding_lookup(decoder_embeddings_matrix, preprocessed_targets)
      training_predictions, test_predictions = decoder_rnn(decoder_embedded_input,
                                                           decoder_embeddings_matrix,
                                                           encoder_state,
                                                           questions_num_words,
                                                           sequence_length,
                                                           rnn_size,
                                                           num_layers,
                                                           ques_words_to_int,
                                                           keep_prob,
                                                           batch_size)
      return training_predictions, test_predictions  
  
  ### Phase 3: Training the SEQ2SEQ Model ###
  
  # Setting the Hyperparameters
  epochs = 100
  batch_size = 32
  rnn_size = 1024
  num_layers = 3
  encoding_embedding_size = 1024
  decoding_embedding_size = 1024
  learning_rate = 0.001
  learning_rate_decay = 0.9
  min_learning_rate = 0.0001
  keep_probability = 0.5
  
  # Defining a session
  tf.reset_default_graph()
  session = tf.InteractiveSession()   
  </code></pre>
  
  <p>I fixed the issue by deactivating and reactivating the virtual env and then running the command "pip install --user tensorflow=1.0.0" and also <code>pip3 install --user tensorflow=1.0.0</code> and then that attribute error related to tf.reset_default_graph() session = tf.InteractiveSession() was solved</p>