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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
#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) {}
void clear() {
num_tables_ = 0;
num_customers_ = 0;
dish_locs_.clear();
}
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();
}
unsigned num_customers() const {
return num_customers_;
}
// returns +1 or 0 indicating whether a new table was opened
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);
}
// returns -1 or 0, indicating whether a table was closed
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;
// sample customer to remove UNIFORMLY. that is, do NOT use the discount
// here. if you do, it will introduce (unwanted) bias!
double r = rng->next() * loc.total_dish_count_;
--loc.total_dish_count_;
for (typename std::list<unsigned>::iterator ti = loc.table_counts_.begin();
ti != loc.table_counts_.end(); ++ti) {
r -= *ti;
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_; // customers at all tables with this dish
std::list<unsigned> table_counts_; // list<> gives O(1) deletion and insertion, which we want
// .size() is the number of tables for this dish
};
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
|
