void SparseVlatCluster::setEigenDecomposition(const float* eigenVectors , const float* eigenValues, size_t vectorsDim, size_t vectorsSize){
if (vectorsDim != vectorsSize)
retinThrowException("Not square matrix");
if (vectorsDim != getTensorDim(1))
retinThrowException2("Invalid dim %d != %d", vectorsDim, getTensorDim(1));
U.resize(vectorsDim*vectorsDim);
L.resize(vectorsDim);
memcpy(&U[0], eigenVectors, vectorsDim*vectorsDim * sizeof(float));
memcpy(&L[0], eigenValues, vectorsDim * sizeof(float));
}
void KPCA::compPrimalAdd(const float* feature,size_t featureDim_,size_t firstEigen_,size_t eigenCount_)
{
if (featureDim == 0)
compPrimalBegin(featureDim_,firstEigen_,eigenCount_);
if (featureDim != featureDim_)
retinThrowException2("Bad featureDim %d != %d",featureDim_,featureDim);
if (firstEigen != firstEigen_)
retinThrowException2("Bad firstEigen %d != %d",firstEigen_,firstEigen);
if (eigenCount != eigenCount_)
retinThrowException2("Bad eigenCount %d != %d",eigenCount_,eigenCount);
if (featureCount > dim)
retinThrowException1("Wrong number of features (%ld expected)",dim);
vector_add_float(&primalMean[0],feature,featureDim_);
for (size_t j=0;j<eigenCount;j++) {
double eig = 1.0 / sqrt(eigens[firstEigen+j].getValue());
const double* eigv = eigens[firstEigen+j].getVector();
vector_addm_float(&primalVectors[j*featureDim],eigv[featureCount] * eig,feature,featureDim);
}
featureCount ++;
}
void KPCA::compPrimal(const float* features,size_t featureDim_,size_t featureCount_)
{
if (featureCount_ != dim)
retinThrowException2("Bad featureCount %d != %d",featureCount_,dim);
compPrimalBegin(featureDim_,0,eigens.size());
for (size_t i=0;i<featureCount_;i++) {
compPrimalAdd(features+i*featureDim_,featureDim_,0,eigens.size());
}
compPrimalEnd();
/*size_t p = eigens.size();
vector<double> ls(p);
vector<const double*> vs(p);
for (size_t j=0;j<eigens.size();j++) {
ls[j] = 1.0 / sqrt(eigens[j].getValue());
vs[j] = eigens[j].getVector();
values[j] = eigens[j].getValue() / dim;
}
for (size_t k=0;k<dim;k++) {
for (size_t i=0;i<featureDim;i++) {
double x = features[i+k*featureDim];
for (size_t j=0;j<p;j++) {
temp[i+j*featureDim] += x * vs[j][k] * ls[j];
}
}
}
for (size_t i=0;i<temp.size();i++)
vectors[i] = (float)temp[i];*/
/*for (size_t j=0;j<eigens.size();j++) {
double l = 1.0 / sqrt(eigens[j].getValue());
const double* v = eigens[j].getVector();
values[j] = eigens[j].getValue() / dim;
for (size_t i=0;i<featureDim;i++) {
double w = 0;
for (size_t k=0;k<dim;k++) {
w += features[i+k*featureDim] * v[k] * l;
}
vectors[i+j*featureDim] = w;
}
}*/
}
void PackedVlatCluster::add(const float* feature,size_t dim)
{
size_t meanDim = getTensorDim(1);
if (dim != meanDim)
retinThrowException2("Invalid feature dim %d != %d",dim,meanDim);
vector<double> temp(meanDim);
const float* mean = getMeanTensor(1);
if (mean) {
for (size_t i=0;i<dim;i++)
temp[i] = feature[i] - mean[i];
}
else {
for (size_t i=0;i<dim;i++)
temp[i] = feature[i];
}
pca.add(&temp[0],dim);
}
void SparseVlatCluster::add(const float* feature, size_t featureDim){
size_t meanDim = getTensorDim(1);
if (featureDim != meanDim)
retinThrowException2("Invalid feature dim %d != %d", featureDim, meanDim);
vector<float> featureCentred(meanDim);
const float* mean = getMeanTensor(1);
if (mean)
vector_linear_float(&featureCentred[0], feature, -1, mean, meanDim);
else
memcpy(&featureCentred[0],feature,meanDim*sizeof(float));
vector<float> featureDual(meanDim);
matrix_CpAtB_float(&featureDual[0], &U[0], &featureCentred[0], meanDim, meanDim, 1);
if(mainOrder == 1 || sparsityOn == SparseVlatCluster::sparsityOnDiag){
for(size_t i = 0 ; i < meanDim ; i++)
varDual[i] += featureDual[i]*featureDual[i];
}
else if(sparsityOn == SparseVlatCluster::sparsityOnFull){
vector<float> temp(meanDim*meanDim);
matrix_Cpaat_float(&temp[0], &featureDual[0], meanDim);
for(size_t i = 0 ; i < meanDim*meanDim ; i++)
temp[i] *= temp[i];
vector_add_float (&varDual[0], &featureDual[0], meanDim*meanDim);
}
vector<pair<size_t, float> > sortTable;
if (mainOrder == 1) {
if(sparsityOn == sparsityMaxValues){
sortTable.resize(meanDim);
for(size_t i = 0 ; i < meanDim ; i++){
sortTable[i].first = i;
sortTable[i].second = featureDual[i];
}
sort(sortTable.begin(), sortTable.end(), myfunction);
for(size_t i = sparsityDim ; i < meanDim ; i++){
featureDual[sortTable[i].first] = 0;
}
}
vector_add_float (&vlat[0], &featureDual[0], meanDim);
}
else if (mainOrder == 2) {
if(sparsityOn == sparsityMaxValues){
vector<float> temp(meanDim*meanDim);
memset(&temp[0],0,meanDim*meanDim*sizeof(float));
matrix_Cpaat_float(&temp[0], &featureDual[0], meanDim);
sortTable.resize(meanDim*meanDim);
for(size_t i = 0 ; i < meanDim*meanDim ; i++){
sortTable[i].first = i;
sortTable[i].second = temp[i];
}
sort(sortTable.begin(), sortTable.end(), myfunction);
for(size_t i = sparsityDim ; i < meanDim*meanDim ; i++){
temp[sortTable[i].first] = 0;
}
vector_add_float (&vlat[0], &temp[0], meanDim*meanDim);
}
else
matrix_Cpaat_float(&vlat[0], &featureDual[0], meanDim);
}
counter++;
}
PackedVlat* PackedVlatBuilder::createPackedVlat(double mse)
{
size_t featureDim = 0;
// Calcule les valeurs propres
for (size_t c=0;c<clusters.size();c++) {
size_t dim = clusters[c].getTensorDim(1);
if (featureDim == 0)
featureDim = dim;
else if (featureDim != dim)
retinThrowException2("Different clusters dim %d != %d",dim,featureDim);
PCA& pca = clusters[c].pca;
pca.computeEigens();
}
// Range toutes les valeurs propres
double norm2 = 0;
vector< pair<size_t,float> > order;
for (size_t c=0;c<clusters.size();c++) {
const std::vector<PCA::Eigen>& eigens = clusters[c].pca.getEigens();
for (size_t e=0;e<eigens.size();e++) {
double x = eigens[e].getValue();
order.push_back(make_pair(e+c*featureDim,x*x));
norm2 += x*x;
}
}
vsort_inc(order);
norm2 = sqrt(norm2);
// Retire des vecteurs tant qu'on ne commet pas trop d'erreurs
size_t featureCount = order.size();
size_t bagCount = clusters.size();
double error = 0;
vector<bool> selected(featureDim*bagCount,true);
for (size_t i=0;i<order.size();i++) {
if (sqrt((error+order[i].second)) > mse*norm2)
break;
error += order[i].second;
selected[order[i].first] = false;
featureCount --;
}
// Forme le VLAT packé
PackedVlat* pvlat = new PackedVlat(featureDim,featureCount,bagCount);
size_t count = 0;
for (size_t c=0;c<clusters.size();c++) {
PCA& pca = clusters[c].pca;
const std::vector<PCA::Eigen>& eigens = pca.getEigens();
pvlat->setBagInitialSize(c,pca.getCount());
size_t bagSize = 0;
for (size_t e=0;e<eigens.size();e++) {
if (selected[e+c*featureDim]) {
if (count >= featureCount)
retinThrowException2("Oo %d != %d",count,featureCount);
float* data = pvlat->feature(count++);
for (size_t i=0;i<featureDim;i++) {
data[i] = (float) (sqrt(eigens[e].getValue())*eigens[e].getVector()[i]);
}
bagSize ++;
}
}
pvlat->setBagSize(c,bagSize);
}
//matrix_print (cout,pvlat->data(),featureDim,featureCount);
return pvlat;
}
