PClassifier TTreeSplitConstructor_Attribute::operator()(
PStringList &descriptions, PDiscDistribution &subsetSizes, float &quality, int &spentAttribute,
PExampleGenerator gen, const int &weightID,
PDomainContingency dcont, PDistribution apriorClass,
const vector<bool> &candidates,
PClassifier nodeClassifier
)
{ checkProperty(measure);
measure->checkClassTypeExc(gen->domain->classVar->varType);
bool cse = candidates.size()==0;
vector<bool>::const_iterator ci(candidates.begin()), ce(candidates.end());
if (!cse) {
if (noCandidates(candidates))
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
ci = candidates.begin();
}
int N = gen ? gen->numberOfExamples() : -1;
if (N<0)
N = dcont->classes->cases;
TSimpleRandomGenerator rgen(N);
int thisAttr = 0, bestAttr = -1, wins = 0;
quality = 0.0;
if (measure->needs == TMeasureAttribute::Contingency_Class) {
vector<bool> myCandidates;
if (cse) {
myCandidates.reserve(gen->domain->attributes->size());
PITERATE(TVarList, vi, gen->domain->attributes)
myCandidates.push_back((*vi)->varType == TValue::INTVAR);
}
else {
myCandidates.reserve(candidates.size());
TVarList::const_iterator vi(gen->domain->attributes->begin());
for(; ci != ce; ci++, vi++)
myCandidates.push_back(*ci && ((*vi)->varType == TValue::INTVAR));
}
if (!dcont || dcont->classIsOuter)
dcont = PDomainContingency(mlnew TDomainContingency(gen, weightID, myCandidates));
ci = myCandidates.begin();
ce = myCandidates.end();
TDomainContingency::iterator dci(dcont->begin()), dce(dcont->end());
for(; (ci != ce) && (dci!=dce); dci++, ci++, thisAttr++)
if (*ci && checkDistribution((const TDiscDistribution &)((*dci)->outerDistribution.getReference()), minSubset)) {
float thisMeas = measure->call(thisAttr, dcont, apriorClass);
if ( ((!wins || (thisMeas>quality)) && ((wins=1)==1))
|| ((thisMeas==quality) && rgen.randbool(++wins))) {
quality = thisMeas;
subsetSizes = (*dci)->outerDistribution;
bestAttr = thisAttr;
}
}
}
else if (measure->needs == TMeasureAttribute::DomainContingency) {
if (!dcont || dcont->classIsOuter)
dcont = PDomainContingency(mlnew TDomainContingency(gen, weightID));
TDomainContingency::iterator dci(dcont->begin()), dce(dcont->end());
for(; (cse || (ci!=ce)) && (dci!=dce); dci++, thisAttr++)
if ( (cse || *(ci++))
&& ((*dci)->outerVariable->varType==TValue::INTVAR)
&& checkDistribution((const TDiscDistribution &)((*dci)->outerDistribution.getReference()), minSubset)) {
float thisMeas = measure->call(thisAttr, dcont, apriorClass);
if ( ((!wins || (thisMeas>quality)) && ((wins=1)==1))
|| ((thisMeas==quality) && rgen.randbool(++wins))) {
quality = thisMeas;
subsetSizes = (*dci)->outerDistribution;
bestAttr = thisAttr;
}
}
}
else {
TDomainDistributions ddist(gen, weightID);
TDomainDistributions::iterator ddi(ddist.begin()), dde(ddist.end()-1);
for(; (cse || (ci!=ce)) && (ddi!=dde); ddi++, thisAttr++)
if (cse || *(ci++)) {
TDiscDistribution *discdist = (*ddi).AS(TDiscDistribution);
if (discdist && checkDistribution(*discdist, minSubset)) {
float thisMeas = measure->call(thisAttr, gen, apriorClass, weightID);
if ( ((!wins || (thisMeas>quality)) && ((wins=1)==1))
|| ((thisMeas==quality) && rgen.randbool(++wins))) {
quality = thisMeas;
subsetSizes = PDiscDistribution(*ddi); // not discdist - this would be double wrapping!
bestAttr = thisAttr;
}
}
}
}
if (!wins)
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
if (quality<worstAcceptable)
return returnNothing(descriptions, subsetSizes, spentAttribute);
PVariable attribute = gen->domain->attributes->at(bestAttr);
TEnumVariable *evar = attribute.AS(TEnumVariable);
if (evar)
descriptions = mlnew TStringList(evar->values.getReference());
else
descriptions = mlnew TStringList(subsetSizes->size(), "");
spentAttribute = bestAttr;
TClassifierFromVarFD *cfv = mlnew TClassifierFromVarFD(attribute, gen->domain, bestAttr, subsetSizes);
cfv->transformUnknowns = false;
return cfv;
}
void ActorCriticOnPolicyOnStateTest::testNormalDistribution()
{
policyDistribution = new NormalDistribution<double>(random, problem->getContinuousActions(), 0.5,
1.0, projector->dimension());
checkDistribution(policyDistribution);
}
HMM::HMM(int order_, int numStates_, int numObs_)
{
_order = order_;
_numStates = numStates_ + 1; //autoinclude begin/end state
_numObs = numObs_;
_maxState = int(pow(_numStates, _order));
/*Initial HMM parameter matrices */
_pTransition = createMatrix(_maxState, _numStates);
_pObservation = createMatrix(_numStates, _numObs);
condstate_dist = createMatrix(_numObs, _numStates);
//_initial_probability = new double[_maxState];
_pState = new double[_numStates];
srand(time(0));
int sum;
for (int i = 0; i < _numObs; i++)
{
sum = 0;
//_pTransition[i][0] = 0;
for (int j = 0; j < _numStates; j++)
{
int r = (rand() % 10000) + 1;
_pTransition[i][j] = r;
sum += r;
}
for (int j = 0; j < _numStates; j++)
{
_pTransition[i][j] /= sum;
}
if (!checkDistribution(_pTransition[i], _numStates))
{
cout << "Degenerate" << endl;
exit(0);
}
}
for (int o = 0; o < _numObs; o++)
{
_pObservation[0][o] = 0.0;
}
for (int i = 1; i < _numStates; i++)
{
sum = 0;
for (int o = 0; o < _numObs; o++)
{
int r = (rand() % 10000) + 1;
_pObservation[i][o] = r;
sum += r;
}
for (int o = 0; o < _numObs; o++)
{
_pObservation[i][o] /= sum;
}
if (!checkDistribution(_pObservation[i], _numObs))
{
cout << "Degenerate" << endl;
exit(0);
}
}
// //initial_probability[0] = 0.0;
// sum = 0;
// for (int i = 1; i < _numStates; i++)
// {
// int r = (rand() % 10000) + 1;
// initial_probability[i] = r;
// sum += r;
// }
// for (int i = 1; i < _numStates; i++)
// {
// initial_probability[i] /= sum;
// }
//
// for (int i = _numStates; i < _maxState; i++)
// {
// initial_probability[i] = 0.0;
// }
}
