1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
#ifndef _CCRP_H_
#define _CCRP_H_
#include <cassert>
#include <cmath>
#include <list>
#include <iostream>
#include <vector>
#include <tr1/unordered_map>
#include <boost/functional/hash.hpp>
#include "sampler.h"
// Chinese restaurant process (Pitman-Yor parameters) with explicit table
// tracking.
template <typename Dish, typename DishHash = boost::hash<Dish> >
class CCRP {
public:
CCRP(double disc, double conc) : num_tables_(), num_customers_(), discount_(disc), concentration_(conc) {}
unsigned num_tables(const Dish& dish) const {
const typename std::tr1::unordered_map<Dish, DishLocations, DishHash>::const_iterator it = dish_locs_.find(dish);
if (it == dish_locs_.end()) return 0;
return it->second.table_counts_.size();
}
int increment(const Dish& dish, const double& p0, MT19937* rng) {
DishLocations& loc = dish_locs_[dish];
bool share_table = false;
if (loc.total_dish_count_) {
const double p_empty = (concentration_ + num_tables_ * discount_) * p0;
const double p_share = (loc.total_dish_count_ - loc.table_counts_.size() * discount_);
share_table = rng->SelectSample(p_empty, p_share);
}
if (share_table) {
double r = rng->next() * (loc.total_dish_count_ - loc.table_counts_.size() * discount_);
for (typename std::list<unsigned>::iterator ti = loc.table_counts_.begin();
ti != loc.table_counts_.end(); ++ti) {
r -= (*ti - discount_);
if (r <= 0.0) {
++(*ti);
break;
}
}
if (r > 0.0) {
std::cerr << "Serious error: r=" << r << std::endl;
Print(&std::cerr);
assert(r <= 0.0);
}
} else {
loc.table_counts_.push_back(1u);
++num_tables_;
}
++loc.total_dish_count_;
++num_customers_;
return (share_table ? 0 : 1);
}
int decrement(const Dish& dish, MT19937* rng) {
DishLocations& loc = dish_locs_[dish];
assert(loc.total_dish_count_);
if (loc.total_dish_count_ == 1) {
dish_locs_.erase(dish);
--num_tables_;
--num_customers_;
return -1;
} else {
int delta = 0;
double r = rng->next() * (loc.total_dish_count_ - loc.table_counts_.size() * discount_);
--loc.total_dish_count_;
for (typename std::list<unsigned>::iterator ti = loc.table_counts_.begin();
ti != loc.table_counts_.end(); ++ti) {
r -= (*ti - discount_);
if (r <= 0.0) {
if ((--(*ti)) == 0) {
--num_tables_;
delta = -1;
loc.table_counts_.erase(ti);
}
break;
}
}
if (r > 0.0) {
std::cerr << "Serious error: r=" << r << std::endl;
Print(&std::cerr);
assert(r <= 0.0);
}
--num_customers_;
return delta;
}
}
double prob(const Dish& dish, const double& p0) const {
const typename std::tr1::unordered_map<Dish, DishLocations, DishHash>::const_iterator it = dish_locs_.find(dish);
const double r = num_tables_ * discount_ + concentration_;
if (it == dish_locs_.end()) {
return r * p0 / (num_customers_ + concentration_);
} else {
return (it->second.total_dish_count_ - discount_ * it->second.table_counts_.size() + r * p0) /
(num_customers_ + concentration_);
}
}
// taken from http://en.wikipedia.org/wiki/Chinese_restaurant_process
// does not include P_0's
double log_crp_prob() const {
double lp = 0.0;
if (num_customers_) {
const double r = lgamma(1.0 - discount_);
lp = lgamma(concentration_) - lgamma(concentration_ + num_customers_) + num_tables_ * discount_ + lgamma(concentration_ / discount_ + num_tables_) - lgamma(concentration_ / discount_);
for (typename std::tr1::unordered_map<Dish, DishLocations, DishHash>::const_iterator it = dish_locs_.begin();
it != dish_locs_.end(); ++it) {
const DishLocations& cur = it->second;
lp += lgamma(cur.total_dish_count_ - discount_) - r;
}
}
return lp;
}
struct DishLocations {
DishLocations() : total_dish_count_() {}
unsigned total_dish_count_;
std::list<unsigned> table_counts_; // list<> gives O(1) deletion and insertion, which we want
};
void Print(std::ostream* out) const {
for (typename std::tr1::unordered_map<Dish, DishLocations, DishHash>::const_iterator it = dish_locs_.begin();
it != dish_locs_.end(); ++it) {
(*out) << it->first << " (" << it->second.total_dish_count_ << " on " << it->second.table_counts_.size() << " tables): ";
for (typename std::list<unsigned>::const_iterator i = it->second.table_counts_.begin();
i != it->second.table_counts_.end(); ++i) {
(*out) << " " << *i;
}
(*out) << std::endl;
}
}
typedef typename std::tr1::unordered_map<Dish, DishLocations, DishHash>::const_iterator const_iterator;
const_iterator begin() const {
return dish_locs_.begin();
}
const_iterator end() const {
return dish_locs_.end();
}
unsigned num_tables_;
unsigned num_customers_;
std::tr1::unordered_map<Dish, DishLocations, DishHash> dish_locs_;
double discount_;
double concentration_;
};
template <typename T,typename H>
std::ostream& operator<<(std::ostream& o, const CCRP<T,H>& c) {
c.Print(&o);
return o;
}
#endif
|
