/* Cette fonction revoie vrai si l'objet pixel sur lequel est appelé cette fonction
* est dans le meme ensemble que celui en paramètre
*/
bool Pixel::dans_Meme_Ensemble(Pixel* autre_Pixel){
Pixel* Mon_representant = getEnsemble()->getHead();
Pixel* Son_representant = autre_Pixel->getEnsemble()->getHead();
return Mon_representant == Son_representant;
}
void ConfigurationDefault::updateParameters(const std::vector<Obs>& iObs, int iDate, int iInit, float iOffset, int iPoolId, const std::string& iVariable, int iDateGet, int iDateSet, float iOffsetGet, float iOffsetSet) {
const std::vector<Obs>& useObs = iObs;
int dateFcst = iDate;
float offset = iOffset;
int poolId = iPoolId;
iDate = iDateGet;
bool needEnsemble = getNeedEnsemble();
// Check that we are updating the right forecast
for(int k = 0; k < useObs.size(); k++) {
Obs obs = useObs[k];
assert(Global::getDate(obs.getDate(), obs.getInit(), obs.getOffset()) == Global::getDate(dateFcst, iInit, offset) &&
Global::getTime(obs.getDate(), obs.getInit(), obs.getOffset()) == Global::getTime(dateFcst, iInit, offset));
}
// Selector
if(mSelector->needsTraining()) {
Parameters par;
getParameters(Processor::TypeSelector, iDate, iInit, iOffsetGet, poolId, iVariable, 0, par);
// Create vector date and offsets for selector's update parameters
std::vector<int> fcstDates(iObs.size(), iDate);
std::vector<float> fcstOffsets(iObs.size(), iOffset);
mSelector->updateParameters(fcstDates, iInit, fcstOffsets, useObs, par);
setParameters(Processor::TypeSelector, iDate, iInit, iOffsetSet, poolId, iVariable, 0, par);
}
if(needEnsemble) {
// Correctors
std::vector<Ensemble> ensembles;
for(int n = 0; n < useObs.size(); n++) {
Location obsLocation = useObs[n].getLocation();
// Get the raw ensemble
Ensemble ensemble;
getEnsemble(dateFcst, iInit, offset, obsLocation, iVariable, ensemble, typeUnCorrected);
ensembles.push_back(ensemble);
}
for(int k = 0; k < (int) mCorrectors.size(); k++) {
Parameters parCorrector;
getParameters(Processor::TypeCorrector, iDate, iInit, iOffsetGet, poolId, iVariable, k, parCorrector);
Parameters parOrig = parCorrector;
if(mCorrectors[k]->needsTraining()) {
mCorrectors[k]->updateParameters(ensembles, useObs, parCorrector);
setParameters(Processor::TypeCorrector, iDate, iInit, iOffsetSet, poolId, iVariable, k, parCorrector);
}
// Correct ensemble for next corrector
for(int n = 0; n < ensembles.size(); n++) {
mCorrectors[k]->correct(parOrig, ensembles[n]);
}
}
// Uncertainty
Parameters parUncertainty;
getParameters(Processor::TypeUncertainty, iDate, iInit, iOffsetGet, poolId, iVariable, 0, parUncertainty);
Parameters parAverager;
getParameters(Processor::TypeAverager, iDate, iInit, iOffsetGet, poolId, iVariable, 0, parAverager);
if(mUncertainty->needsTraining()) {
mUncertainty->updateParameters(ensembles, useObs, parUncertainty);
setParameters(Processor::TypeUncertainty, iDate, iInit, iOffsetSet, poolId, iVariable, 0, parUncertainty);
}
// Calibrators
if(mAverager->needsTraining() || mCalibrators.size() > 0 || mUpdaters.size() > 0) {
std::vector<std::vector<Distribution::ptr> > upstreams;
upstreams.resize(1 + mCalibrators.size() + mUpdaters.size());
upstreams[0].resize(useObs.size());
for(int n = 0; n < useObs.size(); n++) {
Distribution::ptr uncD = mUncertainty->getDistribution(ensembles[n], parUncertainty, *mAverager, parAverager);
upstreams[0][n] = uncD;
}
// Start with the uncertainty distributions. Then iteratively calibrate the previous
// distirbution (upstream).
int Iupstream = 0;
for(int k = 0; k < (int) mCalibrators.size(); k++) {
upstreams[Iupstream+1].resize(useObs.size());
Parameters parCalibrator;
getParameters(Processor::TypeCalibrator, iDate, iInit, iOffsetGet, poolId, iVariable, k, parCalibrator);
if(mCalibrators[k]->needsTraining()) {
mCalibrators[k]->updateParameters(upstreams[Iupstream], useObs, parCalibrator);
setParameters(Processor::TypeCalibrator, iDate, iInit, iOffsetSet, poolId, iVariable, k, parCalibrator);
}
// Calibrate all distributions for the next calibrator
for(int n = 0; n < useObs.size(); n++) {
upstreams[Iupstream+1][n] = mCalibrators[k]->getDistribution(upstreams[Iupstream][n], parCalibrator);
}
Iupstream++;
}
// Updaters
if(mUpdaters.size() > 0) {
assert(mUpdaters.size() <= 1);
std::vector<Distribution::ptr> recentDists(useObs.size());
std::vector<Obs> recentObs;
for(int n = 0; n < useObs.size(); n++) {
Distribution::ptr recentDist = getDistribution(dateFcst, iInit, 0, useObs[n].getLocation(), iVariable, typeUnUpdated);
recentDists[n] = recentDist;
// Get the recent most observation
Obs obs;
mData.getObs(dateFcst, iInit, 0, useObs[n].getLocation(), iVariable, obs);
recentObs.push_back(obs);
}
for(int k = 0; k < mUpdaters.size(); k++) {
upstreams[Iupstream+1].resize(useObs.size());
Parameters par;
getParameters(Processor::TypeUpdater, iDate, iInit, iOffsetGet, poolId, iVariable, k, par);
if(mUpdaters[k]->needsTraining()) {
mUpdaters[k]->updateParameters(upstreams[Iupstream], useObs, recentDists, recentObs, par);
setParameters(Processor::TypeUpdater, iDate, iInit, iOffsetSet, poolId, iVariable, k, par);
}
Iupstream++;
}
}
// Averager
if(mAverager->needsTraining()) {
Parameters parAverager;
getParameters(Processor::TypeAverager, iDate, iInit, iOffsetGet, poolId, iVariable, 0, parAverager);
mAverager->updateParameters(upstreams[upstreams.size()-1], useObs, parAverager);
setParameters(Processor::TypeAverager, iDate, iInit, iOffsetSet, poolId, iVariable, 0, parAverager);
}
}
}
}
Distribution::ptr ConfigurationDefault::getDistribution(int iDate,
int iInit,
float iOffset,
const Location& iLocation,
std::string iVariable,
ProcTypeDist iType) const {
float offsetCode = mPooler->find(iOffset);
Ensemble ens;
getEnsemble(iDate, iInit, iOffset, iLocation, iVariable, ens);
/////////////////
// Uncertainty //
/////////////////
Parameters parUnc;
getParameters(Processor::TypeUncertainty, iDate, iInit, offsetCode, iLocation, iVariable, 0, parUnc);
Parameters parAverager;
getParameters(Processor::TypeAverager, iDate, iInit, offsetCode, iLocation, iVariable, 0, parAverager);
Distribution::ptr uncD = mUncertainty->getDistribution(ens, parUnc, *mAverager, parAverager);
if(mCalibrators.size() == 0 && mUpdaters.size() == 0)
return uncD;
if(iType == typeUnCalibrated)
return uncD;
/////////////////
// Calibration //
/////////////////
std::vector<Distribution::ptr> cal;
cal.push_back(uncD);
// Chain calibrators together
for(int i = 0; i < (int) mCalibrators.size(); i++) {
Parameters parCal;
getParameters(Processor::TypeCalibrator, iDate, iInit, offsetCode, iLocation, iVariable, i, parCal);
cal.push_back(mCalibrators[i]->getDistribution(cal[i], parCal));
}
if(iType == typeUnUpdated)
return cal.back();
//////////////
// Updating //
//////////////
for(int i = 0; i < (int) mUpdaters.size(); i++) {
Parameters par;
Obs recentObs;
mData.getObs(iDate, iInit, 0, iLocation, iVariable, recentObs);
Distribution::ptr recentDist = getDistribution(iDate, iInit, 0, iLocation, iVariable, typeUnUpdated);
getParameters(Processor::TypeUpdater, iDate, iInit, offsetCode, iLocation, iVariable, i, par);
int Iupstream = cal.size()-1;
assert(Iupstream >= 0);
Distribution::ptr dist = mUpdaters[i]->getDistribution(cal[Iupstream], recentObs, recentDist, par);
cal.push_back(dist);
}
return cal.back();
}
void ClassificationTree::optSplitPos(int &nOptFeatureIndex,
float &fOptFeatureVal,
std::vector<int32_t> &vCurrentIndex,
std::vector<int32_t> &vFeatureIndex) {
float minDevia = INT_MAX;
// sample the feature
std::vector<int32_t> vTempFeatureIndex;
if (getEnsemble()) {
srand( (unsigned)time(NULL));
for (int32_t i = 0; i < vFeatureIndex.size(); ++i) {
int32_t t = rand() % vFeatureIndex.size();
std::swap(vFeatureIndex[i], vFeatureIndex[t]);
}
vTempFeatureIndex.assign(vFeatureIndex.begin(), vFeatureIndex.begin() + getRandFeatureCnt());
} else {
vTempFeatureIndex.assign(vFeatureIndex.begin(), vFeatureIndex.end());
}
// gini data
int32_t totLabelCnt = vCurrentIndex.size();
for (int i = 0; i < vTempFeatureIndex.size(); ++i) {
std::set<int32_t> featureValueSet;
std::map<int32_t, int32_t> featureValCnt;
std::vector<int32_t> labelCnt(getLabelCnt(), 0);
std::map<int32_t, std::vector<int32_t> > featureLabelCnt;
for (int j = 0; j < vCurrentIndex.size(); ++j) {
int32_t val = (int32_t)getTrainingX()[vCurrentIndex[j]][vTempFeatureIndex[i]];
int32_t label = (int32_t)getTrainingY()[vCurrentIndex[j]];
featureValueSet.insert(val);
if (featureValCnt.find(val) == featureValCnt.end()) {
featureValCnt[val] = 1;
std::vector<int32_t> t(getLabelCnt(), 0);
featureLabelCnt[val] = t;
featureLabelCnt[val][label] += 1;
} else {
featureValCnt[val] += 1;
featureLabelCnt[val][label] += 1;
}
labelCnt[label] += 1;
}
for (std::set<int32_t>::iterator it = featureValueSet.begin(); it != featureValueSet.end(); ++it) {
int32_t val = *it;
int cnt = featureValCnt[val];
std::vector<int32_t> labelNum = featureLabelCnt[val];
float gini = 0.0;
float rTot = 0.0;
float lTot = 0.0;
for (int32_t k = 0; k < getLabelCnt(); ++k) {
lTot += labelNum[k] * labelNum[k] * 1.0 / (cnt * cnt);
rTot += (labelCnt[k] - labelNum[k]) * (labelCnt[k] - labelNum[k]) * 1.0 /
((totLabelCnt - cnt) * (totLabelCnt - cnt));
}
gini = (1 - lTot) * cnt * 1.0 + (1 - rTot) * (totLabelCnt - cnt) * 1.0;
gini = gini / totLabelCnt;
if (gini < minDevia) {
gini = minDevia;
fOptFeatureVal = val;
nOptFeatureIndex = vTempFeatureIndex[i];
}
}
}
}
Pixel* Pixel:: getHead() {
return getEnsemble()->getHead();
}//Recuperer le representant dun ensemble, findSet
