source: proiecte/Parallel-DT/R8/Src/testrules.c @ 22

/*************************************************************************/
/*                                                                       */
/*      Evaluatation of rulesets                                         */
/*      ------------------------                                         */
/*                                                                       */
/*************************************************************************/


#include "defns.i"
#include "types.i"
#include "extern.i"
#include "rulex.i"



/*************************************************************************/
/*                                                                       */
/*      Evaluate all rulesets                                            */
/*                                                                       */
/*************************************************************************/


    EvaluateRulesets(DeleteRules)
/*  ----------------  */
    Boolean DeleteRules;
{
    short t;
    ItemNo *Errors, Interpret();
    float AvSize=0, AvErrs=0;
    Boolean Final;

    if ( TRIALS == 1 )
    {
        /*  Evaluate current ruleset as there is no composite ruleset  */

        Interpret(0, MaxItem, DeleteRules, true, true);
        return;
    }

    Errors = (ItemNo *) malloc((TRIALS+1) * sizeof(ItemNo));

    ForEach(t, 0, TRIALS)
    {
        NRules    = PRSet[t].SNRules;
        Rule      = PRSet[t].SRule;
        RuleIndex = PRSet[t].SRuleIndex;
        DefaultClass = PRSet[t].SDefaultClass;

        if ( t < TRIALS )
        {
            printf("\nRuleset %d:\n", t);
        }
        else
        {
            printf("\nComposite ruleset:\n");
        }

        Final = (t == TRIALS);
        Errors[t] = Interpret(0, MaxItem, DeleteRules, Final, Final);

        AvSize += NRules;
        AvErrs += Errors[t];

        if ( DeleteRules )
        {
            PRSet[t].SNRules = NRules;
        }
    }

    /*  Print report  */

    printf("\n");
    printf("Trial   Size      Errors\n");
    printf("-----   ----      ------\n");

    ForEach(t, 0, TRIALS)
    {
        if ( t < TRIALS )
        {
            printf("%4d", t);
        }
        else
        {
            printf("  **");
        }
        printf("    %4d  %3d(%4.1f%%)\n",
              PRSet[t].SNRules, Errors[t], 100 * Errors[t] / (MaxItem+1.0));
    }

    AvSize /= TRIALS + 1;
    AvErrs /= TRIALS + 1;
    printf("\t\t\t\tAv size = %.1f,  av errors = %.1f (%.1f%%)\n",
           AvSize, AvErrs, 100 * AvErrs / (MaxItem+1.0));
}



/*************************************************************************/
/*                                                                       */
/*      Evaluate current ruleset                                         */
/*                                                                       */
/*************************************************************************/


float   Confidence;             /* certainty factor of fired rule */
                                /* (set by BestRuleIndex) */


