def recommend(self):
# Compute the indices of the non-target playlists
b = Builder()
nontarget_indices = b.get_nontarget_indices(self.target_tracks)
# Initialize the dataframe
dataframe_list = []
# Apply tfidf on the traspose of URM
print('Predicting...', flush=True)
for i in tqdm(range(0, self.num_playlist_to_recommend)):
# Iterate over indices of target playlists
index = b.get_target_playlist_index(self.target_playlists[i])
# Compute the indices of the known tracks
known_indices = np.nonzero(self.URM[index].toarray().flatten())
# Make top-10 prediction
URM_row_flatten = self.MfRec.predict(index).toarray().flatten()
top_10_indices = b.get_top_10_indices(URM_row_flatten, nontarget_indices, known_indices, [])
top_10_tracks = b.get_top_10_tracks_from_indices(top_10_indices)
top_10_tracks_string = ' '.join([str(i) for i in top_10_tracks])
# Create dataset
if self.is_test:
dataframe_list.append([self.target_playlists[i], top_10_tracks])
else:
dataframe_list.append([self.target_playlists[i], top_10_tracks_string])
dataframe = pd.DataFrame(dataframe_list, columns=['playlist_id', 'track_ids'])
return dataframe
def recommend(self):
b = Builder()
nontarget_indices = b.get_nontarget_indices(self.target_tracks)
dataframe_list = []
print('Predicting...', flush=True)
for i in tqdm(range(0, self.num_playlist_to_recommend)):
# Iterate over indices of target playlists
index = b.get_target_playlist_index(self.target_playlists[i])
# Compute relevant indices for the prediction
known_indices = np.nonzero(self.URM[index].toarray().flatten())
URM_row = self.URM[index, :] * self.Slim
# Make prediction
URM_row_flatten = URM_row.toarray().flatten()
top_5_indices = b.get_top_10_indices(URM_row_flatten, nontarget_indices, known_indices, owner_indices)
top_5_tracks = b.get_top_10_tracks_from_indices(top_5_indices)
top_5_tracks_string = ' '.join([str(i) for i in top_5_tracks])
# Create dataset
if self.is_test:
dataframe_list.append([self.target_playlists[i], top_5_tracks])
else:
dataframe_list.append([self.target_playlists[i], top_5_tracks_string])
dataframe = pd.DataFrame(dataframe_list, columns=['playlist_id', 'track_ids'])
return dataframe
def __init__(self):
self.b = Builder()
self.URM_train = None
self.test_df = None
self.target_playlists = None
self.target_tracks = None
self.num_playlists_to_test = 10000
def main():
build = Builder()
goods_list = build.create_goods(10)
eldorado = Seller(goods_list, "eldorado")
worker_vasya = Worker("Вася", salary=100, greedy_level=1.4)
worker_petya = Worker("Петя", salary=80, greedy_level=1.2)
eldorado.add_worker(worker_petya)
eldorado.add_worker(worker_vasya)
worker_vasya.sell_one_good(eldorado.goods_list)
worker_petya.sell_one_good(eldorado.goods_list)
print(eldorado.get_workers_info())
print(build.get_string_repr(eldorado.goods_list))
worker_petya.sale_prices(eldorado.goods_list, 0.8)
worker_vasya.upscale_prices(eldorado.goods_list)
print(build.get_string_repr(eldorado.goods_list))
input()
def recommend_rr(self):
builder = Builder()
nontarget_indices = builder.get_nontarget_indices(self.target_tracks)
URM_T = self.URM.T
URM_tfidf_T = feature_extraction.text.TfidfTransformer().fit_transform(
URM_T)
URM_tfidf = URM_tfidf_T.T
URM_tfidf_csr = URM_tfidf.tocsr()
dataframe_list = []
print('Predicting round_robin with mode =',
self.mode,
'...',
flush=True)
for i in tqdm(range(0, self.num_playlist_to_recommend)):
# Iterate over indices of target playlists
index = builder.get_target_playlist_index(self.target_playlists[i])
# Compute relevant indices for the prediction
known_indices = np.nonzero(self.URM[index].toarray().flatten())
# Calculate recommenders contributions
icm_prediction = self.URM[index, :] * self.S_ICM
icm_prediction_flatten = icm_prediction.toarray().flatten()
icm_prediction_flatten[known_indices] = 0
icm_prediction_flatten[nontarget_indices] = 0
ucm_prediction = self.URM[index, :] * self.S_UCM
ucm_prediction_flatten = ucm_prediction.toarray().flatten()
ucm_prediction_flatten[known_indices] = 0
ucm_prediction_flatten[nontarget_indices] = 0
slimBPR_prediction = URM_tfidf_csr[index, :] * self.Slim
slimBPR_prediction_flatten = slimBPR_prediction.toarray().flatten()
slimBPR_prediction_flatten[known_indices] = 0
slimBPR_prediction_flatten[nontarget_indices] = 0
# Round Robin prediction
top_5_indices = self.round_robin(icm_prediction_flatten,
ucm_prediction_flatten,
slimBPR_prediction_flatten,
self.mode, self.a, self.b, self.c)
top_5_tracks = builder.get_top_10_tracks_from_indices(
top_5_indices)
top_5_tracks_string = ' '.join([str(i) for i in top_5_tracks])
# Create dataset
if self.is_test:
dataframe_list.append([self.target_playlists[i], top_5_tracks])
else:
dataframe_list.append(
[self.target_playlists[i], top_5_tracks_string])
dataframe = pd.DataFrame(dataframe_list,
columns=['playlist_id', 'track_ids'])
return dataframe
def hybrid_rec(is_test):
print('*** Test Hybrid Recommender ***')
b = Builder()
ev = Evaluator(is_test=is_test)
ev.split()
rec = HybridRec.HybridRec()
S_UCM = b.get_S_UCM_KNN(b.get_UCM(ev.get_URM_train()), 600)
S_ICM = b.build_S_ICM_knn(b.build_ICM(), 250)
Slim = SlimBPR.SlimBPR(ev.get_URM_train(),
epochs=1,
learning_rate=0.01,
positive_item_regularization=1,
negative_item_regularization=1).get_S_SLIM_BPR(500)
rec.fit(ev.get_URM_train(),
ev.get_target_playlists(),
ev.get_target_tracks(),
ev.num_playlists_to_test,
S_ICM,
S_UCM,
Slim,
is_test,
alfa=0.3,
avg=0.3)
"""
0.30, 0.30
alfa*((1-avg)*collab + avg*content) + (1-alfa)*slimBPR
only collab con knn=500 0.09080017548893707
knn=600 0.09085745115462485
only content knn=250 0.05537121844924659
knn=300 0.055101704695727706
only slim con lr=0.01 epoch=1 0.09087007071213243
lr=0.001 epoch=8 0.09346656108877179
content+collab con avg=0.20 0.
avg=0.30 0.09762916809334841
all together con alfa=0.40 0.10715025718387602
alfa=0.30 0.1082252839472891
"""
train_df = rec.recommend()
if is_test:
map5 = ev.map5(train_df)
print('Hybrid MAP@10:', map5)
return map5
else:
print('Prediction saved!')
train_df.to_csv(os.path.dirname(os.path.realpath(__file__))[:-19] +
"/all/sub.csv",
sep=',',
index=False)
return 0
def read_data_split_and_search():
"""
This function provides a simple example on how to tune parameters of a given algorithm
The BayesianSearch object will save:
- A .txt file with all the cases explored and the recommendation quality
- A _best_model file which contains the trained model and can be loaded with recommender.load_model()
- A _best_parameter file which contains a dictionary with all the fit parameters, it can be passed to recommender.fit(**_best_parameter)
- A _best_result_validation file which contains a dictionary with the results of the best solution on the validation
- A _best_result_test file which contains a dictionary with the results, on the test set, of the best solution chosen using the validation set
"""
dataReader = Builder()
URM_train = dataReader.get_URM_train()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
collaborative_algorithm_list = [HybridRec]
from ParameterTuning.AbstractClassSearch import EvaluatorWrapper
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator_validation_earlystopping = SequentialEvaluator(URM_validation,
cutoff_list=[5])
evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[5, 10])
evaluator_validation = EvaluatorWrapper(evaluator_validation_earlystopping)
evaluator_test = EvaluatorWrapper(evaluator_test)
runParameterSearch_Collaborative_partial = partial(
runParameterSearch_Collaborative,
URM_train=URM_train,
metric_to_optimize="MAP",
evaluator_validation_earlystopping=evaluator_validation_earlystopping,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test,
output_root_path=output_root_path)
# pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)
# resultList = pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)
for recommender_class in collaborative_algorithm_list:
try:
runParameterSearch_Collaborative_partial(recommender_class)
except Exception as e:
print("On recommender {} Exception {}".format(
recommender_class, str(e)))
traceback.print_exc()
def recommend_avg_similarity(self, avg, beta):
b = Builder()
#2nb = NewBuilder()
nontarget_indices = b.get_nontarget_indices(self.target_tracks)
URM_T = self.URM.T
URM_tfidf_T = feature_extraction.text.TfidfTransformer().fit_transform(
URM_T)
URM_tfidf = URM_tfidf_T.T
URM_tfidf_csr = URM_tfidf.tocsr()
dataframe_list = []
# Weighted average of S_ICM and S_UCM
S_avg = (avg * self.S_ICM) + ((1 - avg) * self.S_UCM)
print('Predicting avg_similarity...', flush=True)
for i in tqdm(range(0, self.num_playlist_to_recommend)):
# Iterate over indices of target playlists
index = b.get_target_playlist_index(self.target_playlists[i])
# Compute relevant indices for the prediction
known_indices = np.nonzero(self.URM[index].toarray().flatten())
#owner_tracks = nb.get_tracks_from_playlist_owner(self.target_playlists[i])
#owner_indices = nb.get_tracks_indices(owner_tracks)
owner_indices = []
# Calculate recommenders contributions
avg_prediction = URM_tfidf_csr[index, :] * S_avg
#avg_prediction = normalize(avg_prediction, axis=1, norm='l2')
#slimBPR_prediction = URM_tfidf_csr[index, :] * self.Slim
#slimBPR_prediction = normalize(slimBPR_prediction, axis=1, norm='l2')
# Weighted average of recommendations
URM_row = (beta * avg_prediction
) #+ ((1-beta) * slimBPR_prediction)
# Make prediction
URM_row_flatten = URM_row.toarray().flatten()
top_5_indices = b.get_top_5_indices(URM_row_flatten,
nontarget_indices,
known_indices, owner_indices)
top_5_tracks = b.get_top_5_tracks_from_indices(top_5_indices)
top_5_tracks_string = ' '.join([str(i) for i in top_5_tracks])
# Create dataset
if self.is_test:
dataframe_list.append([self.target_playlists[i], top_5_tracks])
else:
dataframe_list.append(
[self.target_playlists[i], top_5_tracks_string])
dataframe = pd.DataFrame(dataframe_list,
columns=['playlist_id', 'track_ids'])
return dataframe
def mf_als_rec(is_test):
print('*** Test MF-ALS Recommender ***')
conf = SparkConf().setAppName("MF-ALS Rec").setMaster("local")
sc = SparkContext(conf=conf)
b = Builder()
ev = Evaluator(is_test=is_test)
ev.split()
UCM = b.get_UCM(ev.get_URM_train())
target_playlists = ev.get_target_playlists()
urm_train_indices = ev.get_URM_train().nonzero()
ratings_list = []
print('Creating RDD of tuples')
for index in tqdm(range(0, urm_train_indices[0].size)):
ratings_list.append(
Rating(urm_train_indices[0][index], urm_train_indices[1][index],
1))
ratings = sc.parallelize(ratings_list)
model = ALS.trainImplicit(ratings, rank=10, iterations=5, alpha=0.01)
dataframe_list = []
print('Predicting...', flush=True)
all_predictions = model.recommendProductsForUsers(10).filter(lambda r: r[0] in target_playlists)\
.collect()
for u in tqdm(all_predictions):
prediction = []
for i in u[1]:
prediction.append(i.product)
dataframe_list.append([u[0], prediction])
def get_id(e):
return e[0]
dataframe_list.sort(key=get_id)
train_df = pd.DataFrame(dataframe_list,
columns=['playlist_id', 'track_ids'])
if is_test:
map5 = ev.map5(train_df)
print('Hybrid MAP@10:', map5)
return map5
else:
print('Prediction saved!')
train_df.to_csv(os.path.dirname(os.path.realpath(__file__))[:-19] +
"/all/sub.csv",
sep=',',
index=False)
return 0
def main():
build = Builder("Toshiba")
amount_of_goods = 15
splitter = 60
goods = build.create_goods(amount_of_goods)
eldorado = Seller("Eldorado")
eldorado.add_goods(goods)
print(build.get_string_repr(eldorado.GoodsList), "\n", "=" * splitter)
cons_petya = WorkerConsultant("Petya", salary=splitter, greedy_level=1.1)
cons_vasya = WorkerConsultant("Vasya", salary=200, greedy_level=1.3)
cons_andrea = WorkerConsultant("Andrea", salary=150, greedy_level=1.5)
man_victor = WorkerManager("Victor", salary=1000)
eldorado.add_worker(cons_petya)
eldorado.add_worker(cons_vasya)
eldorado.add_worker(cons_andrea)
eldorado.add_worker(man_victor)
for i in range(len(eldorado.GoodsList) - 10):
eldorado.get_random_consultant().sell_one_good(eldorado.GoodsList)
print("=" * splitter)
eldorado.get_random_consultant().upscale_prices(eldorado.GoodsList)
print("=" * splitter)
for i in range(len(eldorado.GoodsList) - 5):
eldorado.get_random_consultant().sell_one_good(eldorado.GoodsList)
print(eldorado.get_workers_info())
print("=" * splitter)
man_victor.fire_worker(eldorado.find_worst_consultant(),
eldorado.WorkerList)
print("=" * splitter)
print("\n", eldorado.get_workers_info(), sep="")
print(eldorado.get_random_consultant().get_sold_goods_info())
print("Highest salary", eldorado.get_highest_salary_worker().get_info())
print("=" * splitter)
search_id = randint(0, amount_of_goods - 1)
print("Search Results of id {0}: {1}".format(
search_id, eldorado.find_good_by_id(search_id)))
print("=" * splitter)
print(build.get_string_repr(eldorado.GoodsList))
print("=" * splitter)
print("Cost of all goods in", eldorado, eldorado.calculate_prices())
print("=" * splitter)
print("Amount of WorkerConsultant class:", WorkerConsultant.get_amount())
print("Amount of WorkerManager class:", WorkerManager.get_amount())
print("Amount of Good class:", Good.get_amount())
print("Amount of Builder class:", Builder.get_amount())
print("Amount of Seller class:", Seller.get_amount())
input("PressEnter")
def __init__(self, is_test=True):
self.b = Builder()
self.URM_train = None
self.test_df = None
self.target_playlists = None
self.target_tracks = None
self.num_playlists_to_test = 10000
self.is_test = is_test
self.num_playlists_to_evaluate = 10000
def builder_for_target_image(self, target, image_id=None, template=None, parameters=None):
builder = Builder()
builder.customize_image_for_target(target, image_id, template, parameters)
self.builders_lock.acquire()
try:
self.builders[builder.target_image.identifier] = builder
finally:
self.builders_lock.release()
return builder
def builder_for_base_image(self, template, parameters=None):
builder = Builder()
builder.build_image_from_template(template, parameters=parameters)
self.builders_lock.acquire()
try:
self.builders[builder.base_image.identifier] = builder
finally:
self.builders_lock.release()
return builder
def builder_for_provider_image(self, provider, credentials, target, image_id=None, template=None, parameters=None):
builder = Builder()
builder.create_image_on_provider(provider, credentials, target, image_id, template, parameters)
self.builders_lock.acquire()
try:
self.builders[builder.provider_image.identifier] = builder
finally:
self.builders_lock.release()
return builder
def makeGenerator(images):
classifier = AvgRGBClassifier()
deltaCalculator = (AvgDeltaCalculator().addCalculator(
WeightedRGBDeltaCalculator(),
255.0).addCalculator(WeightedHSVDeltaCalculator()))
builder = Builder((56, 56))
generator = Generator(classifier.classify(images), deltaCalculator,
builder)
return generator
def getResult(self):
items = Builder().getItems()
xml = "<list>"
xmlContent = ""
for item in items:
xmlContent = xmlContent + self.getPartElement(item.getItem())
xml = xml + xmlContent + "</list>"
return xml
def test_uptodate(self):
builder = Builder()
dst = self.getPath('y')
builder.applyRule(dst, self.srcPaths,
lambda: catFiles(dst, self.srcPaths))
self.assertEquals(1, countLines(dst))
self.assertEquals(1, builder.numRules)
self.assertEquals(0, builder.numMade)
def recommend(self):
# Compute the indices of the non-target playlists
b = Builder()
nontarget_indices = b.get_nontarget_indices(self.target_tracks)
# Initialize the dataframe
dataframe_list = []
# Apply tfidf on the traspose of URM
URM_T = self.URM.T
URM_tfidf_T = feature_extraction.text.TfidfTransformer().fit_transform(
URM_T)
URM_tfidf = URM_tfidf_T.T
URM_tfidf_csr = URM_tfidf.tocsr()
# Weighted average of S_ICM and S_UCM
S_avg = (self.avg * self.S_ICM) + ((1 - self.avg) * self.S_UCM)
print('Predicting...', flush=True)
for i in tqdm(range(0, self.num_playlist_to_recommend)):
# Iterate over indices of target playlists
index = b.get_target_playlist_index(self.target_playlists[i])
# Compute the indices of the known tracks
known_indices = np.nonzero(self.URM[index].toarray().flatten())
# Calculate recommenders contributions
avg_prediction = URM_tfidf_csr[index, :] * S_avg
slimBPR_prediction = URM_tfidf_csr[index, :] * self.Slim
# Weighted sum of recommendations
URM_row = (self.alfa * avg_prediction) + (
(1 - self.alfa) * slimBPR_prediction)
# Make top-5 prediction
URM_row_flatten = URM_row.toarray().flatten()
top_5_indices = b.get_top_5_indices(URM_row_flatten,
nontarget_indices,
known_indices, [])
top_5_tracks = b.get_top_5_tracks_from_indices(top_5_indices)
top_5_tracks_string = ' '.join([str(i) for i in top_5_tracks])
# Create dataset
if self.is_test:
dataframe_list.append([self.target_playlists[i], top_5_tracks])
else:
dataframe_list.append(
[self.target_playlists[i], top_5_tracks_string])
dataframe = pd.DataFrame(dataframe_list,
columns=['playlist_id', 'track_ids'])
return dataframe
def fit(self, URM, target_playlists, target_tracks,
num_playlist_to_recommend, ICM, k, knn, is_test):
self.URM = URM
self.target_playlists = target_playlists
self.target_tracks = target_tracks
self.num_playlist_to_recommend = num_playlist_to_recommend
self.ICM = ICM
self.is_test = is_test
self.S_ICM_SVD = Builder().get_S_ICM_SVD(self.ICM, k, knn)
class WeatherSkill:
api = OWMApi()
profile = None
@staticmethod
@IntentBuilder(Builder("weather"))
def handle_current_weather(string: str):
"""
Погода в Париже
:return:
"""
forecast = WeatherSkill.get_forecast(string)
parsed = Forecast().parse(forecast)
return "Сейчас за окном %s, температура %.1f градусов" % (
parsed.detailed_status, parsed.temp)
@staticmethod
@IntentBuilder(Builder("forecast").require("weather"))
def handle_forecast(string: str):
forecast = WeatherSkill.get_forecast(string)
parsed = Forecast().parse(forecast)
return "По прогнозу будет %s, температура %.1f" % (
parsed.detailed_status, parsed.temp)
@staticmethod
@IntentBuilder(Builder("weather").require("will"))
def handle_weather_will(string: str):
forecast = WeatherSkill.get_forecast(string)
parsed = Forecast().parse(forecast)
return "По прогнозу будет %s, температура %.1f" % (
parsed.detailed_status, parsed.temp)
@staticmethod
def get_forecast(string: str) -> dict:
city = extract_city(string)
if city is None:
city = "Moscow,ru"
date = extract_datetime(string)
forecast = WeatherSkill.api.weather_forecast(date, city)
return forecast
def build(self):
print("build")
path = self.entry_dirPath.get()
if self.checkInput(path):
self.builder = Builder(path, self.bins)
try:
Builder.build(self.builder)
if self.builder.trainingSet is None:
tkMessageBox.showinfo("Bad input", "Bins isn't valid, Please try to another value of bins")
else:
tkMessageBox.showinfo("Building Done", "Building classifier using train-set is done!")
except:
tkMessageBox.showinfo("Failed", "Something went wrong, please try again")
def getResult(self):
items = Builder().getItems()
json = "{"
itemsSize = len(items)
currentItem = 0
jsonContent = ""
for item in items:
currentItem = currentItem +1
jsonContent = jsonContent + self.getPartElement(item.getItem())
if(currentItem < itemsSize):
jsonContent = jsonContent+","
json = json +jsonContent+"}"
return json
def recommend_fm(self, ICM):
builder = Builder()
newBuilder = NewBuilder()
fm = FactorizationMachine()
fm.fit(self.URM, ICM, self.target_playlists, self.target_tracks)
target_tracks_i = newBuilder.get_tracks_indices(self.target_tracks)
r = fm.recommend()
print(r)
print(r.shape)
nontarget_indices = builder.get_nontarget_indices(self.target_tracks)
dataframe_list = []
offset = 0
print('Predicting FM...', flush=True)
for i in tqdm(range(0, self.num_playlist_to_recommend)):
# Iterate over indices of target playlists
index = builder.get_target_playlist_index(self.target_playlists[i])
owner_indices = []
known_indices = np.nonzero(self.URM[index].toarray().flatten())
# Increment offset of prediction array r
if i != 0 and i % fm.n_tracks == 0:
offset += fm.n_tracks
# Weighted average of recommendations
URM_row_flatten = np.zeros(fm.n_tracks)
for t_i in target_tracks_i:
URM_row_flatten[t_i] = r[i + offset]
# Make prediction
top_5_indices = builder.get_top_5_indices(URM_row_flatten,
nontarget_indices,
known_indices,
owner_indices)
top_5_tracks = builder.get_top_5_tracks_from_indices(top_5_indices)
top_5_tracks_string = ' '.join([str(i) for i in top_5_tracks])
# Create dataset
if self.is_test:
dataframe_list.append([self.target_playlists[i], top_5_tracks])
else:
dataframe_list.append(
[self.target_playlists[i], top_5_tracks_string])
dataframe = pd.DataFrame(dataframe_list,
columns=['playlist_id', 'track_ids'])
return dataframe
def test_build(self):
builder = Builder()
dst = self.getPath('123')
builder.applyRule(dst, self.srcPaths,
lambda: catFiles(dst, self.srcPaths))
self.assert_(os.path.exists(dst))
self.assertEquals(3, countLines(dst))
dst = self.getPath('x')
builder.applyRule(dst, self.srcPaths,
lambda: catFiles(dst, self.srcPaths))
self.assertEquals(3, countLines(dst))
self.assertEquals(2, builder.numRules)
self.assertEquals(2, builder.numMade)
def build_test_x(self):
print("Build test_x...")
b = Builder()
playlists_indices = b.get_playlists_indices(self.test_playlists)
tracks_indices = b.get_tracks_indices(self.test_tracks)
ICM_lil = self.ICM.tolil()
URM_lil = self.URM.tolil()
rows_list = []
for p_i in tqdm(playlists_indices):
p_i_tracks = URM_lil[p_i].rows[0]
self.build_rows(p_i, p_i_tracks, ICM_lil, rows_list, True)
# Stack all the rows together
self.test_x = sparse.vstack(rows_list)
def __init__(self, top_level_dir, repos, jobs=1, sudo_creds=None):
"""
:param top_level_dir: the directory that holds all the cloned
repositories according to manifest
example: <top_level_dir>/on-http/...
/on-tftp/...
:param repos: a list of repositories to be build
:param jobs: Number of parallel jobs(build debian packages) to run.
:param sudo_creds: the environment variable name of sudo credentials.
for example: SUDO_CRED=username:password
:return: None
"""
self.top_level_dir = top_level_dir
self._repos = repos
self._jobs = jobs
self._sudo_creds = sudo_creds
self._builder = Builder(self._jobs)
def main():
build = Builder()
go = build.create_goods(10)
eldorado = Seller(go, "Eldorado")
eldorado.add_worker(Worker("Vasya", salary=100, greedy_level=1.3))
eldorado.add_worker(Worker("Petya", salary=200, greedy_level=1.8))
eldorado.add_worker(Worker("Ivan", salary=150, greedy_level=1.1))
eldorado.add_worker(Worker("Vasya", salary=560, greedy_level=1.4))
print(eldorado.get_random_worker().get_sold_goods_info())
print(build.get_string_repr(eldorado.goods_list))
print("Amount of Worker class:", Worker.amount_of_workers)
print("Amount of Good class:", Good.amount)
print("Amount of Builder class:", Builder.amount)
print("Amount of Seller class:", Builder.amount)
input("PressEnter")
def recommend(self):
# Compute the indices of the non-target playlists
b = Builder()
nontarget_indices = b.get_nontarget_indices(self.target_tracks)
# Initialize the dataframe
dataframe_list = []
print('Predicting...', flush=True)
for i in tqdm(range(0, self.num_playlist_to_recommend)):
# Iterate over indices of target playlists
index = b.get_target_playlist_index(self.target_playlists[i])
# Compute the indices of the known tracks
known_indices = np.nonzero(self.URM[index].toarray().flatten())
# Make single predictions
ucm_pred = self.URM[index, :] * self.S_UCM
icm_pred = self.URM[index, :] * self.S_ICM
# Weighted sum of predictions
URM_row = (self.alfa * icm_pred) + ((1 - self.alfa) * ucm_pred)
# Make top-5 prediction
URM_row_flatten = URM_row.toarray().flatten()
top_5_indices = b.get_top_10_indices(URM_row_flatten,
nontarget_indices,
known_indices, [])
top_5_tracks = b.get_top_10_tracks_from_indices(top_5_indices)
top_5_tracks_string = ' '.join([str(i) for i in top_5_tracks])
# Create dataset
if self.is_test:
dataframe_list.append([self.target_playlists[i], top_5_tracks])
else:
dataframe_list.append(
[self.target_playlists[i], top_5_tracks_string])
dataframe = pd.DataFrame(dataframe_list,
columns=['playlist_id', 'track_ids'])
return dataframe
def item_based(is_test):
print('*** Item Based Recommender ***')
b = Builder()
ev = Evaluator()
ev.split()
rec = ItemBasedRec.ItemBasedRec()
S_ICM = b.build_S_ICM_knn(b.build_ICM(), 250)
rec.fit(ev.get_URM_train(), ev.get_target_playlists(),
ev.get_target_tracks(), ev.num_playlists_to_test, S_ICM, is_test)
train_df = rec.recommend()
if is_test:
map5 = ev.map5(train_df)
print('ItemBased MAP@5:', map5)
else:
print('Prediction saved!')
train_df.to_csv('ItemBased.csv', sep=',', index=False)
def collaborative_filtering(is_test):
print('*** Test Collaborative Filtering Recommender ***')
b = Builder()
ev = Evaluator()
ev.split()
rec = CollaborativeFilteringRec.CollaborativeFilteringRec()
S_UCM = b.get_S_UCM_KNN(b.get_UCM(b.get_URM()), 500)
rec.fit(ev.get_URM_train(), ev.get_target_playlists(),
ev.get_target_tracks(), ev.num_playlists_to_test, S_UCM, True)
train_df = rec.recommend()
if is_test:
map5 = ev.map5(train_df)
print('CollaborativeFiltering MAP@5:', map5)
else:
print('Prediction saved!')
train_df.to_csv('CollaborativeFiltering.csv', sep=',', index=False)
