data=feedback, test_size=0.1, val_size=0.1, exclude_unknowns=True, review_text=review_modality, verbose=True, seed=123, ) pretrained_word_embeddings = {} # You can load pretrained word embedding here model = cornac.models.NARRE( embedding_size=100, id_embedding_size=32, n_factors=32, attention_size=16, kernel_sizes=[3], n_filters=64, dropout_rate=0.5, max_text_length=50, batch_size=64, max_iter=10, init_params={'pretrained_word_embeddings': pretrained_word_embeddings}, verbose=True, seed=123, ) cornac.Experiment(eval_method=ratio_split, models=[model], metrics=[cornac.metrics.RMSE()]).run()
num_neg=50, seed=123) neumf1 = cornac.models.NeuMF(num_factors=8, layers=[64, 32, 16, 8], act_fn='tanh', learner='adam', num_epochs=10, batch_size=256, lr=0.001, num_neg=50, seed=123) neumf2 = cornac.models.NeuMF(name='NeuMF_pretrained', learner='adam', num_epochs=10, batch_size=256, lr=0.001, num_neg=50, seed=123, num_factors=gmf.num_factors, layers=mlp.layers, act_fn=mlp.act_fn).pretrain(gmf, mlp) # Instantiate evaluation metrics ndcg_50 = cornac.metrics.NDCG(k=50) rec_50 = cornac.metrics.Recall(k=50) # Put everything together into an experiment and run it cornac.Experiment(eval_method=ratio_split, models=[gmf, mlp, neumf1, neumf2], metrics=[ndcg_50, rec_50]).run()
tokenizer=BaseTokenizer('\t'), max_vocab=8000, max_doc_freq=0.5, stop_words='english') ratio_split = RatioSplit(data=data, test_size=0.2, exclude_unknowns=True, item_text=item_text_module, verbose=True, seed=123, rating_threshold=0.5) cdr = cornac.models.CDR(k=50, autoencoder_structure=[200], max_iter=100, batch_size=128, lambda_u=0.01, lambda_v=0.1, lambda_w=0.0001, lambda_n=5, learning_rate=0.001, vocab_size=8000) rec_300 = cornac.metrics.Recall(k=300) exp = cornac.Experiment(eval_method=ratio_split, models=[cdr], metrics=[rec_300]) exp.run()
# build text module item_text_modality = TextModality(corpus=plots, ids=movie_ids, tokenizer=BaseTokenizer( sep='\t', stop_words='english'), max_vocab=5000, max_doc_freq=0.5) ratio_split = RatioSplit(data=ml_1m, test_size=0.2, exclude_unknowns=True, item_text=item_text_modality, verbose=True, seed=123) hft = cornac.models.HFT(k=10, max_iter=40, grad_iter=5, l2_reg=0.001, lambda_text=0.01, vocab_size=5000, seed=123) mse = cornac.metrics.MSE() exp = cornac.Experiment(eval_method=ratio_split, models=[hft], metrics=[mse], user_based=False) exp.run()
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ """Example for Social Bayesian Personalized Ranking with Epinions dataset""" import cornac from cornac.data import Reader, GraphModule from cornac.datasets import epinions from cornac.eval_methods import RatioSplit ratio_split = RatioSplit(data=epinions.load_data(Reader(bin_threshold=4.0)), test_size=0.1, rating_threshold=0.5, exclude_unknowns=True, verbose=True, user_graph=GraphModule(data=epinions.load_trust())) sbpr = cornac.models.SBPR(k=10, max_iter=50, learning_rate=0.001, lambda_u=0.015, lambda_v=0.025, lambda_b=0.01, verbose=True) rec_10 = cornac.metrics.Recall(k=10) cornac.Experiment(eval_method=ratio_split, models=[sbpr], metrics=[rec_10]).run()
ml_100k = cn.datasets.movielens.load_100k() # Split data based on ratio ratio_split = cn.eval_methods.RatioSplit(data=ml_100k, test_size=0.2, rating_threshold=4.0, seed=123) # Here we are comparing biased MF, PMF, and BPR mf = cn.models.MF(k=10, max_iter=25, learning_rate=0.01, lambda_reg=0.02, use_bias=True) pmf = cn.models.PMF(k=10, max_iter=100, learning_rate=0.001, lamda=0.001) bpr = cn.models.BPR(k=10, max_iter=100, learning_rate=0.001, lambda_reg=0.01) # Define metrics used to evaluate the models mae = cn.metrics.MAE() rmse = cn.metrics.RMSE() rec_20 = cn.metrics.Recall(k=20) ndcg_20 = cn.metrics.NDCG(k=20) auc = cn.metrics.AUC() # Put it together into an experiment and run exp = cn.Experiment(eval_method=ratio_split, models=[mf, pmf, bpr], metrics=[mae, rmse, rec_20, ndcg_20, auc], user_based=True) exp.run()
import cornac from cornac.data import Reader from cornac.datasets import citeulike from cornac.eval_methods import RatioSplit _, item_ids = citeulike.load_text() data = citeulike.load_data(reader=Reader(item_set=item_ids)) ratio_split = RatioSplit(data=data, test_size=0.2, exclude_unknowns=True, verbose=True, seed=123, rating_threshold=0.5) cf = cornac.models.WMF(k=50, max_iter=50, learning_rate=0.001, lambda_u=0.01, lambda_v=0.01, verbose=True, seed=123) rec_300 = cornac.metrics.Recall(k=300) cornac.Experiment(eval_method=ratio_split, models=[cf], metrics=[rec_300], user_based=True).run()
lambda_u=0.01, lambda_h=0.01, lambda_v=0.01, max_iter=10000, trainable=True, verbose=True, ) n_items = eval_method.train_set.num_items k_1 = int(n_items / 100) k_5 = int(n_items * 5 / 100) k_10 = int(n_items * 10 / 100) cornac.Experiment( eval_method=eval_method, models=[model], metrics=[ cornac.metrics.AUC(), cornac.metrics.Recall(k=k_1), cornac.metrics.Recall(k=k_5), cornac.metrics.Recall(k=k_10), cornac.metrics.NDCG(k=k_1), cornac.metrics.NDCG(k=k_5), cornac.metrics.NDCG(k=k_10), ], show_validation=True, save_dir="dist/toy/result", verbose=True, ).run()
Discrete('act_fn', ['tanh', 'relu', 'elu']), Discrete('n_epochs', [20, 50, 100]), Continuous("beta", low=0.4, high=1.8), Continuous("learning_rate", low=1e-3, high=3e-1), ], metric=hm, eval_method=eval_method, n_trails=50, ) # In[ ]: cornac.Experiment( eval_method=eval_method, models=[rs], metrics=[mae, rmse, recall25, recall50, ndcg, ncrr, auc, mAP, f1, hm], user_based=True, save_dir=GLOBAL_DIR, ).run() # In[ ]: import pickle saved_path = rs.best_model.save(GLOBAL_DIR) item_idx2id = list(rs.best_model.train_set.item_ids) item_id2idx = rs.best_model.train_set.uid_map mapping = { 'item_idx2id': item_idx2id, 'item_id2idx': item_id2idx, }
# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ import cornac as cn ml_100k = cn.datasets.movielens.load_100k() ratio_split = cn.eval_methods.RatioSplit(data=ml_100k, test_size=0.2, rating_threshold=4.0, verbose=True) bo = cn.models.BaselineOnly(max_iter=30, learning_rate=0.01, lambda_reg=0.02, verbose=True) svd = cn.models.SVD(k=10, max_iter=30, learning_rate=0.01, lambda_reg=0.02, verbose=True) mae = cn.metrics.MAE() rmse = cn.metrics.RMSE() cn.Experiment(eval_method=ratio_split, models=[bo, svd], metrics=[mae, rmse]).run()
seed=123, ) # Instantiate a NMF recommender model. nmf = cornac.models.NMF( k=15, max_iter=50, learning_rate=0.005, lambda_u=0.06, lambda_v=0.06, lambda_bu=0.02, lambda_bi=0.02, use_bias=False, verbose=True, seed=123, ) # Instantiate evaluation metrics. mae = cornac.metrics.MAE() rmse = cornac.metrics.RMSE() rec_20 = cornac.metrics.Recall(k=20) pre_20 = cornac.metrics.Precision(k=20) # Instantiate and then run an experiment. cornac.Experiment( eval_method=eval_method, models=[nmf], metrics=[mae, rmse, rec_20, pre_20], user_based=True, ).run()
model=mf, space=[ Discrete("k", [10, 30, 50]), Discrete("use_bias", [True, False]), Discrete("lambda_reg", [1e-1, 1e-2, 1e-3, 1e-4]), ], metric=rmse, eval_method=ratio_split, ) # Wrap MF model inside RandomSearch along with the searching space, try 30 times rs_mf = RandomSearch( model=mf, space=[ Discrete("k", [10, 30, 50]), Discrete("use_bias", [True, False]), Continuous("lambda_reg", low=1e-4, high=1e-1), ], metric=rmse, eval_method=ratio_split, n_trails=30, ) # Put everything together into an experiment and run it cornac.Experiment( eval_method=ratio_split, models=[gs_mf, rs_mf], metrics=[mae, rmse], user_based=False, ).run()
weighting="bm25", name="UserKNN-BM25") # ItemKNN methods item_knn_cosine = cornac.models.ItemKNN(k=K, similarity="cosine", name="ItemKNN-Cosine") item_knn_pearson = cornac.models.ItemKNN(k=K, similarity="pearson", name="ItemKNN-Pearson") item_knn_adjusted = cornac.models.ItemKNN(k=K, similarity="cosine", mean_centered=True, name="ItemKNN-AdjustedCosine") # Put everything together into an experiment cornac.Experiment( eval_method=ratio_split, models=[ user_knn_cosine, user_knn_pearson, user_knn_amp, user_knn_idf, user_knn_bm25, item_knn_cosine, item_knn_pearson, item_knn_adjusted, ], metrics=[cornac.metrics.RMSE()], user_based=True, ).run()
act_fn=best_params.get('act_fn'), beta=best_params.get('beta'), learning_rate=best_params.get('learning_rate'), batch_size=100, trainable=True, verbose=False, seed=123, use_gpu=True) mp = cornac.models.most_pop.recom_most_pop.MostPop(name='MostPop') # In[ ]: cornac.Experiment( eval_method=ratio_split, models=[vaecf, mp], metrics=[mae, rmse, recall25, recall50, ndcg, ncrr, auc, mAP, f1, hm], user_based=True, #save_dir=GLOBAL_DIR, ).run() # In[ ]: saved_path = vaecf.save(GLOBAL_DIR) item_idx2id = list(vaecf.train_set.item_ids) item_id2idx = vaecf.train_set.uid_map mp_item_idx2id = list(mp.train_set.item_ids) mapping = { 'vaecf': { 'item_idx2id': item_idx2id, 'item_id2idx': item_id2idx,
# -*- coding: utf-8 -*- """ Example for Matrix Factorization with biases @author: Quoc-Tuan Truong <*****@*****.**> """ import cornac from cornac.datasets import movielens from cornac.eval_methods import RatioSplit ratio_split = RatioSplit(data=movielens.load_1m(), test_size=0.2, exclude_unknowns=False, verbose=True) mf = cornac.models.MF(k=10, max_iter=25, learning_rate=0.01, lambda_reg=0.02, use_bias=True, early_stop=True, verbose=True) mae = cornac.metrics.MAE() rmse = cornac.metrics.RMSE() exp = cornac.Experiment(eval_method=ratio_split, models=[mf], metrics=[mae, rmse], user_based=True) exp.run()
# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ """Example for Maximum Margin Matrix Factorization on MovieLens 100K dataset""" import cornac # Load MovieLens 100K dataset, and binarise ratings using cornac.data.Reader feedback = cornac.datasets.movielens.load_feedback( variant="100K", reader=cornac.data.Reader(bin_threshold=1.0)) # Define an evaluation method to split feedback into train and test sets ratio_split = cornac.eval_methods.RatioSplit(data=feedback, test_size=0.2, verbose=True) mmmf = cornac.models.MMMF(k=10, max_iter=200, learning_rate=0.01, verbose=True) # Use NDCG@10 for evaluation ndcg = cornac.metrics.NDCG(k=10) # Put everything together into an experiment and run it cornac.Experiment(eval_method=ratio_split, models=[mmmf], metrics=[ndcg]).run()
ratio_split = RatioSplit( data=feedback, test_size=0.1, rating_threshold=0.5, exclude_unknowns=True, verbose=True, item_image=item_image_modality, ) # Instantiate CVAE vbpr = cornac.models.VBPR( k=10, k2=20, n_epochs=50, batch_size=100, learning_rate=0.005, lambda_w=1, lambda_b=0.01, lambda_e=0.0, use_gpu=True, ) # Instantiate evaluation measures auc = cornac.metrics.AUC() rec_50 = cornac.metrics.Recall(k=50) # Put everything together into an experiment and run it cornac.Experiment(eval_method=ratio_split, models=[vbpr], metrics=[auc, rec_50]).run()
n_bpr_samples=args.bpr_samples, n_element_samples=args.element_samples, lambda_reg=args.lambda_reg, lambda_bpr=args.lambda_bpr, max_iter=args.epoch, lr=args.learning_rate, verbose=args.verbose, seed=args.seed, ) exp = cornac.Experiment( eval_method=eval_method, models=[mter], metrics=[ cornac.metrics.RMSE(), cornac.metrics.Recall(k=10), cornac.metrics.Recall(k=50), cornac.metrics.NDCG(k=50), cornac.metrics.AUC(), ], ) exp.run() # save params and trained weights pd.DataFrame( data={ "raw_id": list(eval_method.train_set.uid_map.keys()), "id": list(eval_method.train_set.uid_map.values()), })[["raw_id", "id"]].to_csv(os.path.join(args.out, "uid_map"), header=None,
rs = RatioSplit(data=ml_100k, test_size=0.2, rating_threshold=4.0, seed=123) # initialize models, here we are comparing: Biased MF, PMF, and BPR models = [ MF(k=10, max_iter=25, learning_rate=0.01, lambda_reg=0.02, use_bias=True, seed=123), PMF(k=10, max_iter=100, learning_rate=0.001, lambda_reg=0.001, seed=123), BPR(k=10, max_iter=200, learning_rate=0.001, lambda_reg=0.01, seed=123), ] # define metrics to evaluate the models metrics = [ MAE(), RMSE(), Precision(k=10), Recall(k=10), NDCG(k=10), AUC(), MAP() ] # put it together in an experiment, voilà! cornac.Experiment(eval_method=rs, models=models, metrics=metrics, user_based=True).run()
ml_1m = movielens.load_feedback(variant="1M") # Define an evaluation method to split feedback into train and test sets ratio_split = RatioSplit( data=ml_1m, test_size=0.2, exclude_unknowns=False, verbose=True ) # Instantiate the global average baseline and MF model global_avg = cornac.models.GlobalAvg() mf = cornac.models.MF( k=10, max_iter=25, learning_rate=0.01, lambda_reg=0.02, use_bias=True, early_stop=True, verbose=True, ) # Instantiate MAE and RMSE for evaluation mae = cornac.metrics.MAE() rmse = cornac.metrics.RMSE() # Put everything together into an experiment and run it cornac.Experiment( eval_method=ratio_split, models=[global_avg, mf], metrics=[mae, rmse], user_based=True, ).run()
# Here we are comparing biased MF, PMF, and BPR mf = cornac.models.MF(k=10, max_iter=25, learning_rate=0.01, lambda_reg=0.02, use_bias=True, seed=123) pmf = cornac.models.PMF(k=10, max_iter=100, learning_rate=0.001, lambda_reg=0.001, seed=123) bpr = cornac.models.BPR(k=10, max_iter=200, learning_rate=0.001, lambda_reg=0.01, seed=123) # Define metrics used to evaluate the models mae = cornac.metrics.MAE() rmse = cornac.metrics.RMSE() recall = cornac.metrics.Recall(k=[10, 20]) ndcg = cornac.metrics.NDCG(k=[10, 20]) auc = cornac.metrics.AUC() # Put it together into an experiment and run cornac.Experiment(eval_method=rs, models=[mf, pmf, bpr], metrics=[mae, rmse, recall, ndcg, auc], user_based=True).run()
Continuous("lambda_u", low=1e-4, high=1e-1), Continuous("lambda_v", low=1e-4, high=1e-1), Continuous("learning_rate", low=1e-3, high=1e-1), Discrete('batch_size', [128, 256]), Continuous('a', low=0.8, high=1.4), Continuous('b', low=0.0, high=2e-1), ], metric=auc, eval_method=cv, n_trails=30, ) # In[9]: cornac.Experiment(eval_method=cv, models=[rs_wmf], metrics=[mae, rmse, recall, ndcg, auc, mAP], user_based=True).run() # In[ ]: with open("submission.txt", "w") as f: item_idx2id = list(rs_wmf.best_model.train_set.item_ids) last_ok = 0 for i in range(9402): try: f.write(" ".join([ str(item_idx2id[rec]) for rec in rs_wmf.best_model.rank(i)[0][0:50] ]) + "\n") last_ok = i except:
# ml_100k = cornac.datasets.movielens.load_feedback(variant="100K") rs = cornac.eval_methods.RatioSplit(data=data, test_size=0.2, rating_threshold=1.0, seed=123) bpr = cornac.models.BPR(k=10, max_iter=200, learning_rate=0.001, lambda_reg=0.01, seed=123) mae = cornac.metrics.MAE() rmse = cornac.metrics.RMSE() prec = cornac.metrics.Precision(k=10) recall = cornac.metrics.Recall(k=10) ndcg = cornac.metrics.NDCG(k=10) experi = cornac.Experiment( eval_method=rs, models=[ bpr], metrics=[mae, rmse, prec, recall, ndcg], user_based=True ) experi.run() # keys: ['MAE', 'RMSE', 'NDCG@10', 'Precision@10', 'Recall@10'] results = experi.result[0].metric_user_results hr = list(results['Precision@10'].values()) ndcg = list(results['NDCG@10'].values()) recall = list(results['Recall@10'].values()) print(#"MAP:\t%f" % eval_map, "Precision@K:\t%f" % np.mean(hr), "NDCG:\t%f" % np.mean(ndcg), "Recall@K:\t%f" % np.mean(recall),
def run_task(task_input): inputParam, username, current_run = task_input user_folder = "uploads/" + username run_folder = os.path.join(user_folder, str(current_run)) try: # Reading of Dataset and Metadata pathData = os.path.abspath("uploads/dataset/" + inputParam['data_file']) dataset = read_data(pathData) # pathMeta = cache(url = os.path.abspath("uploads/metadata/" + inputParam["meta_file"])) # metadata = read_meta(pathMeta) # Using Cornac eval_method = select_eval(inputParam["evalmethod"], dataset) model = select_model(inputParam) metrics = select_metrics(inputParam["metrics"], inputParam) exp = cornac.Experiment(eval_method=eval_method, models=[model], metrics=metrics, user_based=True) exp.run() exp_result = str(exp.result) result = exp_result.split("\n") # Splitting the output output = [] for line in result: if '|' in line: store = [] for data in line.split('|'): store.append(data) output.append(store) # Creating the run folder os.makedirs(run_folder) # Saving the trained model model_file = "trained_model.pkl" model_path = os.path.join(run_folder, model_file) f = open(model_path, "wb") pickle.dump(model, f) f.close() # Saving the run results results_path = user_folder + "/user_results.pkl" run_result = {} run_result["parameter"] = inputParam run_result["output"] = output result_dict = {current_run: run_result} f = open(results_path, "rb") user_results = pickle.load(f) user_results.update(result_dict) f.close() f = open(results_path, "wb") pickle.dump(user_results, f) f.close() print("Task completed!") except: results_path = user_folder + "/user_results.pkl" result_dict = {current_run: "Training error! Try again..."} f = open(results_path, "rb") user_results = pickle.load(f) user_results.update(result_dict) f.close() f = open(results_path, "wb") pickle.dump(user_results, f) f.close() print("Training Error!")
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ import cornac from cornac.datasets import movielens from cornac.eval_methods import RatioSplit from cornac.models import IBPR # Load the MovieLens 1M dataset ml_1m = movielens.load_1m() # Instantiate an evaluation method. ratio_split = RatioSplit(data=ml_1m, test_size=0.2, rating_threshold=1.0, exclude_unknowns=True, verbose=True) # Instantiate a IBPR recommender model. ibpr = IBPR(k=10, init_params={'U': None, 'V': None}, verbose=True) # Instantiate evaluation metrics. rec_20 = cornac.metrics.Recall(k=20) pre_20 = cornac.metrics.Precision(k=20) # Instantiate and then run an experiment. exp = cornac.Experiment(eval_method=ratio_split, models=[ibpr], metrics=[rec_20, pre_20], user_based=True) exp.run()
import cornac from cornac.datasets import movielens from cornac.eval_methods import RatioSplit from cornac.models import PMF # Load the MovieLens 100K dataset ml_100k = movielens.load_feedback() # Instantiate an evaluation method. ratio_split = RatioSplit(data=ml_100k, test_size=0.2, rating_threshold=4.0, exclude_unknowns=False) # Instantiate a PMF recommender model. pmf = PMF(k=10, max_iter=100, learning_rate=0.001, lambda_reg=0.001) # Instantiate evaluation metrics. mae = cornac.metrics.MAE() rmse = cornac.metrics.RMSE() rec_20 = cornac.metrics.Recall(k=20) pre_20 = cornac.metrics.Precision(k=20) # Instantiate and then run an experiment. cornac.Experiment( eval_method=ratio_split, models=[pmf], metrics=[mae, rmse, rec_20, pre_20], user_based=True, ).run()
# limitations under the License. # ============================================================================ """Example for Bayesian Personalized Ranking with Netflix dataset""" import cornac from cornac.data import Reader from cornac.datasets import netflix from cornac.eval_methods import RatioSplit ratio_split = RatioSplit( data=netflix.load_data_small(reader=Reader(bin_threshold=1.0)), test_size=0.1, rating_threshold=1.0, exclude_unknowns=True, verbose=True) most_pop = cornac.models.MostPop() bpr = cornac.models.BPR(k=10, max_iter=100, learning_rate=0.001, lambda_reg=0.01, verbose=True) auc = cornac.metrics.AUC() rec_20 = cornac.metrics.Recall(k=20) cornac.Experiment(eval_method=ratio_split, models=[most_pop, bpr], metrics=[auc, rec_20], user_based=True).run()
test_size=0.2, exclude_unknowns=True, rating_threshold=0.5, verbose=True, seed=123, item_text=item_text_modality, ) # Instantiate CVAE model cvae = cornac.models.CVAE( z_dim=50, vae_layers=[200, 100], act_fn="sigmoid", input_dim=8000, lr=0.001, batch_size=128, n_epochs=100, lambda_u=1e-4, lambda_v=0.001, lambda_r=10, lambda_w=1e-4, seed=123, verbose=True, ) # Use Recall@300 for evaluation rec_300 = cornac.metrics.Recall(k=300) # Put everything together into an experiment and run it cornac.Experiment(eval_method=ratio_split, models=[cvae], metrics=[rec_300]).run()
rating_threshold=0.5, ) # Instantiate the VAECF model vaecf = cornac.models.VAECF( k=10, autoencoder_structure=[20], act_fn="tanh", likelihood="mult", n_epochs=100, batch_size=100, learning_rate=0.001, beta=1.0, seed=123, use_gpu=True, verbose=True, ) # Instantiate evaluation measures rec_20 = cornac.metrics.Recall(k=20) ndcg_20 = cornac.metrics.NDCG(k=20) auc = cornac.metrics.AUC() # Put everything together into an experiment and run it cornac.Experiment( eval_method=ratio_split, models=[vaecf], metrics=[rec_20, ndcg_20, auc], user_based=True, ).run()
sentiment=md, seed=123) # Instantiate the EFM model efm = cornac.models.EFM(num_explicit_factors=40, num_latent_factors=60, num_most_cared_aspects=15, rating_scale=5.0, alpha=0.85, lambda_x=1, lambda_y=1, lambda_u=0.01, lambda_h=0.01, lambda_v=0.01, max_iter=100, num_threads=1, trainable=True, verbose=True, seed=123) # Instantiate evaluation metrics rmse = cornac.metrics.RMSE() ndcg_50 = cornac.metrics.NDCG(k=50) auc = cornac.metrics.AUC() # Put everything together into an experiment and run it exp = cornac.Experiment(eval_method=split_data, models=[efm], metrics=[rmse, ndcg_50, auc]) exp.run()