ItemNo Interpret(Fp, Lp, DeleteRules, CMInfo, Arrow)
/*     ---------  */
    ItemNo Fp, Lp;
    Boolean DeleteRules, CMInfo, Arrow;
{
    ItemNo i, Tested=0, Errors=0, *Better, *Worse, *ConfusionMat;
    Boolean FoundRule;
    ClassNo AssignedClass, AltClass;
    Attribute Att;
    RuleNo p, Bestr, ri, ri2, riDrop=0, BestRuleIndex();
    float ErrorRate, BestRuleConfidence;

    if ( CMInfo )
    {
        ConfusionMat = (ItemNo *) calloc((MaxClass+1)*(MaxClass+1), sizeof(ItemNo));
    }

    ForEach(ri, 1, NRules)
    {
        p = RuleIndex[ri];
        Rule[p].Used = Rule[p].Incorrect = 0;
    }

    Better = (ItemNo *) calloc(NRules+1, sizeof(ItemNo));
    Worse  = (ItemNo *) calloc(NRules+1, sizeof(ItemNo));

    ForEach(i, Fp, Lp)
    {
        /*  Find first choice for rule for this item  */

        ri = BestRuleIndex(Item[i], 1);
        Bestr = ( ri ? RuleIndex[ri] : 0 );
        FoundRule = Bestr > 0;

        if ( FoundRule )
        {
            Rule[Bestr].Used++;
            AssignedClass =  Rule[Bestr].Rhs;
            BestRuleConfidence = Confidence;

            /*  Now find second choice  */

            ri2 = BestRuleIndex(Item[i], ri+1);
            AltClass = ( ri2 ? Rule[RuleIndex[ri2]].Rhs : DefaultClass );
            if ( AltClass != AssignedClass )
            {
                if ( AssignedClass == Class(Item[i]) )
                {
                    Better[ri]++;
                }
                else
                if ( AltClass == Class(Item[i]) )
                {
                    Worse[ri]++;
                }
            }
        }
        else
        {
            AssignedClass = DefaultClass;
        }
        
        if ( CMInfo )
        {
            ConfusionMat[Class(Item[i])*(MaxClass+1)+AssignedClass]++;
        }
        Tested++;

        if ( AssignedClass != Class(Item[i]) )
        {
            Errors++;
            if ( FoundRule ) Rule[Bestr].Incorrect++;

            Verbosity(3)
            {
                printf("\n");
                ForEach(Att, 0, MaxAtt)
                {
                    printf("\t%s: ", AttName[Att]);
                    if ( MaxAttVal[Att] )
                    {
                        if ( DVal(Item[i],Att) )
                        {
                            printf("%s\n", AttValName[Att][DVal(Item[i],Att)]);
                        }
                        else
                        {
                            printf("?\n");
                        }
                    }
                    else
                    {
                        if ( CVal(Item[i],Att) != Unknown )
                        {
                            printf("%g\n", CVal(Item[i],Att));
                        }
                        else
                        {
                            printf("?\n");
                        }
                    }
                }
                printf("\t%4d:\tGiven class %s,", i, ClassName[Class(Item[i])]);
                if ( FoundRule )
                {
                    printf(" rule %d [%.1f%%] gives class ",
                            Bestr, 100 * BestRuleConfidence);
                }
                else
                {
                    printf(" default class ");
                }
                printf("%s\n", ClassName[AssignedClass]);
            }
        }
    }

    printf("\nRule  Size  Error  Used  Wrong\t          Advantage\n");
    printf(  "----  ----  -----  ----  -----\t          ---------\n");
    ForEach(ri, 1, NRules)
    {
        p = RuleIndex[ri];
        if ( Rule[p].Used > 0 )
        {
            ErrorRate = Rule[p].Incorrect / (float) Rule[p].Used;

            printf("%4d%6d%6.1f%%%6d%7d (%.1f%%)\t%6d (%d|%d) \t%s\n",
                    p, Rule[p].Size,
                    100 * Rule[p].Error, Rule[p].Used, Rule[p].Incorrect,
                    100 * ErrorRate,
                    Better[ri]-Worse[ri], Better[ri], Worse[ri],
                    ClassName[Rule[p].Rhs]);

            /*  See whether this rule should be dropped.  Note: can only drop
                one rule at a time, because Better and Worse are affected  */

            if ( DeleteRules && ! riDrop && Worse[ri] > Better[ri] )
            {
                riDrop = ri;
            }
        }
    }

    cfree(Better);
    cfree(Worse);

    if ( riDrop )
    {
        printf("\nDrop rule %d\n", RuleIndex[riDrop]);

        ForEach(ri, riDrop+1, NRules)
        {
            RuleIndex[ri-1] = RuleIndex[ri];
        }
        NRules--;
    
        if ( CMInfo ) free(ConfusionMat);
        return Interpret(Fp, Lp, DeleteRules, true, Arrow);
    }
    else
    {
        printf("\nTested %d, errors %d (%.1f%%)%s\n",
            Tested, Errors, 100 * Errors / (float) Tested,
            ( Arrow ? "   <<" : "" ));
    }

    if ( CMInfo )
    {
        PrintConfusionMatrix(ConfusionMat);
        free(ConfusionMat);
    }

    return Errors;
}



/*************************************************************************/
/*                                                                       */
/*      Find the best rule for the given case, leaving probability       */
/*      in Confidence                                                    */
/*                                                                       */
/*************************************************************************/


RuleNo BestRuleIndex(CaseDesc, Start)
/*     ---------------  */
    Description CaseDesc;
    RuleNo Start;
{
    RuleNo r, ri;
    float Strength();

    ForEach(ri, Start, NRules)
    {
        r = RuleIndex[ri];
        Confidence = Strength(Rule[r], CaseDesc);

        if ( Confidence > 0.1 )
        {
            return ri;
        }
    }

    Confidence = 0.0;
    return 0;
}