def __simulateRecommendation(self, portfolio:Portfolio1Aggr, portfolioModel:pd.DataFrame, evaluatonTool:AEvalTool, testRatingsDF:DataFrame,
history:AHistory, evaluation:dict, uProbOfObserv:List[float], uObservation:List[bool], userID:int,
currentItemID:int, nextItemID:int):
rItemIDs:List[int]
rItemIDsWithResponsibility:List[tuple[int, Series[int, str]]]
rItemIDs, rItemIDsWithResponsibility = portfolio.recommend(
userID, portfolioModel, testRatingsDF, history, numberOfItems=self._numberOfItems)
print(testRatingsDF)
if not nextItemID in rItemIDs:
return
index:int = rItemIDs.index(nextItemID)
probOfObserv:float = uProbOfObserv[index]
wasObserved:bool = uObservation[index]
if wasObserved:
clickedItemID: int = nextItemID
evaluatonTool.click(rItemIDsWithResponsibility, clickedItemID, probOfObserv, portfolioModel, evaluation)
# save log of history
history.insertRecommendations(userID, rItemIDs, uProbOfObserv, clickedItemID)
else:
evaluatonTool.ignore(rItemIDsWithResponsibility, portfolioModel, evaluation)
# save log of history
history.insertRecommendations(userID, rItemIDs, uProbOfObserv, None)
def __simulateRecommendation(self, portfolio:APortfolio, portfolioDesc:APortfolioDescription, portfolioModel:pd.DataFrame,
evaluatonTool:AEvalTool, history:AHistory, evaluation:dict, uObservation:List[bool],
currentItemID:int, nextItemIDs:List[int], userID:int):
#print("userID: " + str(userID))
portId:str = portfolioDesc.getPortfolioID()
args:dict = {APortfolio.ARG_NUMBER_OF_RECOMM_ITEMS:self._numberOfRecommItems, Portfolio1Aggr.ARG_NUMBER_OF_AGGR_ITEMS:self._numberOfAggrItems}
rItemIDs:List[int]
rItemIDsWithResponsibility:List[tuple[int, Series[int, str]]]
rItemIDs, rItemIDsWithResponsibility = portfolio.recommend(userID, portfolioModel, args)
evaluatonTool.displayed(rItemIDsWithResponsibility, portfolioModel, evaluation)
nextNoClickedItemIDs:List[int] = list(set(nextItemIDs) -set(self._clickedItems[userID]))
candidatesToClick:List[int] = list(set(rItemIDs) & set(nextNoClickedItemIDs))
clickedItemIDs:List[int] = []
for candidateToClickI in candidatesToClick:
indexI:int = rItemIDs.index(candidateToClickI)
wasCandidateObservedI:bool = uObservation[indexI]
if wasCandidateObservedI:
clickedItemIDs.append(candidateToClickI)
print("nextItemIDs: " + str(nextItemIDs))
print("rItemIDs: " + str(rItemIDs))
print("uObservation: " + str(uObservation))
print("candidatesToClick: " + str(candidatesToClick))
print("clickedItemIDs: " + str(clickedItemIDs))
for clickedItemIdI in clickedItemIDs:
evaluatonTool.click(rItemIDsWithResponsibility, clickedItemIdI, portfolioModel, evaluation)
if not clickedItemIdI in self._clickedItems[userID]:
self._clickedItems[userID].append(clickedItemIdI)
print("clickedItems: " + str(self._clickedItems[userID]))
# store port model time evolution to file
self.portModelTimeEvolutionFiles[portId].write("currentItemID: " + str(currentItemID) + "\n")
self.portModelTimeEvolutionFiles[portId].write("userID: " + str(userID) + "\n")
self.portModelTimeEvolutionFiles[portId].write(str(portfolioModel) + "\n\n")
# store history of recommendations to file
self.historyOfRecommendationFiles[portfolioDesc.getPortfolioID()].write("userID: " + str(userID) + "\n")
self.historyOfRecommendationFiles[portfolioDesc.getPortfolioID()].write("currentItemID: " + str(currentItemID) + "\n")
self.historyOfRecommendationFiles[portfolioDesc.getPortfolioID()].write("rItemIDs: " + str(rItemIDs) + "\n")
self.historyOfRecommendationFiles[portfolioDesc.getPortfolioID()].write("uObservation: " + str(uObservation) + "\n")
self.historyOfRecommendationFiles[portfolioDesc.getPortfolioID()].write("clickedItemIDs: " + str(clickedItemIDs) + "\n\n")
# save log of history
history.insertRecomAndClickedItemIDs(userID, rItemIDs, clickedItemIDs)
# delete log of history
history.deletePreviousRecomOfUser(userID, self._repetitionOfRecommendation * self._numberOfRecommItems)
def runPenalization(self, userID:int, methodsResultDict:dict, history:AHistory):
def getItemIDs(methIdI:str):
recommI:Series = methodsResultDict[methIdI]
itemIDsI:List[int] = recommI.index
return itemIDsI
itemsInRecomendationsLL:List[List[int]] = map(getItemIDs, methodsResultDict)
itemsInRecomendations:List[int] = list(itertools.chain.from_iterable(itemsInRecomendationsLL))
itemIdsToRemove:List[int] = []
for itemIdI in itemsInRecomendations:
valueOfIgnoringI:float = history.getIgnoringValue(userID, itemIdI, limit=self._lengthOfHistory)
#print("valueOfIgnoringI: " + str(valueOfIgnoringI))
if valueOfIgnoringI >= self._borderNegFeedback:
itemIdsToRemove.append(itemIdI)
#print("itemIdsToRemove: " + str(itemIdsToRemove))
methodsResultNewDict:dict = {}
for methIdI in methodsResultDict.keys():
ratingsI:Series = methodsResultDict[methIdI]
ratingsNewI:Series = ratingsI.drop(list(set(ratingsI.keys()) & set(itemIdsToRemove)))
methodsResultNewDict[methIdI] = ratingsNewI
return methodsResultNewDict
def runPenalization(self, userID: int, methodsResultDict: dict,
history: AHistory):
if type(userID) is not int and type(userID) is not np.int64:
raise ValueError("Type of userID isn't int.")
if type(methodsResultDict) is not dict:
raise ValueError("Type of methodsResultDict isn't dict.")
if not isinstance(history, AHistory):
raise ValueError("Type of history isn't AHistory.")
itemIDs: List[int] = list(
set(
itertools.chain(
*[rI.index for mI, rI in methodsResultDict.items()])))
penalties: dict = {}
for itemIdI in itemIDs:
prevRecomendations: List[
tuple] = history.getPreviousRecomOfUserAndItem(
userID, itemIdI, 100)
prevRecomendations.reverse()
penaltyI: float = 0
i: int = 0
for indexJ, userIdJ, itemIdJ, positionJ, clickedJ, timestampJ in prevRecomendations:
penaltyPositionJ: float = self._penalPositionFnc(
positionJ, *self._argumentsPositionList)
penaltyHistoryJ: float = self._penalHistoryFnc(
i, *self._argumentsHistoryList)
penaltyI += penaltyPositionJ * penaltyHistoryJ
i += 1
penalties[itemIdI] = penaltyI
penalizedResultsDict: dict = {}
methodIdI: str
resulrsI: Series
for methodIdI, resultsI in methodsResultDict.items():
penalizedResultDictI: dict = {}
candidateIdJ: int
votesOfCandidateJ: int
for candidateIdJ, votesOfCandidateJ in resultsI.items():
#print("candidateIdJ: " + str(candidateIdJ))
#print("votesOfCandidateJ: " + str(votesOfCandidateJ))
penalizedResultDictI[candidateIdJ] = votesOfCandidateJ / (
1 + penalties.get(candidateIdJ, 0))
penalizedResultsDict[methodIdI] = Series(penalizedResultDictI,
name="rating")
return penalizedResultsDict
def __getPenaltiesOfItemIDs(self, userID:int, itemIDs:List[int], history:AHistory):
prevRecomendations:List[tuple] = history.getPreviousRecomOfUser(userID, self._lengthOfHistory)
i:int = len(prevRecomendations) #self._lengthOfHistory#
#print(prevRecomendations)
probabilities:dict = {}
for indexJ, userIdJ, itemIdJ, positionJ, clickedJ, timestampJ in prevRecomendations:
actProbability = probabilities.get(itemIdJ, 1) #init with one
prob_implicit_rejection:float = self._penalPositionFnc(positionJ, *self._argumentsPositionList)
prob_stable_pref:float = self._penalHistoryFnc(i, *self._argumentsHistoryList)
prob_couldBeRelevant = (1-(prob_implicit_rejection * prob_stable_pref) )
probabilities[itemIdJ] = actProbability*prob_couldBeRelevant
i = i-1
print(probabilities)
return probabilities
"""
def __getPenaltiesOfItemIDs(self, userID:int, itemIDs:List[int], history:AHistory):
penalties:dict = {}
for itemIdI in itemIDs:
prevRecomendations:List[tuple] = history.getPreviousRecomOfUserAndItem(userID, itemIdI, self._lengthOfHistory)
prevRecomendations.reverse()
penaltyI: float = 0
i:int = 0
#print(prevRecomendations)
for indexJ, userIdJ, itemIdJ, positionJ, clickedJ, timestampJ in prevRecomendations:
penaltyPositionJ:float = self._penalPositionFnc(positionJ, *self._argumentsPositionList)
penaltyHistoryJ:float = self._penalHistoryFnc(i, *self._argumentsHistoryList)
penaltyI += penaltyPositionJ * penaltyHistoryJ
i += 1
penalties[itemIdI] = penaltyI
return penalties
def runOneMethodPenalization(self, userID:int, methodsResultSrs:Series, history:AHistory):
itemIdsToRemove:List[int] = []
for itemIdI in methodsResultSrs.index:
#print(itemIdI)
valueOfIgnoringI:float = history.getIgnoringValue(userID, itemIdI, limit=self._lengthOfHistory)
#print("valueOfIgnoringI: " + str(valueOfIgnoringI))
if valueOfIgnoringI >= self._borderNegFeedback:
itemIdsToRemove.append(itemIdI)
print("borderNegFeedback " + str(self._borderNegFeedback))
print(itemIdsToRemove)
newMethodsResultSrs:Series = methodsResultSrs.drop(itemIdsToRemove)
#print(newMethodsResultSrs)
#print(normalize(newMethodsResultSrs.values[:,np.newaxis], axis=0).ravel())
normalizedNewMethodsResultSrs:Series = Series(
normalize(newMethodsResultSrs.values[:, np.newaxis], axis=0).ravel(),
index=newMethodsResultSrs.index)
return normalizedNewMethodsResultSrs
def simulateRecommendation(
self, portfolio: APortfolio, portfolioDesc: APortfolioDescription,
portfolioModel: DataFrame, evaluatonTool: AEvalTool,
history: AHistory, evaluationDict: Dict[str, object],
currentDFIndex: int, counterI: int, counterMax: int,
testRatingsDF: DataFrame, uObservation: List[bool], userID: int,
sessionID: int, windowOfItemIDsI: List[int],
currentPageType: object):
from datasets.slantour.events import Events #class
COL_ITEMID: str = self._ratingClass.getColNameItemID()
currentItemID: int = testRatingsDF.loc[currentDFIndex][COL_ITEMID]
print("userID: " + str(userID))
portId: str = portfolioDesc.getPortfolioID()
args: Dict[str, object] = {
APortfolio.ARG_NUMBER_OF_RECOMM_ITEMS: self._numberOfRecommItems,
Portfolio1Aggr.ARG_NUMBER_OF_AGGR_ITEMS: self._numberOfAggrItems,
EvalToolContext.ARG_PAGE_TYPE: currentPageType,
EvalToolContext.ARG_ITEM_ID: currentItemID,
EvalToolContext.ARG_SENIORITY: sessionID
}
rItemIDs: List[int]
rItemIDsWithResponsibility: List[tuple[int, Series[int, str]]]
rItemIDs, rItemIDsWithResponsibility = portfolio.recommend(
userID, portfolioModel,
args | {self.ARG_STATUS: counterI / counterMax})
evaluatonTool.displayed(
userID, rItemIDsWithResponsibility, portfolioModel,
args | {self.ARG_STATUS: counterI / counterMax})
candidatesToClick: List[int] = [
itemIDI for itemIDI, observedI in zip(
rItemIDs, uObservation[:len(rItemIDs)]) if observedI
]
clickedItemIDs: List[int] = list(
set(candidatesToClick) & set(windowOfItemIDsI))
clickedNewItemIDs: List[int] = [
itemIdI for itemIdI in clickedItemIDs
if itemIdI not in self._clickedItems[userID]
]
print("windowOfItemIDsI: " + str(windowOfItemIDsI))
print("rItemIDs: " + str(rItemIDs))
print("uObservation: " + str(uObservation))
print("candidatesToClick: " + str(candidatesToClick))
print("clickedItemIDs: " + str(clickedItemIDs))
print("clickedNewItemIDs: " + str(clickedNewItemIDs))
print("historyOfClickedItems: " + str(self._clickedItems[userID]))
for clickedNewItemIdI in clickedNewItemIDs:
evaluationDict[AEvalTool.CLICKS] = evaluationDict.get(
AEvalTool.CLICKS, 0) + 1
evaluatonTool.click(
userID, rItemIDsWithResponsibility, clickedNewItemIdI,
portfolioModel,
args | {self.ARG_STATUS: counterI / counterMax})
self._clickedItems[userID].append(clickedNewItemIdI)
# store port model time evolution to file
self.portModelTimeEvolutionFiles[portId].write(
str(counterI) + " / " + str(counterMax) + "\n")
self.portModelTimeEvolutionFiles[portId].write("currentItemID: " +
str(currentItemID) +
"\n")
self.portModelTimeEvolutionFiles[portId].write("userID: " +
str(userID) + "\n")
self.portModelTimeEvolutionFiles[portId].write(
str(portfolioModel.to_json()) + "\n\n")
# store history of recommendations to file
self.historyOfRecommendationFiles[
portfolioDesc.getPortfolioID()].write("userID: " + str(userID) +
"\n")
self.historyOfRecommendationFiles[
portfolioDesc.getPortfolioID()].write("currentItemID: " +
str(currentItemID) + "\n")
self.historyOfRecommendationFiles[
portfolioDesc.getPortfolioID()].write("rItemIDs: " +
str(rItemIDs) + "\n")
self.historyOfRecommendationFiles[
portfolioDesc.getPortfolioID()].write("uObservation: " +
str(uObservation) + "\n")
self.historyOfRecommendationFiles[
portfolioDesc.getPortfolioID()].write("clickedItemIDs: " +
str(clickedItemIDs) + "\n\n")
self.historyOfRecommendationFiles[portfolioDesc.getPortfolioID(
)].write("clickedNewItemIDs: " + str(clickedNewItemIDs) + "\n\n")
# save log of history
history.insertRecomAndClickedItemIDs(userID, rItemIDs, clickedItemIDs)
# delete log of history
lengthOfHistory: int = 10 * self._recomRepetitionCount * self._numberOfAggrItems
#print("lengthOfHistory: " + str(lengthOfHistory))
history.deletePreviousRecomOfUser(userID, lengthOfHistory)