class WebServer(object): logging.basicConfig(level=logging.INFO) def __init__(self, configMap): self.db = DatabaseInterface(configMap['data_dir']) # numberToServe: the number of items finally served to the users self.numberToServe = configMap['numberToServe'] self.log = logging.getLogger(__name__) def start(self): # each object here simulates the API calls through network # passing an object A to the constructor of B means A will communication to B self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.userAnalyzer = UserAnalyzer() self.modelStore = ModelStore() self.offlineLearner = OfflineLearner(self.db, self.modelStore) self.onlineLearner = OnlineLearner(self.db, self.modelStore) self.offlineLearner.trainModel() # when we start the webserver, we should let offline learner to train the models, # such that, after the start(), we can start to give recommendation self.recEngine = RecEngine(self.userAnalyzer, self.modelStore, self.db.extract(DatabaseInterface.USER_ACTIVITY_KEY)) def getAction(self, action): assert (isinstance(action, Action)) # taking the action from users self.onlineLearner.trainModel(action) # analyze action type, and save the registered user's action actionType = self.userAnalyzer.analyzeAction(action) if actionType == "registered": self.log.info("Recording action %s" % action) self.db.putAction(action) def provideRecommendation(self, request): # return the ID's for the recommended items assert (isinstance(request, Request)) # provide recommendations to user self.log.info("responding to request: %s" % request) recommendations = self.recEngine.provideRecommendation(request) recsReranked = self.ranker.rerank(recommendations) return recsReranked # a list of item ids def renderRecommendation(self, request): assert (isinstance(request, Request)) recsReranked = self.provideRecommendation(request) # for the purpose of testing, we sort the index, output item names # output is ordered by the id value return self.db.extract(DatabaseInterface.INVENTORY_KEY).loc[recsReranked].sort_index() def increment(self): self.log.info("incrementing the system, update the models") # increment the whole system by one day, trigger offline training self.offlineLearner.trainModel() self.modelStore.cleanOnlineModel() self.recEngine.resetCache() def getFromInventory(self, itemId): return self.db.extract(DatabaseInterface.INVENTORY_KEY).loc[itemId]
def start(self): # DatabaseQueries.createTables() self.modelStore = ModelStore() # "database" of models self.userAnalyzer = UserAnalyzer( ) # classify user type: anonymous? registered new? or registered old? self.trainingCenter = TrainingCenter(self.modelStore) self.ranker = Ranker() # just rank the recommended items # once start should firstly train the models and immediately have recommendations on home page self.trainingCenter.trainModel( ) # NOTE: need to firstly train models once for a welcome page self.recEngine = RecEngine(self.userAnalyzer, self.modelStore, DatabaseQueries.getNumRatingsPerUser())
class WebServer(object): logging.basicConfig(level=logging.INFO) #configMap is in main def __init__(self, configMap): self.db = DatabaseInterface(configMap['data_dir']) self.numberToServe = configMap['numberToServe'] self.log = logging.getLogger(__name__) #要用key idk why, why not a direct string? #initialize everything def start(self): self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.userAnalyzer = UserAnalyzer() self.modelStore = ModelStore() self.offlineLearner = OfflineLearner(self.db, self.modelStore) self.onlineLearner = OnlineLearner(self.db, self.modelStore) #so that immediately after we start, we can start to give recommendations self.offlineLearner.trainModel() #had to extract it here self.recEngine = RecEngine( self.userAnalyzer, self.modelStore, self.db.extract(DatabaseInterface.USER_ACTIVITY_KEY)) def getAction(self, action): assert (isinstance(action, Action)) self.onlineLearner.trainModel(action) actionType = self.userAnalyzer.analyzeAction(action) if actionType == "registered": self.db.putAction(action) def provideRec(self, request): assert (isinstance(request, Request)) rec = self.recEngine.provideRec(request) recReRanked = self.ranker.rerank(rec) return recReRanked def renderRec(self, request): assert (isinstance(request, Request)) recReRanked = self.provideRec(request) return self.db.extract( DatabaseInterface.INVENTORY_KEY).loc[recReRanked].sort_index() def increment(self): #offline, online, recengine(find the new most popular one) self.offlineLearner.trainModel() self.modelStore.cleanOnlineModel() self.recEngine.resetCache() def getFromInventory(self, itemId): return self.db.extract(DatabaseInterface.INVENTORY_KEY).loc[itemId]
def start(self): # each object here simulates the API calls through network # passing an object A to the constructor of B means A will communication to B self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.user_analyzer = UserAnalyzer() self.model_store = ModelStore() self.online_learner = OnlineLearner(self.db, self.model_store) self.offline_learner = OfflineLearner(self.db, self.model_store) self.increment() self.rec_engine = RecEngine( self.user_analyzer, self.model_store, self.db.connTable[DatabaseInterface.USER_ACTIVITY_KEY])
def start(self): self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.userAnalyzer = UserAnalyzer() self.modelStore = ModelStore() self.offlineLearner = OfflineLearner(self.db, self.modelStore) self.onlineLearner = OnlineLearner(self.db, self.modelStore) #so that immediately after we start, we can start to give recommendations self.offlineLearner.trainModel() #had to extract it here self.recEngine = RecEngine( self.userAnalyzer, self.modelStore, self.db.extract(DatabaseInterface.USER_ACTIVITY_KEY))
def start(self): # each object here simulates the API calls through network # passing an object A to the constructor of B means A will communication to B self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.userAnalyzer = UserAnalyzer() self.modelStore = ModelStore() self.offlineLearner = OfflineLearner(self.db, self.modelStore) self.onlineLearner = OnlineLearner(self.db, self.modelStore) self.offlineLearner.trainModel() # when we start the webserver, let offline learner to train the models, # so that after the start(), we can start to give recommendation self.recEngine = RecEngine( self.userAnalyzer, self.modelStore, self.db.extract(DatabaseInterface.USER_ACTIVITY_KEY))
class WebServer(object): logging.basicConfig(level=logging.INFO) def __init__(self, configMap): self.db = DatabaseInterface(configMap['data_dir']) self.numberToServe = configMap['numberToServe'] self.log = logging.getLogger(__name__) # numberToServe: the number of items finally served to the users def start(self): # each object here simulates the API calls through network # passing an object A to the constructor of B means A will communication to B self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.user_analyzer = UserAnalyzer() self.model_store = ModelStore() self.online_learner = OnlineLearner(self.db, self.model_store) self.offline_learner = OfflineLearner(self.db, self.model_store) self.increment() self.rec_engine = RecEngine( self.user_analyzer, self.model_store, self.db.connTable[DatabaseInterface.USER_ACTIVITY_KEY]) def getAction(self, action): assert (isinstance(action, Action)) #analyze user type user_type = self.user_analyzer.analyzeAction(action) self.online_learner.trainModel(action) if user_type == "registered": self.log.info("Recording action %s", action) self.db.putAction(action) def provideRecommendation(self, request): # return the ID's for the recommended items assert (isinstance(request, Request)) recommendations = self.rec_engine.provideRecommendation(request) item_ids = self.ranker.rerank(recommendations) return item_ids def renderRecommendation(self, request): assert (isinstance(request, Request)) item_ids = self.provideRecommendation(request) return self.getFromInventory(item_ids).sort_index() def increment(self): self.log.info("incrementing the system, update the models") # increment the whole system by one day, trigger offline training self.model_store.cleanOnlineModel() self.offline_learner.trainModel() def getFromInventory(self, itemId): return self.db.extract(DatabaseInterface.INVENTORY_KEY).loc[itemId]
def start(self): # each object here simulates the API calls through network # passing an object A to the constructor of B means A will communication to B self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.userAnalyzer = UserAnalyzer() self.modelStore = ModelStore() self.offlineLearner = OfflineLearner(self.db, self.modelStore) self.onlineLearner = OnlineLearner(self.db, self.modelStore) self.offlineLearner.trainModel() # when we start the webserver, we should let offline learner to train the models, # such that, after the start(), we can start to give recommendation self.recEngine = RecEngine(self.userAnalyzer, self.modelStore, self.db.extract(DatabaseInterface.USER_ACTIVITY_KEY))
class WebServer(object): logging.basicConfig(level=logging.INFO) def __init__(self, configMap): self.db = DatabaseInterface(configMap['data_dir']) # numberToServe: the number of items finally served to the users self.numberToServe = configMap['numberToServe'] self.log = logging.getLogger(__name__) def start(self): # each object here simulates the API calls through network # passing an object A to the constructor of B means A will communication to B self.db.startEngine() self.ranker = Ranker(self.numberToServe, self.db) self.userAnalyzer = UserAnalyzer() self.modelStore = ModelStore() self.offlineLearner = OfflineLearner(self.db, self.modelStore) self.onlineLearner = OnlineLearner(self.db, self.modelStore) self.offlineLearner.trainModel() # when we start the webserver, let offline learner to train the models, # so that after the start(), we can start to give recommendation self.recEngine = RecEngine( self.userAnalyzer, self.modelStore, self.db.extract(DatabaseInterface.USER_ACTIVITY_KEY)) def getAction(self, action): assert (isinstance(action, Action)) # taking the action from users self.onlineLearner.trainModel(action) # analyze action type, and save the registered user's action actionType = self.userAnalyzer.analyzeAction(action) if actionType == "registered": self.log.info("Recording action %s" % action) self.db.putAction(action) def provideRecommendation(self, request): # return the ID's for the recommended items assert (isinstance(request, Request)) # provide recommendations to user self.log.info("responding to request: %s" % request) recommendations = self.recEngine.provideRecommendation(request) recsReranked = self.ranker.rerank(recommendations) return recsReranked # a list of item ids def renderRecommendation(self, request): assert (isinstance(request, Request)) recsReranked = self.provideRecommendation(request) # for the purpose of testing, we sort the index, output item names # output is ordered by the id value return self.db.extract( DatabaseInterface.INVENTORY_KEY).loc[recsReranked].sort_index() def increment(self): self.log.info("incrementing the system, update the models") # increment the whole system by one day, trigger offline training self.offlineLearner.trainModel() self.modelStore.cleanOnlineModel() self.recEngine.resetCache() def getFromInventory(self, itemId): return self.db.extract(DatabaseInterface.INVENTORY_KEY).loc[itemId]
class FlowControl(object): logging.basicConfig(level=logging.INFO) # Output information for log use def __init__(self, configMap): # numberToServe: the number of items finally served to the users self.numberToServe = configMap['numberToServe'] self.log = logging.getLogger(__name__) # instantiate all together the classes that will be used, and start with training offline models def start(self): # DatabaseQueries.createTables() self.modelStore = ModelStore() # "database" of models self.userAnalyzer = UserAnalyzer( ) # classify user type: anonymous? registered new? or registered old? self.trainingCenter = TrainingCenter(self.modelStore) self.ranker = Ranker() # just rank the recommended items # once start should firstly train the models and immediately have recommendations on home page self.trainingCenter.trainModel( ) # NOTE: need to firstly train models once for a welcome page self.recEngine = RecEngine(self.userAnalyzer, self.modelStore, DatabaseQueries.getNumRatingsPerUser()) # Use models - Output recommendations results directly to user def renderRecommendation(self, userId=None, numberToServe=None, itemId=None, ratingScore=None, classical=None, userPreference=None): self.log.info("responding to request: %s" % userId) recommendations = self.recEngine.provideRecommendation( userId, itemId, ratingScore, classical, userPreference) # returns a dict rankings = self.ranker.rank(recommendations, userId, numberToServe) # a list of item ids # output is the detail content of item, not just item id, but sorted (ranked) by the id value # print("results from recEngine:", recommendations) # print(rankings) df_inventory = DatabaseQueries.getInventory() df_inventory.index = df_inventory.index + 1 itemsRecommended = [] itemsImageURL = [] # for i in rankings: # itemsRecommended.append(df_inventory[ df_inventory['itemId'] == i].itemName.item()) # itemsImageURL.append(df_inventory[df_inventory['itemId']== i].itemImageURL.item()) # print(itemsRecommended) # print(itemsImageURL) for i in rankings: itemName = df_inventory[df_inventory['itemId'] == i].itemName.item() itemsRecommended.append(itemName) if os.path.exists("./static/images/moviePosters/" + itemName + ".jpg"): url = "./static/images/moviePosters/" + itemName + ".jpg" else: url = df_inventory[df_inventory['itemId'] == i].itemImageURL.item() itemsImageURL.append(url) return itemsRecommended, itemsImageURL # Set up and update models - increment system - update offline models and clear online model at the end of day def increment(self): self.log.info("incrementing the system, update the models") # increment the whole system by one day, trigger offline training self.trainingCenter.trainModel() self.recEngine.resetCache() # reset most popular