title: ModuleNotFoundError When loading a pickled file in tornado
body: <p>I am using tornado framework for loading my machine learning model. I have a popularity class</p>
  
  <pre><code>import numpy as np 
  import pandas as pd
  from pandas import DataFrame
  
  class Popularity():
      users_data = pd.read_csv('~/Desktop/LatentCollaborativeFiltering/lib/seed_data/ratings.csv')
      movies_data = pd.read_csv('~/Desktop/LatentCollaborativeFiltering/lib/seed_data/movies.csv')
      data = pd.merge(users_data, movies_data, left_on="movieId", right_on="movieId")
      data = pd.DataFrame.sort_values(data, ['userId','movieId'],ascending=[0,1])
  
      def __init__(self):
          pass
  
  
      def favoriteMovies(self, activeUser,N):
          topMovies=pd.DataFrame.sort_values(self.data[self.data.userId==activeUser],['rating'],ascending=[0])[:N]
          # return the title corresponding to the movies in topMovies 
          return list(topMovies.title)
  
      def recommend_movies(self):
          return "No recommendation"
  </code></pre>
  
  <p>Now i have another file to pickle an object of this class build_model.py</p>
  
  <pre><code>from __future__ import print_function
  
  import os
  
  from sklearn.externals import joblib
  
  import pandas as pd 
  import numpy as np 
  
  from popularity import Popularity
  
  if __name__ == "__main__":
      popu = Popularity()
  
  
      _CUR_DIR = os.path.dirname(os.path.realpath(__file__))
      _SERIALIZATION_DIR = os.path.join(_CUR_DIR)
  
      if not os.path.exists(_SERIALIZATION_DIR):
          os.makedirs(_SERIALIZATION_DIR)
      model_filename = os.path.join(_SERIALIZATION_DIR, "model.pkl")
  
      joblib.dump(popu, model_filename)
      print("Successfully Built and Picked into models folder")
  </code></pre>
  
  <p>This now builds the model and successfully saves the model in same directory as model.pkl file. But when I load the model in the torando it gives me following error</p>
  
  <pre><code>    [I 180702 06:30:44 server:40] Loading Latent Collaborative Filtering model...
  Traceback (most recent call last):
    File "run.py", line 7, in &lt;module&gt;
      server.main()
    File "/home/rabin/Desktop/LatentCollaborativeFiltering/movies-api/app/server.py", line 45, in main
      MODELS["recommender"] = pickle.load(infile)
  ModuleNotFoundError: No module named 'Popularity'
  </code></pre>
  
  <p>My server.py file is</p>
  
  <pre><code># !/usr/bin/env python
  # -*- coding: utf-8 -*-
  import os
  import logging
  import logging.config
  
  import tornado.ioloop
  import tornado.web
  from tornado.options import options
  
  from sklearn.externals import joblib
  
  from app.settings import MODEL_DIR, ROOT_DIR, _CUR_DIR
  from app.handler import IndexHandler, IrisPredictionHandler
  from app.popularity import Popularity
  import pickle
  
  
  MODELS = {}
  
  
  def load_model(pickle_filename):
      return joblib.load(pickle_filename)
  
  
  def main():
  
      # Get the Port and Debug mode from command line options or default in settings.py
      options.parse_command_line()
  
  
      # create logger for app
      logger = logging.getLogger('app')
      logger.setLevel(logging.INFO)
  
      FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
      logging.basicConfig(format=FORMAT)
  
      # Load ML Models
      logger.info("Loading Latent Collaborative Filtering model...")
     #MODELS["recommender"] = load_model(os.path.join(_CUR_DIR, 'model.pkl'))
      #MODELS["recommender"] = load_model('model.pkl')
      with open(os.path.join(_CUR_DIR, 'model.pkl'), 'rb') as infile:
          MODELS["recommender"] = pickle.load(infile)
  
      urls = [
          (r"/$", IndexHandler),
          (r"/api/recommender/(?P&lt;action&gt;[a-zA-Z]+)?", RecommenderHandler, # action is function in handler
              dict(model=MODELS["recommender"]))
      ]
  
      # Create Tornado application
      application = tornado.web.Application(
          urls,
          debug=options.debug,
          autoreload=options.debug)
  
      # Start Server
      logger.info("Starting App on Port: {} with Debug Mode: {}".format(options.port, options.debug))
      application.listen(options.port)
      tornado.ioloop.IOLoop.current().start()
  </code></pre>
  
  <p>And my handler.py file is</p>
  
  <pre><code>"""
  Request Handlers
  """
  
  import tornado.web
  from tornado import concurrent
  from tornado import gen
  from concurrent.futures import ThreadPoolExecutor
  
  from app.base_handler import BaseApiHandler
  from app.settings import MAX_MODEL_THREAD_POOL
  from app.popularity import Popularity
  
  class IndexHandler(tornado.web.RequestHandler):
      """APP is live"""
  
      def get(self):
          self.write("Movie Recommendation System is Live")
  
      def head(self):
          self.finish()
  
  
  class RecommenderHandler(BaseApiHandler):
  
      _thread_pool = ThreadPoolExecutor(max_workers=MAX_MODEL_THREAD_POOL)
  
      def initialize(self, model, *args, **kwargs):
          self.model = model
          super().initialize(*args, **kwargs)
  
      @concurrent.run_on_executor(executor='_thread_pool')
      def _blocking_predict(self, X):
          target_values = self.model.favoriteMovies(5,10) 
          return target_values
  
  
      @gen.coroutine
      def predict(self, data):
          if type(data) == dict:
              data = [data]
  
          X = []
          for item in data:
              record  = (item.get("user_id"))
              X.append(record)
  
          results = yield self._blocking_predict(X)
          self.respond(results)
  </code></pre>
  
  <p>I have searched too much for the solution but has not found yet that worked for me.
  I cannot load from the console too
  <a href="https://i.stack.imgur.com/qqNOy.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/qqNOy.png" alt="enter image description here"></a></p>