def testPerplexityOnRealData(self):
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=AclWordPath, links_file=AclCitePath)
with open(AclDictPath, "rb") as f:
d = pkl.load(f)
data.convert_to_dtype(dtype)
data.prune_and_shuffle(min_doc_len=MinDocLen, min_link_count=MinLinkCount)
# IDF frequency for when we print out the vocab later
freq = np.squeeze(np.asarray(data.words.sum(axis=0)))
scale = np.reciprocal(1 + freq)
# Initialise the model
K = 50
model = mtm.newModelAtRandom(data, K, K - 1, dtype=dtype)
queryState = mtm.newQueryState(data, model)
trainPlan = mtm.newTrainPlan(iterations=200, logFrequency=10, fastButInaccurate=False, debug=True)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, query, (bndItrs, bndVals, bndLikes) = mtm.train (data, model, queryState, trainPlan)
# with open(newModelFileFromModel(model), "wb") as f:
# pkl.dump ((model, query, (bndItrs, bndVals, bndLikes)), f)
# Plot the evolution of the bound during training.
fig, ax1 = plt.subplots()
ax1.plot(bndItrs, bndVals, 'b-')
ax1.set_xlabel('Iterations')
ax1.set_ylabel('Bound', color='b')
ax2 = ax1.twinx()
ax2.plot(bndItrs, bndLikes, 'r-')
ax2.set_ylabel('Likelihood', color='r')
fig.show()
plt.show()
fig, ax1 = plt.subplots()
ax1.imshow(model.topicCov, interpolation="nearest", cmap=cm.Greys_r)
fig.show()
plt.show()
# Print out the most likely topic words
# scale = np.reciprocal(1 + np.squeeze(np.array(data.words.sum(axis=0))))
vocab = mtm.wordDists(model)
topWordCount = 10
kTopWordInds = [self.topWordInds(vocab[k,:], topWordCount) for k in range(K)]
like = mtm.log_likelihood(data, model, query)
perp = perplexity_from_like(like, data.word_count)
print ("Prior %s" % (str(model.topicPrior)))
print ("Perplexity: %f\n\n" % perp)
for k in range(model.K):
print("\nTopic %d\n=============================" % k)
print("\n".join("%-20s\t%0.4f" % (d[kTopWordInds[k][c]], vocab[k][kTopWordInds[k][c]]) for c in range(topWordCount)))
def testOnRealData(self):
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=NipsWordsPath, links_file=NipsCitePath)
with open(NipsDictPath, "rb") as f:
d = pkl.load(f)
data.convert_to_dtype(dtype)
data.prune_and_shuffle(min_doc_len=50, min_link_count=0)
# IDF frequency for when we print out the vocab later
freq = np.squeeze(np.asarray(data.words.sum(axis=0)))
scale = np.reciprocal(1 + freq)
# Initialise the model
K = 10
model = lda.newModelAtRandom(data, K, dtype=dtype)
queryState = lda.newQueryState(data, model)
trainPlan = lda.newTrainPlan(iterations=30, logFrequency=2, debug=False, batchSize=50, rate_retardation=1, forgetting_rate=0.75)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, query, (bndItrs, bndVals, bndLikes) = lda.train (data, model, queryState, trainPlan)
# with open(newModelFileFromModel(model), "wb") as f:
# pkl.dump ((model, query, (bndItrs, bndVals, bndLikes)), f)
# Plot the evolution of the bound during training.
fig, ax1 = plt.subplots()
ax1.plot(bndItrs, bndVals, 'b-')
ax1.set_xlabel('Iterations')
ax1.set_ylabel('Bound', color='b')
ax2 = ax1.twinx()
ax2.plot(bndItrs, bndLikes, 'r-')
ax2.set_ylabel('Likelihood', color='r')
fig.show()
plt.show()
vocab = lda.wordDists(model)
plt.imshow(vocab, interpolation="nearest", cmap=cm.Greys_r)
plt.show()
# Print out the most likely topic words
topWordCount = 100
kTopWordInds = [topWordIndices(vocab[k, :] * scale, topWordCount) \
for k in range(K)]
# Print out the most likely topic words
print("Prior %s" % (str(model.topicPrior)))
print("Perplexity: %f\n\n" % word_perplexity(lda.log_likelihood, model, query, data))
print("")
printWordDists(K, lda.wordDists(model), d)
def testPerplexityOnRealDataWithLdaInc(self):
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=AclWordPath, links_file=AclCitePath)
with open(AclDictPath, "rb") as f:
d = pkl.load(f)
data.convert_to_dtype(dtype)
data.prune_and_shuffle(min_doc_len=MinDocLen, min_link_count=MinLinkCount)
# IDF frequency for when we print out the vocab later
freq = np.squeeze(np.asarray(data.words.sum(axis=0)))
scale = np.reciprocal(1 + freq)
# Initialise the model
topicCounts = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
perps = []
for K in topicCounts:
model = lda.newModelAtRandom(data, K, dtype=dtype)
queryState = lda.newQueryState(data, model)
trainPlan = lda.newTrainPlan(iterations=800, logFrequency=10, fastButInaccurate=False, debug=False)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, query, (bndItrs, bndVals, bndLikes) = lda.train (data, model, queryState, trainPlan)
# with open(newModelFileFromModel(model), "wb") as f:
# pkl.dump ((model, query, (bndItrs, bndVals, bndLikes)), f)
# Print out the most likely topic words
# scale = np.reciprocal(1 + np.squeeze(np.array(data.words.sum(axis=0))))
# vocab = lda.wordDists(model)
# topWordCount = 10
# kTopWordInds = [self.topWordInds(vocab[k,:], topWordCount) for k in range(K)]
like = lda.log_likelihood(data, model, query)
perp = perplexity_from_like(like, data.word_count)
perps.append(perp)
print ("K = %2d : Perplexity = %f\n\n" % (K, perp))
#
# for k in range(model.K):
# print("\nTopic %d\n=============================" % k)
# print("\n".join("%-20s\t%0.4f" % (d[kTopWordInds[k][c]], vocab[k][kTopWordInds[k][c]]) for c in range(topWordCount)))
# Plot the evolution of the bound during training.
fig, ax1 = plt.subplots()
ax1.plot(topicCounts, perps, 'b-')
ax1.set_xlabel('Topic Count')
ax1.set_ylabel('Perplexity', color='b')
fig.show()
plt.show()
def testCrossValPerplexityOnRealDataWithLdaGibbsInc(self):
ActiveFolds = 3
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=AclWordPath, links_file=AclCitePath)
data.convert_to_dtype(np.int32) # Gibbs expects integers as input, regardless of model dtype
data.prune_and_shuffle(min_doc_len=MinDocLen, min_link_count=MinLinkCount)
# Training setup
TrainSamplesPerTopic = 10
QuerySamplesPerTopic = 2
Thin = 2
Debug = False
# Start running experiments
topicCounts = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
for K in topicCounts:
trainPlan = lda_gibbs.newTrainPlan(K * TrainSamplesPerTopic, thin=Thin, debug=Debug)
queryPlan = lda_gibbs.newTrainPlan(K * QuerySamplesPerTopic, thin=Thin, debug=Debug)
trainPerps = []
queryPerps = []
for fold in range(ActiveFolds): # range(NumFolds):
trainData, queryData = data.cross_valid_split(fold, NumFolds)
estData, evalData = queryData.doc_completion_split()
model = lda_gibbs.newModelAtRandom(trainData, K, dtype=dtype)
query = lda_gibbs.newQueryState(trainData, model)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, trainResult, (_, _, _) = lda_gibbs.train (trainData, model, query, trainPlan)
like = lda_gibbs.log_likelihood(trainData, model, trainResult)
perp = perplexity_from_like(like, trainData.word_count)
trainPerps.append(perp)
query = lda_gibbs.newQueryState(estData, model)
_, queryResult = lda_gibbs.query(estData, model, query, queryPlan)
like = lda_gibbs.log_likelihood(evalData, model, queryResult)
perp = perplexity_from_like(like, evalData.word_count)
queryPerps.append(perp)
trainPerps.append(sum(trainPerps) / ActiveFolds)
queryPerps.append(sum(queryPerps) / ActiveFolds)
print("K=%d,Segment=Train,%s" % (K, ",".join([str(p) for p in trainPerps])))
print("K=%d,Segment=Query,%s" % (K, ",".join([str(p) for p in queryPerps])))
def testCrossValPerplexityOnRealDataWithLdaInc(self):
ActiveFolds = 3
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=AclWordPath, links_file=AclCitePath)
data.convert_to_dtype(dtype)
data.prune_and_shuffle(min_doc_len=MinDocLen, min_link_count=MinLinkCount)
# Initialise the model
trainPlan = lda.newTrainPlan(iterations=800, logFrequency=10, fastButInaccurate=False, debug=False)
queryPlan = lda.newTrainPlan(iterations=50, logFrequency=5, fastButInaccurate=False, debug=False)
topicCounts = [30, 35, 40, 45, 50] # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
for K in topicCounts:
trainPerps = []
queryPerps = []
for fold in range(ActiveFolds): # range(NumFolds):
trainData, queryData = data.cross_valid_split(fold, NumFolds)
model = lda.newModelAtRandom(trainData, K, dtype=dtype)
query = lda.newQueryState(trainData, model)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, trainResult, (_, _, _) = lda.train (trainData, model, query, trainPlan)
like = lda.log_likelihood(trainData, model, trainResult)
perp = perplexity_from_like(like, trainData.word_count)
trainPerps.append(perp)
estData, evalData = queryData.doc_completion_split()
query = lda.newQueryState(estData, model)
model, queryResult = lda.query(estData, model, query, queryPlan)
like = lda.log_likelihood(evalData, model, queryResult)
perp = perplexity_from_like(like, evalData.word_count)
queryPerps.append(perp)
trainPerps.append(sum(trainPerps) / ActiveFolds)
queryPerps.append(sum(queryPerps) / ActiveFolds)
print("K=%d,Segment=Train,%s" % (K, ",".join([str(p) for p in trainPerps])))
print("K=%d,Segment=Query,%s" % (K, ",".join([str(p) for p in queryPerps])))
def testOnRealData(self):
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=TNewsWordsPath)
with open(TNewsDictPath, "rb") as f:
d = pkl.load(f)
data.convert_to_dtype(dtype)
data.prune_and_shuffle(min_doc_len=50, min_link_count=0)
# Initialise the model
K = 6
model = mom.newModelAtRandom(data, K, dtype=dtype)
queryState = mom.newQueryState(data, model)
# trainPlan = mom.newTrainPlan(iterations=1000, logFrequency=10, debug=False, burnIn=1000, thinning=10)
trainPlan = mom.newTrainPlan(iterations=200, logFrequency=10, debug=False)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, query, (bndItrs, bndVals, bndLikes) = mom.train (data, model, queryState, trainPlan)
# with open(newModelFileFromModel(model), "wb") as f:
# pkl.dump ((model, query, (bndItrs, bndVals, bndLikes)), f)
# Plot the evolution of the bound during training.
fig, ax1 = plt.subplots()
ax1.plot(bndItrs, bndVals, 'b-')
ax1.set_xlabel('Iterations')
ax1.set_ylabel('Bound', color='b')
ax2 = ax1.twinx()
ax2.plot(bndItrs, bndLikes, 'r-')
ax2.set_ylabel('Likelihood', color='r')
fig.show()
plt.show()
# Print out the most likely topic words
print ("Prior %s" % (str(model.topicPrior)))
print ("Perplexity: %f\n\n" % word_perplexity(mom.log_likelihood, model, query, data))
print ("")
printWordDists(K, mom.wordDists(model), d)
def testMapOnRealData(self):
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=AclWordPath, links_file=AclCitePath)
with open(AclDictPath, "rb") as f:
dic = pkl.load(f)
data.convert_to_dtype(dtype)
data.convert_to_undirected_graph()
data.convert_to_binary_link_matrix()
data.prune_and_shuffle(min_doc_len=MinDocLen, min_link_count=MinLinkCount)
trainData, testData = data.doc_completion_split()
for pseudoNegCount in (5, 10, 25, 50, 100):
rd.seed(0xC0FFEE)
# Initialise the model
K = TopicCount
model = rtm.newModelAtRandom(trainData, K, dtype=dtype, pseudoNegCount=data.doc_count * pseudoNegCount)
queryState = rtm.newQueryState(trainData, model)
trainPlan = rtm.newTrainPlan(iterations=50, logFrequency=LogFreq, fastButInaccurate=False, debug=True)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, topics, (bndItrs, bndVals, bndLikes) = rtm.train(trainData, model, queryState, trainPlan)
# with open(newModelFileFromModel(model), "wb") as f:
# pkl.dump ((model, query, (bndItrs, bndVals, bndLikes)), f)
# Plot the evolution of the bound during training.
fig, ax1 = plt.subplots()
ax1.plot(bndItrs, bndVals, 'b-')
ax1.set_xlabel('Iterations')
ax1.set_ylabel('Bound', color='b')
ax2 = ax1.twinx()
ax2.plot(bndItrs, bndLikes, 'r-')
ax2.set_ylabel('Likelihood', color='r')
fig.show()
plt.show()
# Print out the most likely topic words
# scale = np.reciprocal(1 + np.squeeze(np.array(data.words.sum(axis=0))))
vocab = rtm.wordDists(model)
topWordCount = 10
kTopWordInds = [self.topWordInds(vocab[k, :], topWordCount) for k in range(K)]
like = rtm.log_likelihood(trainData, model, topics)
perp = perplexity_from_like(like, trainData.word_count)
# print ("Prior %s" % (str(model.topicPrior)))
print ("Pseudo Neg-Count: %d " % pseudoNegCount)
print ("\tTrain Perplexity: %f\n\n" % perp)
# for k in range(model.K):
# print ("\nTopic %d\n=============================" % k)
# print ("\n".join("%-20s\t%0.4f" % (dic[kTopWordInds[k][c]], vocab[k][kTopWordInds[k][c]]) for c in range(topWordCount)))
min_probs = rtm.min_link_probs(model, topics, testData.links)
link_probs = rtm.link_probs(model, topics, min_probs)
try:
map = mean_average_prec(testData.links, link_probs)
except:
print ("Unexpected error")
print("\tThe Mean-Average-Precision is %.3f" % map)
def testPerplexityOnRealDataWithMtm2(self):
dtype = np.float64 # DTYPE
rd.seed(0xBADB055)
data = DataSet.from_files(words_file=AclWordPath, links_file=AclCitePath)
with open(AclDictPath, "rb") as f:
d = pkl.load(f)
data.convert_to_dtype(dtype)
data.prune_and_shuffle(min_doc_len=MinDocLen, min_link_count=MinLinkCount)
# IDF frequency for when we print out the vocab later
freq = np.squeeze(np.asarray(data.words.sum(axis=0)))
scale = np.reciprocal(1 + freq)
# Initialise the model
K = 30 # TopicCount
model = mtm2.newModelAtRandom(data, K, dtype=dtype)
queryState = mtm2.newQueryState(data, model)
trainPlan = mtm2.newTrainPlan(iterations=200, logFrequency=10, fastButInaccurate=False, debug=False)
# Train the model, and the immediately save the result to a file for subsequent inspection
model, query, (bndItrs, bndVals, bndLikes) = mtm2.train(data, model, queryState, trainPlan)
# with open(newModelFileFromModel(model), "wb") as f:
# pkl.dump ((model, query, (bndItrs, bndVals, bndLikes)), f)
# Plot the evolution of the bound during training.
fig, ax1 = plt.subplots()
ax1.plot(bndItrs, bndVals, 'b-')
ax1.set_xlabel('Iterations')
ax1.set_ylabel('Bound', color='b')
ax2 = ax1.twinx()
ax2.plot(bndItrs, bndLikes, 'r-')
ax2.set_ylabel('Likelihood', color='r')
fig.show()
plt.show()
fig, ax1 = plt.subplots()
ax1.imshow(model.topicCov, interpolation="nearest", cmap=cm.Greys_r)
fig.show()
plt.show()
# Print out the most likely topic words
# scale = np.reciprocal(1 + np.squeeze(np.array(data.words.sum(axis=0))))
vocab = mtm2.wordDists(model)
topWordCount = 10
kTopWordInds = [self.topWordInds(vocab[k,:], topWordCount) for k in range(K)]
like = mtm2.log_likelihood(data, model, query)
perp = perplexity_from_like(like, data.word_count)
print("Perplexity: %f\n\n" % perp)
for k in range(model.K):
print("\nTopic %d\n=============================" % k)
print("\n".join("%-20s\t%0.4f" % (d[kTopWordInds[k][c]], vocab[k][kTopWordInds[k][c]]) for c in range(topWordCount)))
print ("Most likely documents for each topic")
print ("====================================")
with open ("/Users/bryanfeeney/iCloud/Datasets/ACL/ACL.100/doc_ids.pkl", 'rb') as f:
fileIds = pkl.load (f)
docs_dict = [fileIds[fi] for fi in data.order]
for k in range(model.K):
arg_max_prob = np.argmax(query.means[:, k])
print("K=%2d Document ID = %s (found at %d)" % (k, docs_dict[arg_max_prob], arg_max_prob))
print ("Done")
with open ("/Users/bryanfeeney/Desktop/mtm2-" + str(K) + ".pkl", "wb") as f:
pkl.dump((model, query), f)
def run(args):
'''
Parses the command-line arguments (excluding the application name portion).
Executes a cross-validation run accordingly, saving the output at the end
of each run.
Returns the list of files created.
'''
#
# Enumerate all possible arguments
#
parser = ap.ArgumentParser(description='Execute a topic-modeling run.')
parser.add_argument('--model', '-m', dest='model', metavar=' ', \
help='The type of mode to use, options are ' + ModelNames)
parser.add_argument('--num-topics', '-k', dest='K', type=int, metavar=' ', \
help='The number of topics to fit')
parser.add_argument('--num-lat-topics', '-q', dest='Q', type=int, metavar=' ', \
help='The number of latent topics (i.e. rank of the topic covariance matrix)')
parser.add_argument('--num-lat-feats', '-p', dest='P', type=int, metavar=' ', \
help='The number of latent features (i.e. rank of the features covariance matrix)')
parser.add_argument('--words', '-w', dest='words', metavar=' ', \
help='The path to the pickle file containing a DxT array or matrix of the word-counts across all D documents')
parser.add_argument('--feats', '-x', dest='feats', metavar=' ', \
help='The path to the pickle file containing a DxF array or matrix of the features across all D documents')
parser.add_argument('--links', '-c', dest='links', metavar=' ', \
help='The path to the pickle file containing a DxP array or matrix of the links (citations) emanated by all D documents')
parser.add_argument('--eval', '-v', dest='eval', default=Perplexity, metavar=' ', \
help='Evaluation metric, available options are: ' + ','.join(EvalNames))
parser.add_argument('--out-model', '-o', dest='out_model', default=None, metavar=' ', \
help='Optional output path in which to store the model')
parser.add_argument('--log-freq', '-l', dest='log_freq', type=int, default=10, metavar=' ', \
help='Log frequency - how many times to inspect the bound while running')
parser.add_argument('--iters', '-i', dest='iters', type=int, default=500, metavar=' ', \
help='The maximum number of iterations to run when training')
parser.add_argument('--query-iters', '-j', dest='query_iters', type=int, default=100, metavar=' ', \
help='The maximum number of iterations to run when querying, by default same as when training')
parser.add_argument('--min-vb-change', '-e', dest='min_vb_change', type=float, default=1, metavar=' ', \
help='The amount by which the variational bound must change at each log-interval to avoid inference being stopped early.')
parser.add_argument('--topic-var', dest='topic_var', type=float, default=DefaultPriorCov, metavar=' ', \
help="Scale of the prior isotropic variance over topics")
parser.add_argument('--feat-var', dest='feat_var', type=float, default=DefaultPriorCov, metavar=' ', \
help="Scale of the prior isotropic variance over features")
parser.add_argument('--lat-topic-var', dest='lat_topic_var', type=float, default=DefaultPriorCov, metavar=' ', \
help="Scale of the prior isotropic variance over latent topics")
parser.add_argument('--lat-feat-var', dest='lat_feat_var', type=float, default=DefaultPriorCov, metavar=' ', \
help="Scale of the prior isotropic variance over latent features")
parser.add_argument('--vocab-prior', dest='vocabPrior', type=float, default=1.1, metavar=' ', \
help="Symmetric prior over the vocabulary")
parser.add_argument('--folds', '-f', dest='folds', type=int, default=1, metavar=' ', \
help="Number of cross validation folds.")
parser.add_argument('--truncate-folds', dest='eval_fold_count', type=int, default=-1, metavar=' ', \
help="If set, stop running after the given number of folds had been processed")
parser.add_argument('--debug', '-b', dest='debug', type=bool, default=False, metavar=' ', \
help="Display a debug message, with the bound, after every variable update")
parser.add_argument('--dtype', '-t', dest='dtype', default="f4:f4", metavar=' ', \
help="Datatype to use, values are i4, f4 and f8. Specify two, a data dtype and model dtype, delimited by a colon")
parser.add_argument('--limit-to', dest='limit', type=int, default=0, metavar=' ', \
help="If set, discard all but the initial given number of rows of the input dataset")
parser.add_argument('--word-dict', dest='word_dict', default=None, metavar=' ', \
help='A dictionary of all words. Used to identify hashtag indices')
parser.add_argument('--lda-model', dest='ldaModel', default=None, metavar=' ', \
help='A trained LDA model, used with the LRO model')
parser.add_argument('--feats-mask', dest='features_mask_str', default=None, metavar=' ', \
help='Feature mask to use with FeatSplit runs, comma-delimited list of colon-delimited pairs')
#
# Initialization of the app: first parse the arguments
#
print("Random seed is 0xC0FFEE")
rd.seed(0xC0FFEE)
print("Args are : " + str(args))
args = parser.parse_args(args)
K, P, Q = args.K, args.P, args.Q
features_mask = parse_features_mask(args)
(input_dtype, output_dtype) = parse_dtypes(args.dtype)
fv, tv, lfv, ltv = args.feat_var, args.topic_var, args.lat_feat_var, args.lat_topic_var
#
# Load and prune the data
#
data = DataSet.from_files(args.words, args.feats, args.links, limit=args.limit)
data.convert_to_dtype(input_dtype)
data.prune_and_shuffle(min_doc_len=3, min_link_count=MinLinkCountPrune)
print ("The combined word-count of the %d documents is %.0f, drawn from a vocabulary of %d distinct terms" % (data.doc_count, data.word_count, data.words.shape[1]))
if data.add_intercept_to_feats_if_required():
print ("Appended an intercept to the given features")
#
# Instantiate and configure the model
#
if args.ldaModel is not None:
ldaModel, ldaTopics = load_and_adapt_lda_model(args.ldaModel, data.order)
else:
ldaModel, ldaTopics = None, None
print ("Building template model... ", end="")
if args.model == CtmBouchard:
import model.ctm as mdl
templateModel = mdl.newModelAtRandom(data, K, args.vocabPrior, dtype=output_dtype)
elif args.model == CtmBohning:
import model.ctm_bohning as mdl
templateModel = mdl.newModelAtRandom(data, K, args.vocabPrior, dtype=output_dtype)
elif args.model == StmYvBouchard:
import model.stm_yv as mdl
templateModel = mdl.newModelAtRandom(data, P, K, fv, lfv, args.vocabPrior, dtype=output_dtype)
elif args.model == StmYvBohning:
import model.stm_yv_bohning as mdl
templateModel = mdl.newModelAtRandom(data, P, K, fv, lfv, args.vocabPrior, dtype=output_dtype)
elif args.model == StmYvBohningFakeOnline:
import model.stm_yv_bohning_fake_online as mdl
templateModel = mdl.newModelAtRandom(data, P, K, fv, lfv, args.vocabPrior, dtype=output_dtype)
elif args.model == StmUyvBohning:
import model.stm_uv_vec_y_bohning as mdl
templateModel = mdl.newModelAtRandom(data, K=K, Q=Q, P=P, tv=tv, ltv=ltv, fv=fv, lfv=lfv, vocabPrior=args.vocabPrior, dtype=output_dtype)
elif args.model == LdaCvbZero:
import model.lda_cvb as mdl
templateModel = mdl.newModelAtRandom(data, K, dtype=output_dtype)
elif args.model == LdaVb:
import model.lda_vb_python as mdl
templateModel = mdl.newModelAtRandom(data, K, args.vocabPrior, dtype=output_dtype)
elif args.model == LdaGibbs:
import model.lda_gibbs as mdl
templateModel = mdl.newModelAtRandom(data, K, dtype=output_dtype)
elif args.model == Rtm:
import model.rtm as mdl
templateModel = mdl.newModelAtRandom(data, K, dtype=output_dtype)
elif args.model == Mtm:
import model.mtm2 as mdl
templateModel = mdl.newModelAtRandom(data, K, dtype=output_dtype)
elif args.model == Mtm2:
import model.mtm3 as mdl
templateModel = mdl.newModelAtRandom(data, K, dtype=output_dtype)
elif args.model == Dmr:
import model.dmr as mdl
templateModel = mdl.newModelAtRandom(data, K, dtype=output_dtype)
elif args.model == Lro:
import model.lro_vb as mdl
templateModel = mdl.newModelAtRandom(data, K, dtype=output_dtype)
elif args.model == SimLda:
import model.sim_based_rec as mdl
templateModel = mdl.newModelAtRandom(data, K, method=mdl.LDA, dtype=output_dtype)
elif args.model == SimTfIdf:
import model.sim_based_rec as mdl
templateModel = mdl.newModelAtRandom(data, K, method=mdl.TF_IDF, dtype=output_dtype)
else:
raise ValueError ("Unknown model identifier " + args.model)
print("Done")
trainPlan = mdl.newTrainPlan(args.iters, debug=args.debug)
queryPlan = mdl.newTrainPlan(args.query_iters, debug=args.debug)
if args.eval == Perplexity:
return cross_val_and_eval_perplexity(data, mdl, templateModel, trainPlan, queryPlan, args.folds, args.eval_fold_count, args.out_model)
elif args.eval == HashtagPrecAtM:
return cross_val_and_eval_hashtag_prec_at_m(data, mdl, templateModel, trainPlan, load_dict(args.word_dict), args.folds, args.eval_fold_count, args.out_model)
elif args.eval == MeanAveragePrecAllDocs:
return link_split_map (data, mdl, templateModel, trainPlan, args.folds, args.out_model)
elif args.eval == MeanPrecRecAtMAllDocs:
return link_split_prec_rec (data, mdl, templateModel, trainPlan, args.folds, args.eval_fold_count, args.out_model, ldaModel, ldaTopics)
elif args.eval == LroMeanPrecRecAtMAllDocs:
return insample_lro_style_prec_rec (data, mdl, templateModel, trainPlan, args.folds, args.eval_fold_count, args.out_model, ldaModel, ldaTopics)
elif args.eval == LroMeanPrecRecAtMFeatSplit:
return outsample_lro_style_prec_rec (data, mdl, templateModel, trainPlan, features_mask, args.out_model, ldaModel, ldaTopics)
else:
raise ValueError("Unknown evaluation metric " + args.eval)
return modelFiles