def rmse_known_ground(self, ground_model, transactions):
rmse = 0.0
amount_terms = 0
for transaction in transactions:
for product in transaction.offered_products:
probability_1 = self.probability_of(
Transaction(product, transaction.offered_products))
probability_2 = ground_model.probability_of(
Transaction(product, transaction.offered_products))
rmse += ((probability_1 - probability_2)**2)
amount_terms += 1
return sqrt(rmse / float(amount_terms))
def read_synthetic_instance(file_name):
with open(file_name, 'r') as f:
data = json.loads(f.read())
ground_truth = Model.from_data(data['ground_model'])
transactions = Transaction.from_json(
data['transactions']['in_sample_transactions'])
return ground_truth, transactions
def soft_chi_squared_score_for(self, ground_model, transactions):
expected_purchases = [0.0 for _ in self.products]
observed_purchases = [0.0 for _ in self.products]
for transaction in transactions:
for product in transaction.offered_products:
observed_purchases[product] += ground_model.probability_of(
Transaction(product, transaction.offered_products))
expected_purchases[product] += self.probability_of(
Transaction(product, transaction.offered_products))
score = 0.0
for p in self.products:
score += (((expected_purchases[p] - observed_purchases[p])**2) /
(expected_purchases[p] + 0.5))
return score / float(len(self.products))
def soft_rmse_for(self, ground_model):
rmse = 0.0
amount_terms = 0.0
for t in Transaction.all_for(self):
rmse += ((self.probability_of(t) -
ground_model.probability_of(t))**2)
amount_terms += 1
return sqrt(rmse / float(amount_terms))
def rmse_for(self, transactions):
rmse = 0.0
amount_terms = 0
for transaction in transactions:
for product in transaction.offered_products:
probability = self.probability_of(
Transaction(product, transaction.offered_products))
rmse += ((probability -
float(product == transaction.product))**2)
amount_terms += 1
return sqrt(rmse / float(amount_terms))
def hit_rate_for(self, transactions):
hit_rate = 0
for transaction in transactions:
probabilities = []
for product in transaction.offered_products:
probabilities.append(
(product,
self.probability_of(
Transaction(product, transaction.offered_products))))
most_probable = max(probabilities, key=lambda p: p[1])[0]
hit_rate += int(most_probable == transaction.product)
return float(hit_rate) / float(len(transactions))
def infinite_in_sample_log_likelihood(self, ground_model):
result = 0
for t in Transaction.all_for(self):
result += (ground_model.probability_of(t) *
self.log_probability_of(t))
return result
def probability_distribution_over(self, offered_products):
distribution = []
for product in range(len(self.products)):
transaction = Transaction(product, offered_products)
distribution.append(self.probability_of(transaction))
return distribution