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]
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]
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