39 for (
int d = 0;d <
D;d++) {
double tmp = x[d] - y[d]; acc += tmp * tmp; }
46 for (
int k = 0;k <
K;k++)
c_count[k] = 0;
48 for (
int n = 0;n <
N;n++) {
54 for (
int k = 1;k <
K;k++) {
56 if (tmp_dist < min_dist) { min_dist = tmp_dist; k_winner = k; }
68 for (
int k = 0;k <
K;k++) {
70 for (
int d = 0;d <
D;d++) c_tmpvec[d] = 0.0;
74 for (
int n = 0;n < Nk;n++) {
76 for (
int d = 0;d <
D;d++) c_tmpvec[d] += x[d];
81 for (
int d = 0;d <
D;d++) c_mean[d] = c_tmpvec[d] / Nk;
91 static int counter = 0;
93 bool zombie_mean =
false;
96 int max_count =
count[k];
99 for (
int k = 1;k < K;k++) if (c_count[k] > max_count) { max_count =
c_count[k]; k_hog = k; }
101 for (
int k = 0;k <
K;k++) {
106 it_warning(
"MOG_diag_kmeans_sup::dezombify_means(): detected zombie mean");
109 it_warning(
"MOG_diag_kmeans_sup::dezombify_means(): weirdness: k_hog == k");
113 if (counter >=
c_count[k_hog]) counter = 0;
118 for (
int d = 0;d <
D;d++) c_mean[d] = 0.5 * (
c_means[k_hog][d] + c_x[d]);
133 double tmp_dist = 0.0;
142 for (
int d = 0;d <
D;d++) c_tmpvec[d] = 0.0;
144 for (
int n = 0;n <
N;n++) {
145 double * c_x =
c_X[n];
146 for (
int d = 0;d <
D;d++) c_tmpvec[d] += c_x[d];
149 for (
int d = 0;d <
D;d++) c_tmpvec[d] /= N;
151 int step = int(
floor(
double(N) /
double(
K)));
152 for (
int k = 0;k <
K;k++) {
154 double * c_x =
c_X[k*step];
156 for (
int d = 0;d <
D;d++) c_mean[d] = 0.5 * (c_tmpvec[d] + c_x[d]);
174 if (
verbose) std::cout <<
"MOG_diag_kmeans_sup::iterate(): iteration = " << i <<
" change = " << change << std::endl;
175 if (change == 0)
break;
193 for (
int k = 0;k <
K;k++) {
199 for (
int d = 0;d <
D;d++) c_tmpvec[d] = 0.0;
201 for (
int n = 0;n < Nk;n++) {
203 for (
int d = 0;d <
D;d++) {
double tmp = c_x[d] - c_mean[d]; c_tmpvec[d] += tmp * tmp; }
225 for (
int d = 0;d <
D;d++) {
227 for (
int n = 0;n <
N;n++) acc +=
c_X[n][d];
228 c_norm_mu[d] = acc /
N;
231 for (
int d = 0;d <
D;d++) {
233 for (
int n = 0;n <
N;n++) {
double tmp =
c_X[n][d] - c_norm_mu[d]; acc += tmp * tmp; }
237 for (
int n = 0;n <
N;n++)
for (
int d = 0;d <
D;d++) {
238 c_X[n][d] -= c_norm_mu[d];
239 if (c_norm_sd[d] > 0.0)
c_X[n][d] /= c_norm_sd[d];
247 for (
int n = 0;n <
N;n++)
for (
int d = 0;d <
D;d++) {
248 if (c_norm_sd[d] > 0.0)
c_X[n][d] *= c_norm_sd[d];
249 c_X[n][d] += c_norm_mu[d];
257 for (
int k = 0;k <
K;k++)
for (
int d = 0;d <
D;d++) {
258 if (norm_sd[d] > 0.0)
c_means[k][d] *= c_norm_sd[d];
267 it_assert(model_in.
is_valid(),
"MOG_diag_kmeans_sup::run(): given model is not valid");
268 it_assert((max_iter_in > 0),
"MOG_diag_kmeans_sup::run(): 'max_iter' needs to be greater than zero");
269 it_assert(((trust_in >= 0.0) && (trust_in <= 1.0)),
"MOG_diag_kmeans_sup::run(): 'trust' must be between 0 and 1 (inclusive)");
277 init(means_in, diag_covs_in, weights_in);
281 weights_in.set_size(0);
283 it_assert(
check_size(X_in),
"MOG_diag_kmeans_sup::run(): 'X' is empty or contains vectors of wrong dimensionality");
288 it_warning(
"MOG_diag_kmeans_sup::run(): K > N");
292 it_warning(
"MOG_diag_kmeans_sup::run(): K > N/10");
350 km.
run(model_in, X_in, max_iter_in, trust_in, normalise_in, verbose_in);
double measure_change() const
ADD DOCUMENTATION HERE.
ivec count
keeps a count of the number of vectors assigned to each mean
int size() const
Returns the number of data elements in the array object.
support class for MOG_diag_kmeans()
bool verbose
Whether we print the progress.
double trust
trust factor, where 0 <= trust <= 1.
Array< vec > get_means() const
Obtain a copy of the array of mean vectors.
Array< vec > get_diag_covs() const
Obtain a copy of the array of diagonal covariance vectors.
K-means based optimiser for Mixture of Gaussians - header file.
int * c_count
'C' pointer to the count vector
vec floor(const vec &x)
Round to nearest lower integer.
bool dezombify_means()
ADD DOCUMENTATION HERE.
double ** c_diag_covs
pointers to the covariance vectors
int N
number of training vectors
bool is_valid() const
Returns true if the model's parameters are valid.
#define it_assert(t, s)
Abort if t is not true.
double ** c_means_old
'C' pointers to old means
void calc_means()
ADD DOCUMENTATION HERE.
void set_size(int n, bool copy=false)
Resizing an Array<T>.
int max_iter
Maximum number of iterations.
double ** c_means
pointers to the mean vectors
void unnormalise_vectors()
ADD DOCUMENTATION HERE.
bool check_size(const vec &x_in) const
Check if vector x_in has the same dimensionality as the model.
void initial_means()
ADD DOCUMENTATION HERE.
Diagonal Mixture of Gaussians (MOG) class.
void recalculate_means()
ADD DOCUMENTATION HERE.
void assign_to_means()
ADD DOCUMENTATION HERE.
double ** disable_c_access(double **A_in)
Disable C style access to an Array of vectors (vec)
Array< vec > means_old
means from the previous iteration, used to measure progress
void cleanup()
Release memory used by the model. The model will be empty.
double ** enable_c_access(Array< vec > &A_in)
Enable C style access to an Array of vectors (vec)
Array< ivec > partitions
contains indices of vectors assigned to each mean
void init()
Initialise the model to be empty.
#define it_warning(s)
Display a warning message.
vec get_weights() const
Obtain a copy of the weight vector.
void calc_weights()
ADD DOCUMENTATION HERE.
vec sqrt(const vec &x)
Square root of the elements.
Array< vec > diag_covs
diagonal covariance matrices, stored as vectors
double dist(const double *x, const double *y) const
ADD DOCUMENTATION HERE.
double ** c_X
'C' pointers to training vectors
double * c_weights
pointer to the weight vector
void run(MOG_diag &model_in, Array< vec > &X_in, int max_iter_in=10, double trust_in=0.5, bool normalise_in=true, bool verbose_in=false)
ADD DOCUMENTATION HERE.
void normalise_vectors()
ADD DOCUMENTATION HERE.
int ** c_partitions
'C' pointers to partition vectors
void iterate()
ADD DOCUMENTATION HERE.
void MOG_diag_kmeans(MOG_diag &model_in, Array< vec > &X_in, int max_iter_in, double trust_in, bool normalise_in, bool verbose_in)
void unnormalise_means()
ADD DOCUMENTATION HERE.
void calc_covs()
ADD DOCUMENTATION HERE.