def main(year, min_count=None, outfile=None, drop=1): """ Main function for training and evaluating AAE methods on IREON data """ if (CLEAN == True): print("Loading data from", DATA_PATH) papers = load(DATA_PATH) print("Cleaning data...") clean(CLEAN_DATA_PATH, papers) print("Clean data in {}".format(CLEAN_DATA_PATH)) return print("Loading data from", CLEAN_DATA_PATH) papers = load(CLEAN_DATA_PATH) print("Unpacking IREON data...") # bags_of_papers, ids, side_info = unpack_papers(papers) bags_of_papers, ids, side_info = unpack_papers_conditions(papers) del papers bags = Bags(bags_of_papers, ids, side_info) if args.compute_mi: from aaerec.utils import compute_mutual_info print("[MI] Dataset: IREON (fiv)") print("[MI] min Count:", min_count) tmp = bags.build_vocab(min_count=min_count, max_features=None) mi = compute_mutual_info(tmp, conditions=None, include_labels=True, normalize=True) with open('mi.csv', 'a') as mifile: print('IREON', min_count, mi, sep=',', file=mifile) print("=" * 78) exit(0) log("Whole dataset:", logfile=outfile) log(bags, logfile=outfile) evaluation = Evaluation(bags, year, logfile=outfile) evaluation.setup(min_count=min_count, min_elements=2, drop=drop) # Use only partial citations/labels list (no additional metadata) with open(outfile, 'a') as fh: print("~ Partial List", "~" * 42, file=fh) evaluation(BASELINES + RECOMMENDERS) # Use additional metadata (as defined in CONDITIONS for all models but SVD, which uses only titles) with open(outfile, 'a') as fh: print("~ Conditioned Models", "~" * 42, file=fh) evaluation(CONDITIONED_MODELS)
def main(year, dataset, min_count=None, outfile=None, drop=1): """ Main function for training and evaluating AAE methods on DBLP data """ path = DATA_PATH + ("dblp-ref/" if dataset == "dblp" else "acm.txt") print("Loading data from", path) papers = papers_from_files(path, dataset, n_jobs=4) print("Unpacking {} data...".format(dataset)) bags_of_papers, ids, side_info = unpack_papers(papers) del papers bags = Bags(bags_of_papers, ids, side_info) if args.compute_mi: from aaerec.utils import compute_mutual_info print("[MI] Dataset:", dataset) print("[MI] min Count:", min_count) tmp = bags.build_vocab(min_count=min_count, max_features=None) mi = compute_mutual_info(tmp, conditions=None, include_labels=True, normalize=True) with open('mi.csv', 'a') as mifile: print(dataset, min_count, mi, sep=',', file=mifile) print("=" * 78) exit(0) log("Whole dataset:", logfile=outfile) log(bags, logfile=outfile) evaluation = Evaluation(bags, year, logfile=outfile) evaluation.setup(min_count=min_count, min_elements=2, drop=drop) # To evaluate the baselines and the recommenders without metadata (or just the recommenders without metadata) # with open(outfile, 'a') as fh: # print("~ Partial List", "~" * 42, file=fh) # evaluation(BASELINES + RECOMMENDERS) # evaluation(RECOMMENDERS, batch_size=1000) with open(outfile, 'a') as fh: print("~ Partial List + Titles + Author + Venue", "~" * 42, file=fh) # To evaluate SVD with titles # evaluation(TITLE_ENHANCED) evaluation(CONDITIONED_MODELS, batch_size=1000)
def main(): parser = argparse.ArgumentParser() parser.add_argument( '--model', type=str, defaule='aae', # All possible method should appear here choices=['cm', 'svd', 'ae', 'aae', 'mlp'], help="Specify the model to use [aae]") parser.add_argument('--epochs', type=int, default=20, help="Specify the number of training epochs [50]") parser.add_argument('--hidden', type=int, default=200, help="Number of hidden units [100]") parser.add_argument('--no-title', action='store_false', default=True, dest='use_title', help="Do not use the playlist titles") parser.add_argument('--max-items', type=int, default=75000, help="Limit the max number of considered items") parser.add_argument( '--vocab-size', type=int, default=50000, help="Limit the max number of distinct condition words") parser.add_argument('-j', '--jobs', type=int, default=4, help="Number of jobs for data loading [4].") parser.add_argument('-o', '--outfile', default="submission.csv", type=str, help="Write submissions to this path") parser.add_argument('--use-embedding', default=False, action='store_true', help="Use embedding (SGNS GoogleNews) [false]") parser.add_argument('--dont-aggregate', action='store_false', dest='aggregate', default=True, help="Aggregate track metadata as side info input") parser.add_argument('--debug', action='store_true', default=False, help="Activate debug mode, run only on small sample") parser.add_argument( '-x', '--exclude', type=argparse.FileType('r'), default=None, help="Path to file with slice filenames to exclude for training") parser.add_argument( '--dev', type=str, default=None, help='Path to dev set, use in combination with (-x, --exclude)') parser.add_argument('--no-idf', action='store_false', default=True, dest='use_idf', help="Do **not** use idf re-weighting") parser.add_argument('--lr', type=float, default=0.001, help="Initial learning rate [0.001]") parser.add_argument('--code', type=int, default=100, help="Code dimension [50]") args = parser.parse_args() # Either exclude and dev set, or no exclude and test set assert (args.dev is None) == (args.exclude is None) if args.dev is not None: print("Making submission for dev set:", args.dev) assert os.path.isfile(args.dev) # Dump args into submission file if os.path.exists(args.outfile) and \ input("Path '{}' exists. Overwrite? [y/N]" .format(args.outfile)) != 'y': exit(-1) with open(args.outfile, 'w') as out: print('#', args, file=out) if args.use_embedding: print("Loading embedding:", W2V_PATH) vectors = KeyedVectors.load_word2vec_format(W2V_PATH, binary=W2V_IS_BINARY) else: vectors = None # Create the model as specified by command line args # Count-based never uses title # Decoding recommender always uses title tfidf_params = {'max_features': args.vocab_size, 'use_idf': args.use_idf} model = { 'cm': Countbased(), 'svd': SVDRecommender(use_title=args.use_title), 'ae': AAERecommender(use_title=args.use_title, adversarial=False, n_hidden=args.hidden, n_code=args.code, n_epochs=args.epochs, embedding=vectors, lr=args.lr, tfidf_params=tfidf_params), 'aae': AAERecommender( use_title=args.use_title, adversarial=True, n_hidden=args.hidden, n_code=args.code, n_epochs=args.epochs, gen_lr=args.lr, reg_lr=args.lr, # same gen and reg lrs embedding=vectors, tfidf_params=tfidf_params), 'mlp': DecodingRecommender(n_epochs=args.epochs, n_hidden=args.hidden, embedding=vectors, tfidf_params=tfidf_params) }[args.model] track_attrs = TRACK_INFO if args.aggregate else None if args.exclude is not None: # Dev set case, exclude dev set data exclude = [line.strip() for line in args.exclude] else: # Real submission case, do not exclude any training data exclude = None # = Training = print("Loading data from {} using {} jobs".format(DATA_PATH, args.jobs)) playlists = playlists_from_slices(DATA_PATH, n_jobs=args.jobs, debug=args.debug, without=exclude) print("Unpacking playlists") train_set = Bags(*unpack_playlists(playlists, aggregate=track_attrs)) print("Building vocabulary of {} most frequent items".format( args.max_items)) vocab, __counts = train_set.build_vocab(max_features=args.max_items, apply=False) train_set = train_set.apply_vocab(vocab) print("Training set:", train_set, sep='\n') print("Training for {} epochs".format(args.epochs)) try: model.train(train_set) except KeyboardInterrupt: print("Training interrupted by keyboard, pass.") # Not required anymore del train_set # = Predictions = if args.dev is not None: print("Loading and unpacking DEV set") data, index2playlist, side_info = unpack_playlists( load(args.dev), aggregate=track_attrs) else: print("Loading and unpacking test set") data, index2playlist, side_info = unpack_playlists( load(TEST_PATH), aggregate=track_attrs) test_set = Bags(data, index2playlist, side_info) # Apply same vocabulary as in training test_set = test_set.apply_vocab(vocab) print("Test set:", test_set, sep='\n') pred = model.predict(test_set) if sp.issparse(pred): pred = pred.toarray() else: pred = np.asarray(pred) print("Scaling and removing non-missing items") pred = remove_non_missing(pred, test_set.tocsr(), copy=False) index2trackid = {v: k for k, v in vocab.items()} print("Making submission:", args.outfile) make_submission(pred, index2playlist, index2trackid, outfile=args.outfile) print("Success.") print("Make sure to verify the submission format via", VERIFY_SCRIPT)
def main(outfile=None, min_count=None, aggregate=None): """ Main function for training and evaluating AAE methods on MDP data """ print("Loading data from", DATA_PATH) playlists = playlists_from_slices(DATA_PATH, n_jobs=4) print("Unpacking json data...") bags_of_tracks, pids, side_info = unpack_playlists_for_models_concatenated( playlists) del playlists bags = Bags(data=bags_of_tracks, owners=pids, owner_attributes=side_info) if args.compute_mi: from sklearn.metrics import mutual_info_score print("Computing MI") X = bags.build_vocab(min_count=args.min_count, max_features=None).tocsr() C = X.T @ X print("(Pairwise) mutual information:", mutual_info_score(None, None, contingency=C)) # Exit in this case print("Bye.") exit(0) log("Whole dataset:", logfile=outfile) log(bags, logfile=outfile) train_set, dev_set, y_test = prepare_evaluation(bags, n_items=N_ITEMS, min_count=min_count) log("Train set:", logfile=outfile) log(train_set, logfile=outfile) log("Dev set:", logfile=outfile) log(dev_set, logfile=outfile) # THE GOLD (put into sparse matrix) y_test = lists2sparse(y_test, dev_set.size(1)).tocsr(copy=False) # the known items in the test set, just to not recompute x_test = lists2sparse(dev_set.data, dev_set.size(1)).tocsr(copy=False) for model in MODELS: log('=' * 78, logfile=outfile) log(model, logfile=outfile) log(model.model_params, logfile=outfile) # Training model.train(train_set) print("training finished") # Prediction y_pred = model.predict(dev_set) print("prediction finished") print(" prediction sparse?:", sp.issparse(y_pred)) # Sanity-fix #1, make sparse stuff dense, expect array if sp.issparse(y_pred): y_pred = y_pred.toarray() else: y_pred = np.asarray(y_pred) print("remove non-missing:") # Sanity-fix, remove predictions for already present items y_pred = remove_non_missing(y_pred, x_test, copy=False) print("evaluate:") # Evaluate metrics results = evaluate(y_test, y_pred, METRICS, batch_size=500) print("metrics: ") log("-" * 78, logfile=outfile) for metric, stats in zip(METRICS, results): log("* {}: {} ({})".format(metric, *stats), logfile=outfile) log('=' * 78, logfile=outfile)
set_cnts = collections.OrderedDict(sorted(set_cnts.items())) if dataset == "pubmed" or dataset == "acm" or dataset == "dblp": x_dim = "References" elif dataset == "mpd": x_dim = "Tracks" else: x_dim = "Labels" print("Plotting papers' distribution by number of their {} on file".format( x_dim.lower())) y_dim = "Papers" if dataset != "mpd" else "Playlists" # show the y-value for the bar at x=mark_x_set in the plot plot(set_cnts, dataset, x_dim, y_dim, mark_x_set) bags = bags.build_vocab(apply=True) csr = bags.tocsr() print("N ratings:", csr.sum()) column_sums = csr.sum(0).flatten() row_sums = csr.sum(1).flatten() print(column_sums.shape) print(row_sums.shape) FMT = "N={}, Min={}, Max={} Median={}, Mean={}, Std={}" print("Items per document") print(FMT.format(*compute_stats(row_sums))) print("Documents per item")
def main(year, dataset, min_count=None, outfile=None, drop=1, baselines=False, autoencoders=False, conditioned_autoencoders=False, all_metadata=True): """ Main function for training and evaluating AAE methods on DBLP data """ assert baselines or autoencoders or conditioned_autoencoders, "Please specify what to run" if all_metadata: # V2 - all metadata CONDITIONS = ConditionList([ ('title', PretrainedWordEmbeddingCondition(VECTORS)), ('venue', PretrainedWordEmbeddingCondition(VECTORS)), ( 'author', CategoricalCondition( embedding_dim=32, reduce="sum", # vocab_size=0.01, sparse=False, embedding_on_gpu=True)) ]) else: # V1 - only title metadata CONDITIONS = ConditionList([ ('title', PretrainedWordEmbeddingCondition(VECTORS)) ]) #### CONDITOINS defined ALL_MODELS = [] if baselines: # Models without metadata BASELINES = [ # RandomBaseline(), # MostPopular(), Countbased(), SVDRecommender(1000, use_title=False) ] ALL_MODELS += BASELINES if not all_metadata: # SVD can use only titles not generic conditions ALL_MODELS += [SVDRecommender(1000, use_title=True)] if autoencoders: AUTOENCODERS = [ AAERecommender(adversarial=False, conditions=None, lr=0.001, **AE_PARAMS), AAERecommender(adversarial=True, conditions=None, gen_lr=0.001, reg_lr=0.001, **AE_PARAMS), VAERecommender(conditions=None, **AE_PARAMS), DAERecommender(conditions=None, **AE_PARAMS) ] ALL_MODELS += AUTOENCODERS if conditioned_autoencoders: # Model with metadata (metadata used as set in CONDITIONS above) CONDITIONED_AUTOENCODERS = [ AAERecommender(adversarial=False, conditions=CONDITIONS, lr=0.001, **AE_PARAMS), AAERecommender(adversarial=True, conditions=CONDITIONS, gen_lr=0.001, reg_lr=0.001, **AE_PARAMS), DecodingRecommender(CONDITIONS, n_epochs=100, batch_size=1000, optimizer='adam', n_hidden=100, lr=0.001, verbose=True), VAERecommender(conditions=CONDITIONS, **AE_PARAMS), DAERecommender(conditions=CONDITIONS, **AE_PARAMS) ] ALL_MODELS += CONDITIONED_AUTOENCODERS print("Finished preparing models:", *ALL_MODELS, sep='\n\t') path = DATA_PATH + ("dblp-ref/" if dataset == "dblp" else "acm.txt") print("Loading data from", path) papers = papers_from_files(path, dataset, n_jobs=4) print("Unpacking {} data...".format(dataset)) bags_of_papers, ids, side_info = unpack_papers(papers) del papers bags = Bags(bags_of_papers, ids, side_info) if args.compute_mi: from aaerec.utils import compute_mutual_info print("[MI] Dataset:", dataset) print("[MI] min Count:", min_count) tmp = bags.build_vocab(min_count=min_count, max_features=None) mi = compute_mutual_info(tmp, conditions=None, include_labels=True, normalize=True) with open('mi.csv', 'a') as mifile: print(dataset, min_count, mi, sep=',', file=mifile) print("=" * 78) exit(0) log("Whole dataset:", logfile=outfile) log(bags, logfile=outfile) evaluation = Evaluation(bags, year, logfile=outfile) evaluation.setup(min_count=min_count, min_elements=2, drop=drop) with open(outfile, 'a') as fh: print("~ Partial List + Titles + Author + Venue", "~" * 42, file=fh) evaluation(ALL_MODELS, batch_size=1000)