text: Title: TFLearn model not predicting when using gunicorn
  Body: I have the following class as part of my project:
  
      class LSTMSentimentClassifier(SentimentClassifier):
      def __init__(self, model_name: str, model_location: str, wordvec_model_location: str, lexicon_location: str):
          super(LSTMSentimentClassifier, self).__init__("LSTM_{}".format(model_name))
          self.logger = logging.getLogger(__name__)
          self.model_name = model_name
          self.model_location = model_location
  
          self.numDimensions = 300
          self.num_hidden = 128
          self.learning_rate = 0.001
          self.drop_out = 0.8
  
          tf.reset_default_graph()
  
          net = input_data(shape=[None, self.numDimensions])
          net = embedding(net, input_dim=20000, output_dim=self.num_hidden)
          net = tflearn.lstm(net, self.num_hidden, return_seq=True)
          net = dropout(net, self.drop_out)
          net = tflearn.lstm(net, self.num_hidden, return_seq=True)
          net = dropout(net, self.drop_out)
          net = fully_connected(net, 2, activation='softmax')
          net = regression(net, optimizer='adam', learning_rate=self.learning_rate,
                           loss='mean_square')
  
          self.nn = tflearn.DNN(net, clip_gradients=0., tensorboard_verbose=0)
          self.nn.load(model_location)
  
          self.wordvec_model = KeyedVectors.load_word2vec_format(wordvec_model_location)
          self.lexicon = pickle.load(open(lexicon_location, 'rb'))
  
          self.logger.info("Inside NRCSentimentClassifier -- "
                           "Loaded NRC model file for the model: {}".format(model_name))
  
  
      def word_to_vec(self, sentence: str) -> np.array:
          if type(sentence) == str:
              sentence = sentence
          else:
              sentence = sentence[0]
          words = sentence.split()
          featureVec = [0] * self.numDimensions
          for word in words:
              try:
                  try:
                      featureVec = featureVec + (self.wordvec_model[word] + self.lexicon[word])
                  except:
                      featureVec = featureVec + self.wordvec_model[word]
              except:
                  featureVec
          Vec = [max(0, val) for val in featureVec]
          return np.array(Vec)
  
  
      def predict_sentiment(self, text: str) -> list:
          text_vec = self.word_to_vec(text)
          sentiment_classes = ["positive", "negative"]
  
          labels_with_probabilities = {}
          model_probabilities = self.nn.predict([text_vec])[0]
          for label, probability in zip(sentiment_classes, model_probabilities):
              labels_with_probabilities[label] = probability
          labels_with_probabilities_sorted = sorted(labels_with_probabilities.items(), key=lambda x: x[1], reverse=True)
          print(labels_with_probabilities_sorted)
          output = []
          for label, probability in labels_with_probabilities_sorted:
              label_val = str(label)
              probability_val = float(probability)
              output.append(SentimentScore(sentence=text, sentiment_class=SentimentClass.get_label_NRC(label_val),
                                           confidence_score=probability_val, sentiment_strength=1.0))
  
          return output
  
  When I run this class as part of a python script eg `python classifier.py` it works with a main method and calling the class with the file paths, giving predictions for sentences that I pass into it, `model.predict_sentiment(sentence)`, where `model = LSTMSentimentClassifier("lstm", path_to_classifier, path_to_wordembeddings, path_to_lexicon)`
  
  However this classifier is part of a larger project that uses `gunicorn` and `falcon`. I can start the project and it loads fine, but when I make an api call using the classifier, the classifier gets stuck at the predict. 
  
  I know that the model has loaded correctly but I am confused as to why I can use the above class when running the single python file, but the class predict doesn't work when using it as part of the gunicorn process.
  
  The file locations are correct. I have used prints to verify that a sentence is coming in, it is correctly being turned into a word vector in the correct form and passed into the `nn.predict`, however it is here that the class stops working and gunicorn times out.
  
  Any help would be much appreciated.