static Int
p_binary_is(void)
{ /* X is Y */
Term t = Deref(ARG2);
Term t1, t2;
if (IsVarTerm(t)) {
Yap_ArithError(INSTANTIATION_ERROR,t, "X is Y");
return(FALSE);
}
t1 = Yap_Eval(Deref(ARG3));
if (!Yap_FoundArithError(t1, ARG3)) {
return FALSE;
}
t2 = Yap_Eval(Deref(ARG4));
if (!Yap_FoundArithError(t2, ARG4)) {
return FALSE;
}
if (IsIntTerm(t)) {
Term tout = Yap_FoundArithError(eval2(IntOfTerm(t), t1, t2), 0L);
if (!tout)
return FALSE;
return Yap_unify_constant(ARG1,tout);
}
if (IsAtomTerm(t)) {
Atom name = AtomOfTerm(t);
ExpEntry *p;
Term out;
if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 2)))) {
Term ti[2];
/* error */
ti[0] = t;
ti[1] = MkIntTerm(1);
t = Yap_MkApplTerm(FunctorSlash, 2, ti);
Yap_Error(TYPE_ERROR_EVALUABLE, t,
"functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE,2);
P = FAILCODE;
return(FALSE);
}
if (!(out=Yap_FoundArithError(eval2(p->FOfEE, t1, t2), 0L)))
return FALSE;
return Yap_unify_constant(ARG1,out);
}
return FALSE;
}
static VALUE *eval1(void)
{
VALUE *l, *r;
l = eval2();
while (nextarg("&")) {
G.args++;
r = eval2();
if (null(l) || null(r)) {
freev(l);
freev(r);
l = int_value(0);
} else
freev(r);
}
return l;
}
/* Parse and evaluate & expressions */
struct val *
eval1(void)
{
struct val *l, *r;
l = eval2();
while (token == AND) {
nexttoken(0);
r = eval2();
if (is_zero_or_null(l) || is_zero_or_null(r)) {
free_value(l);
free_value(r);
l = make_int(0);
} else {
free_value(r);
}
}
return l;
}
int main() {
std::cout << "[t-moRandomNeutralWalkExplorer] => START" << std::endl;
eoBit<eoMinimizingFitness> sol(4, true);
sol.fitness(4);
bitNeighborhood nh(4);
evalOneMax eval(4);
dummyEvalOneMax eval2(4);
moSolNeighborComparator<bitNeighbor> sncomp;
//test avec la fonction d'eval classique
//on verifie qu'on ne trouve pas de voisin de mm fitness
moRandomNeutralWalkExplorer<bitNeighbor> test(nh, eval, sncomp, 3);
test.initParam(sol);
test(sol);
assert(!test.accept(sol));
assert(!test.isContinue(sol));
//test avec une fonction d'eval bidon qui renvoie toujours la mm fitness
//on peut donc verifier qu'on s'arette au bout des 3 itérations.
moRandomNeutralWalkExplorer<bitNeighbor> test2(nh, eval2, sncomp, 3);
sol.fitness(2);
test2.initParam(sol);
test2(sol);
assert(test2.accept(sol));
test2.move(sol);
assert(sol.fitness()==2);
test2.updateParam(sol);
assert(test2.isContinue(sol));
test2(sol);
assert(test2.accept(sol));
test2.move(sol);
assert(sol.fitness()==2);
test2.updateParam(sol);
assert(test2.isContinue(sol));
test2(sol);
assert(test2.accept(sol));
test2.move(sol);
assert(sol.fitness()==2);
test2.updateParam(sol);
assert(!test2.isContinue(sol));
std::cout << "[t-moRandomNeutralWalkExplorer] => OK" << std::endl;
return EXIT_SUCCESS;
}
static void
y_pade(double R, double L, double G, double C, TXLine *h)
{
/* float RdL, GdC; */
double RdL, GdC;
sqtCdL = sqrt(C / L);
RdL = R / L;
GdC = G / C;
mac(GdC, RdL, &b1, &b2, &b3, &b4, &b5);
A[0][0] = 1.0 - sqrt(GdC / RdL);
A[0][1] = b1;
A[0][2] = b2;
A[0][3] = -b3;
A[1][0] = b1;
A[1][1] = b2;
A[1][2] = b3;
A[1][3] = -b4;
A[2][0] = b2;
A[2][1] = b3;
A[2][2] = b4;
A[2][3] = -b5;
Gaussian_Elimination1(3);
p3 = A[0][3];
p2 = A[1][3];
p1 = A[2][3];
q1 = p1 + b1;
q2 = b1 * p1 + p2 + b2;
q3 = p3 * sqrt(GdC / RdL);
find_roots(p1, p2, p3, &x1, &x2, &x3);
c1 = eval2(q1 - p1, q2 - p2, q3 - p3, x1) /
eval2(3.0, 2.0 * p1, p2, x1);
c2 = eval2(q1 - p1, q2 - p2, q3 - p3, x2) /
eval2(3.0, 2.0 * p1, p2, x2);
c3 = eval2(q1 - p1, q2 - p2, q3 - p3, x3) /
eval2(3.0, 2.0 * p1, p2, x3);
h->sqtCdL = sqtCdL;
h->h1_term[0].c = c1;
h->h1_term[1].c = c2;
h->h1_term[2].c = c3;
h->h1_term[0].x = x1;
h->h1_term[1].x = x2;
h->h1_term[2].x = x3;
}
void DatasetTensor::createLogTensors()
{
qDebug() << "create log tensors...";
int blockSize = m_data.size();
m_logData.resize( blockSize );
std::vector<QVector3D> evec1( blockSize );
std::vector<float> eval1( blockSize );
std::vector<QVector3D> evec2( blockSize );
std::vector<float> eval2( blockSize );
std::vector<QVector3D> evec3( blockSize );
std::vector<float> eval3( blockSize );
FMath::evecs( m_data, evec1, eval1, evec2, eval2, evec3, eval3 );
//log(M) =Ulog(D)UT
Matrix U(3,3);
DiagonalMatrix D(3);
Matrix logM(3,3);
for ( unsigned int i = 0; i < m_logData.size(); ++i )
{
U( 1, 1 ) = evec1[i].x();
U( 2, 1 ) = evec1[i].y();
U( 3, 1 ) = evec1[i].z();
U( 1, 2 ) = evec2[i].x();
U( 2, 2 ) = evec2[i].y();
U( 3, 2 ) = evec2[i].z();
U( 1, 3 ) = evec3[i].x();
U( 2, 3 ) = evec3[i].y();
U( 3, 3 ) = evec3[i].z();
D(1) = log( eval1[i] );
D(2) = log( eval2[i] );
D(3) = log( eval3[i] );
logM = U*D*U.t();
m_logData[i] = logM;
}
qDebug() << "create log tensors done!";
}
static Int
do_arith23(arith2_op op)
{ /* X is Y */
Term t = Deref(ARG1);
Int out;
Term t1, t2;
if (IsVarTerm(t)) {
Yap_ArithError(INSTANTIATION_ERROR,t, "X is Y");
return(FALSE);
}
t1 = Yap_Eval(t);
if (t1 == 0L)
return FALSE;
t2 = Yap_Eval(Deref(ARG2));
if (t2 == 0L)
return FALSE;
if (!(out=Yap_FoundArithError(eval2(op, t1, t2), 0L)))
return FALSE;
return Yap_unify_constant(ARG3,out);
}
int MyInterpreter::eval2(char *s, int len, int *val)
{
int i, l;
char *e;
int v, varn = -1, err;
//fwrite(s, 1, len, stderr);
//fprintf(stderr, "\n");
e = s + len;
// Skip space
while (*s != 0 && s<e && (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n'))
s ++;
if (*s == 0 || s == e) {
*val = 1;
return 0;
}
if (*s == '(') {
// ( で始まる場合
char *p;
int in = 1;
s ++;
while (*s != 0 && s<e && (*s == ' ' || *s == '\t'))
s ++;
if (*s == 0 || *s == ')')
return ERROR_SYNTAX;
p = s;
while (*s != 0 && s<e) {
if (*s == '(') {
in ++;
} else if (*s == ')') {
in --;
if (in == 0) {
s ++;
break;
}
}
s ++;
}
if (in > 0)
return ERROR_SYNTAX;
if ((err = eval2(p, s-p-1, &v)) != 0)
return err;
} else if ((*s == '!' && *(s+1) != '=') || *s == '~' || *s == '-' || *s == '+') {
// トークンが1項演算子の場合
char *p, op;
int in = 0;
op = *s;
s ++;
while (*s != 0 && s<e && (*s == ' ' || *s == '\t'))
s ++;
if (*s == 0 || s == e)
return ERROR_SYNTAX;
p = s;
while (*s != 0 && s<e && (in>0 || (*s != '+' && *s != '-' && *s != '>' && *s != '<' && *s != '='))) {
if (*s == '(') {
in ++;
} else if (*s == ')') {
in --;
}
s ++;
}
if (eval2(p, s-p, &v) != 0)
return ERROR_SYNTAX;
if (op == '!')
v = !v;
else if (op == '~')
v = ~v;
else if (op == '-')
v = -v;
} else if (*s>='0' && *s<='9') {
// トークンが数値の場合
if (*s == '0' && *(s+1) == 'x') {
v = 0;
s += 2;
while (*s != 0 && s<e && ((*s>='0' && *s<='9') ||
(*s>='a' && *s<='f') || (*s>='A' && *s<='F'))) {
if (*s>='0' && *s<='9')
v = (v<<4) + (*s - '0');
else if (*s>='a' && *s<='f')
v = (v<<4) + (*s - 'a' + 0xa);
else if (*s>='A' && *s<='F')
v = (v<<4) + (*s - 'A' + 0xa);
s ++;
}
} else if (*s == '0' && *(s+1) == 'b') {
v = 0;
s += 2;
while (*s != 0 && s<e && (*s>='0' && *s<='1')) {
v = (v<<1) + (*s - '0');
s ++;
}
} else {
v = 0;
while (*s != 0 && s<e && *s>='0' && *s<='9') {
v = v*10 + (*s - '0');
s ++;
}
}
} else if (((*s>='a' && *s<='z') || (*s>='A' && *s<='Z')) &&
(!(*(s+1)>='a' && *(s+1)<='z') && !(*(s+1)>='A' && *(s+1)<='Z'))) {
// The token is a varibale
if (*s>='a' && *s<='z')
varn = *s - 'a';
else
varn = *s - 'A';
v = variables[varn];
s ++;
} else {
// 定数かどうかをチェックする
for (i=0; i<CONST_NUM; i++) {
const struct ConstValue *c = constants+i;
if (e-s>=c->len && strncmp(c->name, s, 3) == 0) {
v = c->val;
s += c->len;
break;
}
}
// Check if the token is a supported function
// 引数が1つの関数
for (i=0; i<func1Handlers.count(); i++) {
const struct Function1 *f = &func1Handlers[i];
if (e-s>=f->len && strncmp(f->name, s, f->len) == 0) {
char *p;
int in = 1, v1;
s += f->len;
p = s;
while (*s != 0 && s<e && in>0) {
if (*s == '(') {
in ++;
} else if (*s == ')') {
in --;
}
s ++;
}
if (in>0)
return ERROR_SYNTAX;
if (eval2(p, s-p-1, &v1) != 0)
return ERROR_SYNTAX;
#ifdef USE_DELEGATES
v = f->func(v1);
#else
v = (*f->func)(v1);
#endif
}
}
// 引数が2つの関数
for (i=0; i<func2Handlers.count(); i++) {
const struct Function2 *f = &func2Handlers[i];
if (e-s>=f->len && strncmp(f->name, s, f->len) == 0) {
char *p;
int in = 0, v1, v2;
s += f->len;
p = s;
while (*s != 0 && s<e && !(in == 0 && *s == ',')) {
if (*s == '(')
in ++;
else if (*s == ')')
in --;
s ++;
}
if (*s != ',')
return ERROR_SYNTAX;
if (eval2(p, s-p, &v1) != 0)
return ERROR_SYNTAX;
s ++;
p = s;
in = 1;
while (*s != 0 && s<e && in>0) {
if (*s == '(')
in ++;
else if (*s == ')')
in --;
s ++;
}
if (in>0)
return ERROR_SYNTAX;
if (eval2(p, s-p-1, &v2) != 0)
return ERROR_SYNTAX;
#ifdef USE_DELEGATES
v = f->func(v1, v2);
#else
v = (*f->func)(v1, v2);
#endif
break;
}
}
// 引数が3つの関数
for (i=0; i<func3Handlers.count(); i++) {
const struct Function3 *f = &func3Handlers[i];
if (e-s>=f->len && strncmp(f->name, s, f->len) == 0) {
char *p;
int in = 0, v1, v2, v3;
s += f->len;
p = s;
while (*s != 0 && s<e && !(in == 0 && *s == ',')) {
if (*s == '(')
in ++;
else if (*s == ')')
in --;
s ++;
}
if (*s != ',')
return ERROR_SYNTAX;
if (eval2(p, s-p, &v1) != 0)
return ERROR_SYNTAX;
s ++;
p = s;
in = 0;
while (*s != 0 && s<e && !(in == 0 && *s == ',')) {
if (*s == '(')
in ++;
else if (*s == ')')
in --;
s ++;
}
if (*s != ',')
return ERROR_SYNTAX;
if (eval2(p, s-p-1, &v2) != 0)
return ERROR_SYNTAX;
s ++;
p = s;
in = 1;
while (*s != 0 && s<e && in>0) {
if (*s == '(')
in ++;
else if (*s == ')')
in --;
s ++;
}
if (in>0)
return ERROR_SYNTAX;
if (eval2(p, s-p-1, &v3) != 0)
return ERROR_SYNTAX;
#ifdef USE_DELEGATES
v = f->func(v1, v2, v3);
#else
v = (*f->func)(v1, v2, v3);
#endif
break;
}
}
}
// 次のトークンを確かめる
{
int v2;
// Skip space
while (*s != 0 && s<e && (*s == ' ' || *s == '\t'))
s ++;
if (*s == 0 || s == e) { // 後ろに演算子はなかった
*val = v;
return 0;
}
if (*s == '=' && *(s+1) != '=') {
char *p;
int op = *s, in = 0;
s ++;
while (*s != 0 && s<e && (*s == ' ' || *s == '\t'))
s ++;
if (*s == 0 || s == e)
return ERROR_SYNTAX;
p = s;
while (*s != 0 && s<e && (in>0 ||
!(*s == '=' && *(s+1) == '='))) {
if (*s == '(') {
in ++;
} else if (*s == ')') {
in --;
}
s ++;
}
if ((err = eval2(p, s-p, &v2)) != 0)
return err;
if (varn < 0 || varn>=sizeof(variables))
return ERROR_INTERNAL;
v = variables[varn] = v2;
if (*s == 0 || s == e) {
*val = v;
return 0;
}
}
while (*s == '*' || *s == '/' || *s == '%') {
char *p;
int op = *s, in = 0;
s ++;
while (*s != 0 && s<e && (*s == ' ' || *s == '\t'))
s ++;
if (*s == 0 || s == e)
return ERROR_SYNTAX;
p = s;
while (*s != 0 && s<e && (in>0 ||
(*s != '*' && *s != '/' && *s != '%' &&
*s != '+' && *s != '-' && *s != '>' && *s != '<' &&
!(*s == '=' && *(s+1) == '=') && *s != '!'))) {
if (*s == '(') {
in ++;
} else if (*s == ')') {
in --;
}
s ++;
}
if ((err = eval2(p, s-p, &v2)) != 0)
return err;
switch (op) {
case '*':
v = v*v2;
break;
case '/':
v = v/v2;
break;
case '%':
v = v%v2;
break;
}
if (*s == 0 || s == e) {
*val = v;
return 0;
}
}
if (*s == '+' || *s == '-') {
char *p;
int op = *s, in = 0;
p = s;
while (*s != 0 && s<e && (in>0 || (*s != '>' && *s != '<' && *s != '=' && *s != '!'))) {
if (*s == '(') {
in ++;
} else if (*s == ')') {
in --;
}
s ++;
}
if (in != 0)
return ERROR_SYNTAX;
// 演算子の右側を計算する
if ((err = eval2(p, s-p, &v2)) != 0)
return err;
// 左と右を足す
v = v + v2;
if (*s == 0 || s==e) {
*val = v;
return 0;
}
}
if (*s == '>' || *s == '<' || (*s == '=' && *(s+1) == '=')
|| (*s == '!' && *(s+1) == '=')) {
char *p;
int op = *s, op2 = *(s+1), in = 0;
s ++;
if (op2 == '=' || op2 == '<' || op2 == '>')
s ++;
p = s;
while (*s != 0 && s<e && (in>0 || (*s != '&' && *s != '^' && *s != '|'))) {
if (*s == '(') {
in ++;
} else if (*s == ')') {
in --;
}
s ++;
}
if (in != 0)
return ERROR_SYNTAX;
// 演算子の右側を計算する
if ((err = eval2(p, s-p, &v2)) != 0)
return err;
if (op == '>') {
if (op2 == '=') {
v = v>=v2;
} else if (op2 == '>') {
v = v>>v2;
} else {
v = v>v2;
}
} else if (op == '<') {
int main (int __argc, char *__argv[])
{
peo :: init( __argc, __argv );
if (getNodeRank()==1)
std::cout<<"\n\nTest : PSO Global Best\n\n";
rng.reseed (10);
RingTopology topologyMig;
eoGenContinue < Indi > genContPara (10);
eoCombinedContinue <Indi> continuatorPara (genContPara);
eoCheckPoint<Indi> checkpoint(continuatorPara);
peoEvalFunc<Indi, double, const Indi& > plainEval(f);
peoPopEval< Indi > eval(plainEval);
eoUniformGenerator < double >uGen (0, 1.);
eoInitFixedLength < Indi > random (2, uGen);
eoUniformGenerator < double >sGen (-1., 1.);
eoVelocityInitFixedLength < Indi > veloRandom (2, sGen);
eoFirstIsBestInit < Indi > localInit;
eoRealVectorBounds bndsFlight(2,0,1.);
eoStandardFlight < Indi > flight(bndsFlight);
eoPop < Indi > pop;
pop.append (10, random);
eoLinearTopology<Indi> topology(2);
eoRealVectorBounds bnds(2,-1.,1.);
eoStandardVelocity < Indi > velocity (topology,1,0.5,2.,bnds);
eoInitializer <Indi> init(eval,veloRandom,localInit,topology,pop);
eoPeriodicContinue< Indi > mig_cont( 2 );
peoPSOSelect<Indi> mig_selec(topology);
peoGlobalBestVelocity<Indi> mig_replac (2.,velocity);
eoContinuator<Indi> cont(mig_cont, pop);
eoSelector <Indi, eoPop<Indi> > mig_select (mig_selec,1,pop);
eoReplace <Indi, eoPop<Indi> > mig_replace (mig_replac,pop);
eoGenContinue < Indi > genContPara2 (10);
eoCombinedContinue <Indi> continuatorPara2 (genContPara2);
eoCheckPoint<Indi> checkpoint2(continuatorPara2);
peoEvalFunc<Indi, double, const Indi& > plainEval2(f);
peoPopEval< Indi > eval2(plainEval2);
eoUniformGenerator < double >uGen2 (0, 1.);
eoInitFixedLength < Indi > random2 (2, uGen2);
eoUniformGenerator < double >sGen2 (-1., 1.);
eoVelocityInitFixedLength < Indi > veloRandom2 (2, sGen2);
eoFirstIsBestInit < Indi > localInit2;
eoRealVectorBounds bndsFlight2(2,0,1.);
eoStandardFlight < Indi > flight2(bndsFlight2);
eoPop < Indi > pop2;
pop2.append (10, random2);
eoLinearTopology<Indi> topology2(2);
eoRealVectorBounds bnds2(2,-1.,1.);
eoStandardVelocity < Indi > velocity2 (topology2,1,0.5,2.,bnds2);
eoInitializer <Indi> init2(eval2,veloRandom2,localInit2,topology2,pop2);
eoPeriodicContinue< Indi > mig_cont2( 2 );
peoPSOSelect<Indi> mig_selec2(topology2);
peoGlobalBestVelocity<Indi> mig_replac2 (2.,velocity2);
eoContinuator<Indi> cont2(mig_cont2,pop2);
eoSelector <Indi, eoPop<Indi> > mig_select2 (mig_selec2,1,pop2);
eoReplace <Indi, eoPop<Indi> > mig_replace2 (mig_replac2,pop2);
peoAsyncIslandMig< eoPop<Indi>, eoPop<Indi> > mig(cont,mig_select, mig_replace, topologyMig);
checkpoint.add( mig );
peoAsyncIslandMig< eoPop<Indi>, eoPop<Indi> > mig2(cont2,mig_select2, mig_replace2, topologyMig);
checkpoint2.add( mig2 );
eoSyncEasyPSO <Indi> psa(init,checkpoint,eval, velocity, flight);
peoWrapper parallelPSO( psa, pop);
eval.setOwner(parallelPSO);
mig.setOwner(parallelPSO);
eoSyncEasyPSO <Indi> psa2(init2,checkpoint2,eval2, velocity2, flight2);
peoWrapper parallelPSO2( psa2, pop2);
eval2.setOwner(parallelPSO2);
mig2.setOwner(parallelPSO2);
peo :: run();
peo :: finalize();
if (getNodeRank()==1)
{
pop.sort();
pop2.sort();
std::cout << "Final population :\n" << pop << std::endl;
std::cout << "Final population :\n" << pop2 << std::endl;
}
}
Term Yap_eval_binary(Int f, Term t1, Term t2)
{
return eval2(f,t1,t2);
}
static int pade(double l)
{
int i, j;
double a[6];
double b[6];
a[1] = -a1;
a[2] = -a2;
a[3] = -a3;
a[4] = -a4;
a[5] = -a5;
b[0] = 1.0;
b[1] = a[1];
for (i = 2; i <= 5; i++) {
b[i] = 0.0;
for (j = 1; j <= i; j++)
b[i] += j * a[j] * b[i-j];
b[i] = b[i] / (double) i;
}
AA[0][0] = 1.0 - exp(a0 - l * sqrt(RG));
AA[0][1] = b[1];
AA[0][2] = b[2];
AA[0][3] = -b[3];
AA[1][0] = b[1];
AA[1][1] = b[2];
AA[1][2] = b[3];
AA[1][3] = -b[4];
AA[2][0] = b[2];
AA[2][1] = b[3];
AA[2][2] = b[4];
AA[2][3] = -b[5];
Gaussian_Elimination2(3);
ep3 = AA[0][3];
ep2 = AA[1][3];
ep1 = AA[2][3];
eq1 = ep1 + b[1];
eq2 = b[1] * ep1 + ep2 + b[2];
eq3 = ep3 * exp(a0 - l * sqrt(RG));
ep3 = ep3 / (tau*tau*tau);
ep2 = ep2 / (tau*tau);
ep1 = ep1 / tau;
eq3 = eq3 / (tau*tau*tau);
eq2 = eq2 / (tau*tau);
eq1 = eq1 / tau;
/*
printf("factor = %e\n", exp(-a0));
printf("ep1 = %e ep2 = %e ep3 = %e\n", ep1, ep2, ep3);
*/
exp_find_roots(ep1, ep2, ep3, &ex1, &ex2, &ex3);
/*
printf("roots are %e %e %e \n", ex1, ex2, ex3);
*/
ec1 = eval2(eq1 - ep1, eq2 - ep2, eq3 - ep3, ex1) /
eval2(3.0, 2.0 * ep1, ep2, ex1);
if (ifImg)
get_c(eq1 - ep1, eq2 - ep2, eq3 - ep3, ep1, ep2, ex2, ex3, &ec2, &ec3);
else {
ec2 = eval2(eq1 - ep1, eq2 - ep2, eq3 - ep3, ex2) /
eval2(3.0, 2.0 * ep1, ep2, ex2);
ec3 = eval2(eq1 - ep1, eq2 - ep2, eq3 - ep3, ex3) /
eval2(3.0, 2.0 * ep1, ep2, ex3);
}
return (1);
}
/*! \section example55 Example 55: Evaluating Similarity of Two Feature Selection Processes.
To study the difference in feature preferences among principally different feature selection methods
or among differently parametrized instances of the same method FST3 provides measures
capable of evaluating the level of similarity between two sets of trials (Somol Novovicova, IEEE, TPAMI, 2010).
In analogy to stability evaluation (see \ref example54) for each of the two feature selection scenarios
a series of trials is conducted on various samplings of the same data. In this example ten feature selection
trials are performed per scenario, each on randomly sampled 95% of the data. In the first scenario
in each trial the resulting subset is obtained using DOS procedure, optimizing the 3-Nearest
Neighbour accuracy estimated by means of 3-fold cross-validation. In the second scenario
in each trial the resulting subset is obtained using SFFS procedure, maximizing
the Bhattacharyya distance based on normal model. A selection of standard stability measures
is evaluated separately for each of the two scenarios. Eventually the similarity of the two
scenarios is evaluated using analogously founded similarity measures. All measures yield values from
[0,1], where values close to 0 denote low stability/similarity and values close to 1 denote
high stability/similarity. Note that in this experiment the inter-measures (IATI, ICW, IANHI)
yield markedly lower values than the corresponding stability measures (ATI, CW, ANHI).
This illustrates well that considerably different results can be expected from differently founded
feature selection methods.
*/
int main()
{
try{
typedef double RETURNTYPE; typedef double DATATYPE; typedef double REALTYPE;
typedef unsigned int IDXTYPE; typedef unsigned int DIMTYPE; typedef short BINTYPE;
typedef FST::Subset<BINTYPE, DIMTYPE> SUBSET;
typedef FST::Data_Intervaller<std::vector<FST::Data_Interval<IDXTYPE> >,IDXTYPE> INTERVALLER;
typedef boost::shared_ptr<FST::Data_Splitter<INTERVALLER,IDXTYPE> > PSPLITTER;
typedef FST::Data_Splitter_CV<INTERVALLER,IDXTYPE> SPLITTERCV;
typedef FST::Data_Splitter_RandomRandom<INTERVALLER,IDXTYPE,BINTYPE> SPLITTERRANDRAND;
typedef FST::Data_Accessor_Splitting_MemTRN<DATATYPE,IDXTYPE,INTERVALLER> DATAACCESSOR; // uncomment for TRN data format
//typedef FST::Data_Accessor_Splitting_MemARFF<DATATYPE,IDXTYPE,INTERVALLER> DATAACCESSOR; // uncomment for ARFF data format
typedef FST::Distance_L1<DATATYPE,DIMTYPE,SUBSET> DISTANCEL1;
typedef FST::Classifier_kNN<RETURNTYPE,DATATYPE,IDXTYPE,DIMTYPE,SUBSET,DATAACCESSOR,DISTANCEL1> CLASSIFIERKNN;
typedef FST::Criterion_Wrapper<RETURNTYPE,SUBSET,CLASSIFIERKNN,DATAACCESSOR> WRAPPER;
typedef FST::Sequential_Step_Straight<RETURNTYPE,DIMTYPE,SUBSET,WRAPPER> EVALUATOR1;
typedef FST::Criterion_Normal_Bhattacharyya<RETURNTYPE,DATATYPE,REALTYPE,IDXTYPE,DIMTYPE,SUBSET,DATAACCESSOR> BHATTCRIT;
typedef FST::Sequential_Step_Straight<RETURNTYPE,DIMTYPE,SUBSET,BHATTCRIT> EVALUATOR2;
typedef FST::Result_Tracker_Stability_Evaluator<RETURNTYPE,IDXTYPE,DIMTYPE,SUBSET> TRACKER;
std::cout << "Starting Example 55: Evaluating Similarity of Two Feature Selection Processes..." << std::endl;
// set-up ten trials where in each 95% of data is randomly sampled
PSPLITTER dsp_outer(new SPLITTERRANDRAND(10/*splits=trials*/,95,5));
// in the course of wrapper based feature subset search (in one trial) use 3-fold cross-validation
PSPLITTER dsp_inner(new SPLITTERCV(3));
// do not scale data
boost::shared_ptr<FST::Data_Scaler<DATATYPE> > dsc(new FST::Data_Scaler_void<DATATYPE>());
// set-up data access
boost::shared_ptr<std::vector<PSPLITTER> > splitters(new std::vector<PSPLITTER>);
splitters->push_back(dsp_outer); splitters->push_back(dsp_inner);
boost::shared_ptr<DATAACCESSOR> da(new DATAACCESSOR("data/speech_15.trn",splitters,dsc));
da->initialize();
// initiate access to split data parts
da->setSplittingDepth(0); if(!da->getFirstSplit()) throw FST::fst_error("RandRand data split failed.");
da->setSplittingDepth(1); if(!da->getFirstSplit()) throw FST::fst_error("3-fold cross-validation failure.");
// initiate the storage for subset to-be-selected
boost::shared_ptr<SUBSET> sub(new SUBSET(da->getNoOfFeatures())); sub->deselect_all();
// set-up result trackers to collect results of each trial in both scenarios
boost::shared_ptr<TRACKER> tracker1(new TRACKER);
boost::shared_ptr<TRACKER> tracker2(new TRACKER);
// FEATURE SELECTION SCENARIO A (wrapper)
// set-up 3-Nearest Neighbor classifier based on L1 distances
boost::shared_ptr<CLASSIFIERKNN> cknn1(new CLASSIFIERKNN);
cknn1->set_k(3);
// wrap the 3-NN classifier to enable its usage as FS criterion (criterion value will be estimated by 3-fold cross-val.)
boost::shared_ptr<WRAPPER> wknn1(new WRAPPER);
wknn1->initialize(cknn1,da);
// set-up the standard sequential search step object (option: hybrid, ensemble, threaded)
boost::shared_ptr<EVALUATOR1> eval1(new EVALUATOR1);
// set-up Sequential Forward Floating Selection search procedure
FST::Search_DOS<RETURNTYPE,DIMTYPE,SUBSET,WRAPPER,EVALUATOR1> srch1(eval1);
srch1.set_delta(10);
sub->deselect_all();
// Technical remark: should threaded evaluator be used in this case, it would be necessary to move both the evaluator and search procedure set-up
// inside the trial loop. The reason is technical: threaded evaluator caches criterion clones, including data accessor state.
// Therefore no outside changes in splitting level nor current split change can be reflected in criterion evaluation. Renewed
// evaluator set-up resets the cache and thus ensures correct threaded criterion evaluation behavior after split change.
// run the trials
std::cout << "Feature selection setup:" << std::endl << *da << std::endl << *wknn1 << std::endl << *tracker1 << std::endl << std::endl;
RETURNTYPE critval_train;
da->setSplittingDepth(0);
unsigned int trial=0;
bool run=da->getFirstSplit(); if(!run) throw FST::fst_error("RandRand data split failed.");
while(run)
{
trial++; std::cout << std::endl<<"TRIAL A"<<trial<< " ---------------------------------------------------------------------"<<std::endl;
da->setSplittingDepth(1);
if(!srch1.search(0,critval_train,sub,wknn1,std::cout)) throw FST::fst_error("Search not finished.");
tracker1->add(critval_train,sub);
std::cout << std::endl << "(TRIAL A"<<trial<<") Search result: " << std::endl << *sub << "Criterion value=" << critval_train << std::endl;
da->setSplittingDepth(0);
run=da->getNextSplit();
}
// FEATURE SELECTION SCENARIO B (filter)
// set-up normal Bhattacharyya distance criterion
boost::shared_ptr<BHATTCRIT> cb(new BHATTCRIT);
// set-up the standard sequential search step object (option: hybrid, ensemble, threaded)
boost::shared_ptr<EVALUATOR2> eval2(new EVALUATOR2);
// set-up Sequential Forward Floating Selection search procedure
FST::Search_SFFS<RETURNTYPE,DIMTYPE,SUBSET,BHATTCRIT,EVALUATOR2> srch2(eval2);
srch2.set_search_direction(FST::FORWARD);
// target subset size must be set because Bhattacharyya is monotonous with respect to subset size (i.e., evaluates full set as the best)
const DIMTYPE target_size=7;
// run the trials
std::cout << "Feature selection setup:" << std::endl << *da << std::endl << srch2 << std::endl << *cb << std::endl << *tracker2 << std::endl << std::endl;
trial=0;
da->setSplittingDepth(0);
run=da->getFirstSplit(); if(!run) throw FST::fst_error("RandRand data split failed.");
while(run)
{
trial++; std::cout << std::endl<<"TRIAL B"<<trial<< " ---------------------------------------------------------------------"<<std::endl;
cb->initialize(da); // (note that cb initialization = normal model parameter estimation on training data, therefore it must be repeated for each split)
da->setSplittingDepth(1);
if(!srch2.search(target_size,critval_train,sub,cb,std::cout)) throw FST::fst_error("Search not finished.");
tracker2->add(critval_train,sub);
std::cout << std::endl << "(TRIAL B"<<trial<<") Search result: " << std::endl << *sub << "Criterion value=" << critval_train << std::endl;
da->setSplittingDepth(0);
run=da->getNextSplit();
}
// evaluate stability of each scenario and similarity of the two scenarios using results collected by trackers
std::cout<<std::endl;
std::cout << "---------------------------------------------------------------------" << std::endl;
std::cout << "Scenario A resulting criterion values' mean: " << tracker1->value_mean() << ", std. dev.: " << tracker1->value_stddev() << std::endl;
std::cout << "Scenario A subset sizes' mean: " << tracker1->size_mean() << ", std. dev.: " << tracker1->size_stddev() << std::endl;
std::cout << std::endl;
std::cout << "Scenario A stability_ATI()=" << tracker1->stability_ATI() << std::endl;
std::cout << "Scenario A stability_CW()=" << tracker1->stability_CW() << std::endl;
std::cout << "Scenario A stability_ANHI("<<da->getNoOfFeatures()<<")=" << tracker1->stability_ANHI(da->getNoOfFeatures()) << std::endl;
std::cout<<std::endl;
std::cout << "Scenario B resulting criterion values' mean: " << tracker2->value_mean() << ", std. dev.: " << tracker2->value_stddev() << std::endl;
std::cout << "Scenario B subset sizes' mean: " << tracker2->size_mean() << ", std. dev.: " << tracker2->size_stddev() << std::endl;
std::cout << std::endl;
std::cout << "Scenario B stability_ATI()=" << tracker2->stability_ATI() << std::endl;
std::cout << "Scenario B stability_CW()=" << tracker2->stability_CW() << std::endl;
std::cout << "Scenario B stability_ANHI("<<da->getNoOfFeatures()<<")=" << tracker2->stability_ANHI(da->getNoOfFeatures()) << std::endl;
std::cout<<std::endl;
std::cout << "Evaluating similarity between scenario A and scenario B:"<< std::endl;
std::cout << "similarity measure IATI()=" << tracker1->similarity_IATI(*tracker2) << std::endl;
std::cout << "similarity measure ICW()=" << tracker1->similarity_ICW(*tracker2) << std::endl;
std::cout << "similarity measure IANHI("<<da->getNoOfFeatures()<<")=" << tracker1->similarity_IANHI(da->getNoOfFeatures(), *tracker2) << std::endl;
}
catch(FST::fst_error &e) {std::cerr<<"FST ERROR: "<< e.what() << ", code=" << e.code() << std::endl;}
catch(std::exception &e) {std::cerr<<"non-FST ERROR: "<< e.what() << std::endl;}
return 0;
}
