def main():
Settings.new(
linear_solver_partial_time_limit=None,
non_linear_solver_partial_time_limit=None,
solver_total_time_limit=20000,
)
products = [i for i in range(11)]
ground_truth = MarkovChainModel.simple_random(products=products)
offersets = OfferedProductsGenerator(products).generate(TRANSACTIONS)
transactions = TransactionGenerator(ground_truth).generate_for(offersets)
initial_solution = MarkovChainModel.simple_deterministic(products)
estimator_max = MaximumLikelihoodEstimator()
estimation_max = estimator_max.estimate(initial_solution, transactions)
initial_solution = MarkovChainModel.simple_deterministic(products)
estimator_em = MarkovChainExpectationMaximizationEstimator()
estimation_em = estimator_em.estimate(initial_solution, transactions)
initial_solution = MarkovChainRank2Model.simple_deterministic(products)
estimator_mkv2 = MaximumLikelihoodEstimator()
estimation_mkv2 = estimator_mkv2.estimate(initial_solution, transactions)
plot(ground_truth, estimator_max, estimator_em, estimator_mkv2,
estimation_max, estimation_em, estimation_mkv2, transactions)
def main():
Settings.new(
linear_solver_partial_time_limit=None,
non_linear_solver_partial_time_limit=None,
solver_total_time_limit=1800,
)
products = [i for i in range(11)]
number_lists = 10
lists = [
list(np.random.permutation(len(products))) for _ in range(number_lists)
]
ground_truth = RankedListModel.simple_random(products=products,
ranked_lists=lists)
offersets = OfferedProductsGenerator(products).generate(TRANSACTIONS)
transactions = TransactionGenerator(ground_truth).generate_for(offersets)
initial_solution = LatentClassModel.simple_deterministic(products, 10)
estimator_max = MaximumLikelihoodEstimator()
estimation_max = estimator_max.estimate(initial_solution, transactions)
initial_solution = LatentClassModel.simple_deterministic(products, 10)
estimator_em = LatentClassExpectationMaximizationEstimator()
estimation_em = estimator_em.estimate(initial_solution, transactions)
initial_solution = LatentClassModel.simple_deterministic(products, 10)
estimator_fw = LatentClassFrankWolfeEstimator()
estimation_fw = estimator_fw.estimate(initial_solution, transactions)
plot(ground_truth, estimation_em, estimation_max, estimation_fw,
estimator_em, estimator_max, estimator_fw, transactions)
def estimate(self, model, transactions):
likelihood_loss_function_coefficients = self.likelihood_loss_function_coefficients(
transactions)
new_likelihood = model.log_likelihood_for(transactions)
max_iterations = len(likelihood_loss_function_coefficients)
cpu_time = time_for_optimization(
partial_time=Settings.instance(
).non_linear_solver_partial_time_limit(),
total_time=Settings.instance().solver_total_time_limit(),
profiler=self.profiler())
start_time = time.time()
for _ in range(max_iterations):
old_likelihood = new_likelihood
possible_mnl_model = self.look_for_new_mnl_model(
model, likelihood_loss_function_coefficients)
model.add_new_class_with(possible_mnl_model)
self.update_weights_for(model,
likelihood_loss_function_coefficients)
new_likelihood = model.log_likelihood_for(transactions)
likelihood_does_not_increase = new_likelihood < old_likelihood
likelihood_does_not_increase_enough = abs(
new_likelihood - old_likelihood) / len(transactions) < 1e-7
time_limit = (time.time() - start_time) > cpu_time
if likelihood_does_not_increase or likelihood_does_not_increase_enough or time_limit:
break
return model
def main():
Settings.new(
linear_solver_partial_time_limit=None,
non_linear_solver_partial_time_limit=None,
solver_total_time_limit=20000,
)
products = [i for i in range(11)]
ground_truth = MixedLogitModel(
products=products,
mus=[p + 1 for p in products],
sigmas=[1 if p % 2 == 0 else 10 for p in products])
offersets = OfferedProductsGenerator(products).generate(TRANSACTIONS)
transactions = TransactionGenerator(ground_truth).generate_for(offersets)
initial_solution = MixedLogitModel.simple_deterministic(products)
estimator_mx = MaximumLikelihoodEstimator()
estimation_mx = estimator_mx.estimate(initial_solution, transactions)
initial_solution = MultinomialLogitModel.simple_deterministic(products)
estimator_mnl = MaximumLikelihoodEstimator()
estimation_mnl = estimator_mnl.estimate(initial_solution, transactions)
plot(ground_truth, estimation_mx, estimator_mx, estimation_mnl,
estimator_mnl, transactions)
def main():
Settings.new(
linear_solver_partial_time_limit=None,
non_linear_solver_partial_time_limit=None,
solver_total_time_limit=20000,
)
nests = [
{'lambda': 0.8, 'products': [0, 1, 2]},
{'lambda': 0.8, 'products': [3, 4, 5]},
{'lambda': 0.8, 'products': [6, 7, 8]},
{'lambda': 0.8, 'products': [9, 10]},
]
products = [i for i in range(11)]
ground_truth = NestedLogitModel(products=products, etas=[0.1 * i for i in range(1, 12)], nests=nests)
offersets = OfferedProductsGenerator(products).generate(TRANSACTIONS)
transactions = TransactionGenerator(ground_truth).generate_for(offersets)
initial_solution = NestedLogitModel.simple_deterministic(products, nests)
estimator_nl = MaximumLikelihoodEstimator()
estimation_nl = estimator_nl.estimate(initial_solution, transactions)
initial_solution = MultinomialLogitModel.simple_deterministic(products)
estimator_mnl = MaximumLikelihoodEstimator()
estimation_mnl = estimator_mnl.estimate(initial_solution, transactions)
plot(ground_truth, estimator_mnl, estimation_mnl, estimator_nl, estimation_nl, transactions)
def main():
Settings.new(
linear_solver_partial_time_limit=300.0,
non_linear_solver_partial_time_limit=300.0,
solver_total_time_limit=1800.0,
)
ground_truth, transactions = read_synthetic_instance(
'instances/100_lists_300_periods_1_instance.json')
products = ground_truth.products
nests = [{
'products': [0],
'lambda': 0.8
}, {
'products': [i for i in range(1, len(products)) if i % 2 == 0],
'lambda': 0.8
}, {
'products': [i for i in range(1, len(products)) if i % 2 == 1],
'lambda': 0.8
}]
lists = [[i] + list(sorted(set(products) - {i}))
for i in range(len(products))]
models_to_run = [
(ExponomialModel.simple_deterministic(products),
MaximumLikelihoodEstimator()),
(MultinomialLogitModel.simple_deterministic(products),
MaximumLikelihoodEstimator()),
(RandomChoiceModel.simple_deterministic(products),
RandomChoiceModelMaximumLikelihoodEstimator()),
(LatentClassModel.simple_deterministic(products, 1),
LatentClassFrankWolfeEstimator()),
(MarkovChainModel.simple_deterministic(products),
MarkovChainExpectationMaximizationEstimator()),
(MarkovChainRank2Model.simple_deterministic(products),
MaximumLikelihoodEstimator()),
(MixedLogitModel.simple_deterministic(products),
MaximumLikelihoodEstimator()),
(NestedLogitModel.simple_deterministic(products, nests=nests),
MaximumLikelihoodEstimator()),
(RankedListModel.simple_deterministic(products, ranked_lists=lists),
RankedListExpectationMaximizationEstimator(MIPMarketExplorer())),
]
results = []
for initial_solution, estimator in models_to_run:
if hasattr(estimator, 'estimate_with_market_discovery'):
model = estimator.estimate_with_market_discovery(
initial_solution, transactions)
else:
model = estimator.estimate(initial_solution, transactions)
soft_rmse = model.soft_rmse_for(ground_truth)
results.append((model, estimator.profiler(), soft_rmse))
plot(results)
def estimate(self, model, transactions):
self.profiler().reset_convergence_criteria()
self.profiler().update_time()
model = self.custom_initial_solution(model, transactions)
cpu_time = time_for_optimization(partial_time=Settings.instance().non_linear_solver_partial_time_limit(),
total_time=Settings.instance().solver_total_time_limit(),
profiler=self.profiler())
start_time = time.time()
while True:
self.profiler().start_iteration()
model = self.one_step(model, transactions)
likelihood = model.log_likelihood_for(transactions)
self.profiler().stop_iteration(likelihood)
if self.profiler().should_stop() or (time.time() - start_time) > cpu_time:
break
return model
def run(estimation_method, model, input_file, output_file):
print(' * Reading input file...')
ground_truth, transactions = read_synthetic_instance(input_file)
products = ground_truth.products
print(' - Amount of transactions: %s' % len(transactions))
print(' - Amount of products: %s' % len(products))
print(' * Retrieving estimation method...')
model_info = estimators[estimation_method]['models'][model]
print(' * Retrieving settings...')
Settings.new(
linear_solver_partial_time_limit=model_info['settings']
['linear_solver_partial_time_limit'],
non_linear_solver_partial_time_limit=model_info['settings']
['non_linear_solver_partial_time_limit'],
solver_total_time_limit=model_info['settings']
['solver_total_time_limit'],
)
print(' * Creating initial solution...')
model = model_info['model_class'](products)
print(' * Starting estimation...')
if hasattr(model_info['estimator'], 'estimate_with_market_discovery'):
result = model_info['estimator'].estimate_with_market_discovery(
model, transactions)
else:
result = model_info['estimator'].estimate(model, transactions)
rmse = ground_truth.soft_rmse_for(result)
print(' * Computing result...')
print('')
print('Soft RMSE: %s' % rmse)
print('')
result.save(output_file)
return rmse
def main():
Settings.new(
linear_solver_partial_time_limit=None,
non_linear_solver_partial_time_limit=None,
solver_total_time_limit=20000,
)
products = [i for i in range(11)]
ground_truth = MultinomialLogitModel.simple_random(products=products)
offersets = OfferedProductsGenerator(products).generate(TRANSACTIONS)
transactions = TransactionGenerator(ground_truth).generate_for(offersets)
initial_solution = ExponomialModel.simple_deterministic(products)
estimator_exp = MaximumLikelihoodEstimator()
estimation_exp = estimator_exp.estimate(initial_solution, transactions)
initial_solution = MultinomialLogitModel.simple_deterministic(products)
estimator_mnl = MaximumLikelihoodEstimator()
estimation_mnl = estimator_mnl.estimate(initial_solution, transactions)
plot(ground_truth, estimation_exp, estimator_exp, estimation_mnl, estimator_mnl, transactions)
def main():
Settings.new(
linear_solver_partial_time_limit=None,
non_linear_solver_partial_time_limit=None,
solver_total_time_limit=20000,
)
products = [i for i in range(11)]
number_lists = 5
lists = [
list(np.random.permutation(len(products))) for _ in range(number_lists)
]
ground_truth = RankedListModel.simple_random(products=products,
ranked_lists=lists)
offersets = OfferedProductsGenerator(products).generate(TRANSACTIONS)
transactions = TransactionGenerator(ground_truth).generate_for(offersets)
initial_solution = RankedListModel.simple_deterministic(products,
ranked_lists=lists)
estimator_max = RankedListMaximumLikelihoodEstimator()
estimation_max = estimator_max.estimate(initial_solution, transactions)
initial_solution = RankedListModel.simple_deterministic(products,
ranked_lists=lists)
estimator_em = RankedListExpectationMaximizationEstimator()
estimation_em = estimator_em.estimate(initial_solution, transactions)
initial_solution = RankedListModel.simple_deterministic_independent(
products)
estimator_mip = RankedListExpectationMaximizationEstimator.with_this(
MIPMarketExplorer())
estimation_mip = estimator_mip.estimate_with_market_discovery(
initial_solution, transactions)
plot(ground_truth, estimator_max, estimator_em, estimator_mip,
estimation_max, estimation_em, estimation_mip, transactions)
def cpu_time(self, profiler):
return time_for_optimization(
partial_time=Settings.instance().linear_solver_partial_time_limit(
),
total_time=Settings.instance().solver_total_time_limit(),
profiler=profiler)