15 ublas::matrix<double> X =
t(data.
collapse());
17 cout <<
"Starting QDA Training\n"
18 <<
"X = matrix[" << X.size1() <<
"," << X.size2() <<
"]\n";
23 int nClasses = classes.size();
24 int nSamples =
nrow(X);
25 int nFeatures =
ncol(X);
26 covariances.resize(nClasses);
27 covariancesInv.resize(nClasses);
28 for (
int k = 0; k < nClasses; k++) {
30 this->inturruptionPoint();
37 priors =
rep(0, nClasses);
41 cout <<
"Classes: " << classes << endl << flush;
43 for(
int k=0; k< nClasses; k++) {
45 this->inturruptionPoint();
49 std::vector<bool> mask =
createMask(classes[k], Y);
50 ublas::matrix<double> Z(
count(k,classes), nFeatures);
54 int nSamplesThisClass =
nrow(Z);
57 priors[k] = double(nSamplesThisClass) / nSamples;
63 matrix<double> temp =
createMatrix(ublas::vector<double>(row(means,k)),
64 nSamplesThisClass, nFeatures,
true);
65 matrix<double> Zc = Z - temp;
68 this->inturruptionPoint();
70 covariances[k] = prod(
t(Zc), Zc) / nSamplesThisClass;
71 covariancesInv[k] =
solve(covariances[k]);
72 covariancesDet[k] =
det(covariances[k]);
85 ublas::vector<int> QDA::use(
const ublas::matrix<double> & data)
89 cerr <<
"QDA use error: 0 size data matrix given.\n";
90 ublas::vector<int> ret;
94 ublas::matrix<double> X = data;
98 int nClasses = classes.size();
99 int nSamples =
nrow(X);
100 int nFeatures =
ncol(X);
102 ublas::matrix<double> disc_functions(nSamples,nClasses);
105 for(
int k=0; k< nClasses; k++)
107 matrix<double> temp =
createMatrix(ublas::vector<double>(row(means,k)),
108 nSamples, nFeatures,
true);
109 ublas::matrix<double> Xc = X - temp;
110 double scalarpart = -0.5 * log(covariancesDet[k]) + log(priors[k]);
111 ublas::matrix<double> a = prod( Xc,covariancesInv[k]);
112 ublas::matrix<double> sa =
compProd(a,Xc);
113 ublas::vector<double> vectorpart = -0.5 *
rowSums(sa);
114 for(
unsigned int vi=0; vi<vectorpart.size(); vi++)
115 disc_functions(vi,k) = vectorpart[vi] + scalarpart;
119 ublas::vector<int> predicted_classes;
120 predicted_classes.resize(nSamples);
122 for(
int j=0; j<
nrow(disc_functions); j++)
124 ublas::vector<double> disc_functionsRow = row(disc_functions,j);
125 predicted_classes[j] = classes[
whichMax(disc_functionsRow)];
133 ublas::vector<double> max_disc =
134 cppR::rowApply<double>(disc_functions,&cppR::max<double>);
138 matrix<double> max_discs =
139 createMatrix(max_disc,disc_functions.size1(),disc_functions.size2());
142 matrix<double> probabilities =
143 apply(matrix<double>(disc_functions - max_discs), exp);
149 matrix<double> sum_p_rep =
150 createMatrix(sum_p,probabilities.size1(),probabilities.size2());
151 probabilities =
compDiv(probabilities, sum_p_rep);
154 this->probabilities.resize(probabilities.size1());
155 for(
unsigned i=0;i<probabilities.size1();i++)
156 this->probabilities[i] =
157 asStdVector(ublas::vector<double>(row(probabilities,i)));
163 return predicted_classes;
171 map<string, SerializedObject> ret;
175 ret[
"covariances"] =
serialize(covariances);
176 ret[
"covariancesInv"] =
serialize(covariancesInv);
177 ret[
"covariancesDet"] =
serialize(covariancesDet);
183 void QDA::load(map<string, SerializedObject> objects)
189 deserialize(objects[
"covariancesInv"],covariancesInv);
190 deserialize(objects[
"covariancesDet"],covariancesDet);
197 std::map<std::string, CEBL::Param> QDA::getParamsList()
199 std::map<std::string, CEBL::Param> params;
201 "Should QDA compute probabilities when you use the classifier?",
203 params[
"probs"] = probs;
209 void QDA::setParamsList( std::map<std::string, CEBL::Param> &p)
211 compute_probs = bool((*(p.begin())).getBool());