root/vtcross/branches/nikhil/crossmodel2/src/cognitive_engines/CBR_CE/CBR_CE.cpp @ 568

/*
 Copyright 2009 Virginia Polytechnic Institute and State University  

 Licensed under the Apache License, Version 2.0 (the "License"); 
 you may not use this file except in compliance with the License. 
 You may obtain a copy of the License at 
 
 http://www.apache.org/licenses/LICENSE-2.0 

 Unless required by applicable law or agreed to in writing, software 
 distributed under the License is distributed on an "AS IS" BASIS, 
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 See the License for the specific language governing permissions and 
 limitations under the License. 
*/

/*! This file provides a default implementation for a case-based-reasoning based
 * cognitive engine.
 */

#include "CBR_CE.h"
#include <iostream>


using namespace std;

// ZERO is consider +1 sign
inline int signof(int nos) { return ( (nos < 0) ? -1:1 ); }




CBR_CE::CBR_CE(const char* serverName, const char* serverPort, \
        const int32_t numFields, const bool SML) \
    : CognitiveEngine(serverName, serverPort, numFields, SML)
{
    BuildCognitiveEngine();
}


Parameter* 
CBR_CE::GetSolution(Observable *observables, Parameter *currentParameters, Utility *utilities)
{
    LOG("Cognitive Engine:: Generating solution.\n");

    string searchNames[radioInfo->numUtilities];

    for(size_t i = 0; i < radioInfo->numUtilities; i++) {
        searchNames[i] = uList[i].name;
    }

    float searchVals[radioInfo->numUtilities];

    for(size_t i = 0; i < radioInfo->numUtilities; i++) {
        searchVals[i] = uList[i].target;
    }

    uint32_t numberColumns = radioInfo->numParameters + radioInfo->numUtilities + radioInfo->numObservables + 1;
    
    float returnValues[numberColumns];
    
    int searchOps[radioInfo->numUtilities];
    for(size_t i = 0; i < radioInfo->numUtilities; i++) {

        /* If the goal is to maximum, set the search operation to
         * return values greater than the target.
         *
         * If the goal is to minimize, set the search operation to
         * return values less than the target.
         *
         * NOTE: the values '2' and '4' here are from some old preprocesser
         * definitions, which I will copy here until I can figure out just what
         * exactly they were for:
                42      #define EQ 0    // equals
                43      #define NE 1    // not equals
                44      #define GT 2    // greater than
                45      #define GE 3    // greater than or equal to
                46      #define LT 4    // less than
                47      #define LE 5    // less than or equal to
         */
        if(strcmp(uList[i].goal.c_str(), "max") == 0) {
            searchOps[i] = 2;
        } else if(strcmp(uList[i].goal.c_str(), "min") == 0) {
            searchOps[i] = 4;
        }
    }

    /* CBR specific call */
    uint32_t rc = myCBR1->Search(searchNames, searchOps, searchVals,
            radioInfo->numUtilities, returnValues);

    if(rc == 0){
        /* Adapt the returned parameters to meet the objective */
        LOG("Cognitive Engine:: Found\n");
        
        FineTune();

    } else if(rc == 31337) {
        LOG("Cognitive Engine:: Not Found.\n");
        /* No rows in the CBR, pick default parameters */
        /* Currently this is hard coded and implementation specific! */

     int Pt = optList->Ptune; 
 // helps to cycle from on parameter to another.. 

        for (int i = 0; i < radioInfo->numParameters; i++) {
            returnValues[i] = currentParameters[i].value;
        }
    
        returnValues[Pt] = currentParameters[Pt].value + pList[Pt].step*(optList->Slope[Pt]);
                    
////////////////////   LIMITER   /////////////////////////////
            if (returnValues[Pt] > pList[Pt].max) {
                std::cout << "SORRY CANT EXCEED MAX VALUE" << std::endl;
                returnValues[Pt] = returnValues[Pt] - pList[Pt].step;
                optList->Ptune += 1;
            }
            if (returnValues[Pt] < pList[Pt].min) {
                std::cout << "SORRY CANT GO BELOW MIN VALUE" << std::endl;
                returnValues[Pt] = returnValues[Pt] + pList[Pt].step ;
                optList->Ptune += 1;             
            }

            if (optList->Ptune > radioInfo->numParameters) {
                optList->Ptune = 0;             
            }
/////////////////////////////////////////////////////////////
        

        for (int i = 0; i < radioInfo->numUtilities; i++) {
            returnValues[radioInfo->numParameters + i] = uList[i].value;
        }

        for (int i = 0; i < radioInfo->numObservables; i++) {
            returnValues[radioInfo->numParameters + radioInfo->numUtilities + i] = oList[i].value;
        }

    size_t returnValueIndex = 0;
    for(size_t i = 0; i < radioInfo->numParameters; i++) {
        pList[i].value = returnValues[returnValueIndex];
        returnValueIndex++;
    }
    for(size_t i = 0; i < radioInfo->numUtilities; i++) {
        uList[i].value = returnValues[returnValueIndex];
        returnValueIndex++;
    }
    for(size_t i = 0; i < radioInfo->numObservables; i++) {
        oList[i].value = returnValues[returnValueIndex];
        returnValueIndex++;
    }
    returnValues[returnValueIndex] = 0;

    string allNames[numberColumns];
    size_t allNameIndex = 0;
    for(size_t i = 0; i < radioInfo->numParameters; i++) {
        allNames[allNameIndex] = pList[i].name;
        allNameIndex++;
    }
    for(size_t i = 0; i < radioInfo->numUtilities; i++) {
        allNames[allNameIndex] = uList[i].name;
        allNameIndex++;
    }
    for(size_t i = 0; i < radioInfo->numObservables; i++) {
        allNames[allNameIndex] = oList[i].name;
        allNameIndex++;
    }
    allNames[allNameIndex] = "TotalWeight";

    // Add row to CBR. 
    myCBR1->AddRow(allNames, returnValues, returnValueIndex + 1);
    myCBR2->AddRow(allNames, returnValues, returnValueIndex + 1);       
        } else {
        LOG("Cognitive Engine:: Search return an invalid value.\n");
    }

    return pList;
}


void 
CBR_CE::ReceiveFeedback(Observable *observables, Parameter *parameters, Utility *utilities)
{ 
    LOG("Cognitive Engine:: Receiving feedback.\n");
    
    uint32_t numberColumns = radioInfo->numParameters + radioInfo->numUtilities + radioInfo->numObservables + 1;

    uint32_t whereLen = radioInfo->numParameters;
    uint32_t setLen = radioInfo->numUtilities + radioInfo->numObservables + 1;


    float whereValue[whereLen];
    float setValue[setLen];
    string whereList[whereLen];
    string setList[setLen];


// Calculating total weight
        float TotalWeight = 0;
        int Penalty = 100;

    for(size_t i = 0; i < radioInfo->numParameters; i++) {
        whereList[i] = parameters[i].name;
        whereValue[i] = parameters[i].value;
        TotalWeight += parameters[i].value*(optList->Pweights[i]);
    }

    size_t returnValueIndex = 0;
    for(size_t i = 0; i < radioInfo->numUtilities; i++) {
        setList[returnValueIndex] = utilities[i].name;
        setValue[returnValueIndex] = utilities[i].value;
        if ((utilities[i].value > uList[i].target && uList[i].goal == "max") || (utilities[i].value < uList[i].target && uList[i].goal == "min")) 
                TotalWeight += abs(utilities[i].value - uList[i].target)*(optList->Uweights[i]);
        else
                TotalWeight += abs(utilities[i].value - uList[i].target)*(optList->Uweights[i])*Penalty;   
        returnValueIndex++;
    }
    for(size_t i = 0; i < radioInfo->numObservables; i++) {
        setList[returnValueIndex] = observables[i].name;
        setValue[returnValueIndex] = observables[i].value;
        returnValueIndex++;
    }
        setList[returnValueIndex] = "TotalWeight";
        setValue[returnValueIndex] = TotalWeight; 
/////
        
myCBR1->Update(whereList,setList,whereValue,setValue,whereLen,setLen);

// MAIN SELF LEARNING CODE HERE //

int searchOps[radioInfo->numParameters];
string searchNames[radioInfo->numParameters];
float searchVals[radioInfo->numParameters];
float returnValues[numberColumns];


for (int L = 0; L < radioInfo->numParameters ; L++) { 
   searchOps[L] = 0;
   searchNames[L] = parameters[L].name;
   searchVals[L] = parameters[L].value;
}


for (int lp = 0; lp < radioInfo->numParameters; lp++ ) {

   searchOps[lp] = (optList->Slope[lp] == -1)?2:4;   

   uint32_t rc = myCBR1->Search(searchNames, searchOps, searchVals,radioInfo->numParameters, returnValues);
  if(rc == 0) {
        std::cout << "case found for learning for parameter : " << lp << std::endl; 

///////////
        
                std::cout << "CASE STUDY" << std::endl;
                std::cout << "returnvalue ber " << returnValues[radioInfo->numParameters] << std::endl;
                std::cout << "BER current value " << utilities[0].value << std::endl;
                
        

/////////

    for (int ul = 0; ul < radioInfo->numUtilities; ul++) {
        int rl = radioInfo->numParameters + ul;
        if( abs(1 - returnValues[rl]/utilities[ul].value) > optList->PoC ) {
            if(optList->Trend[lp][ul] == 0.0) {

                if ((returnValues[rl] > utilities[ul].value) && optList->Status[lp][ul] >= 0 ) {
                    optList->Status[lp][ul] += 1;
                } 
                else if ( ((returnValues[rl]) < utilities[ul].value) && optList->Status[lp][ul] <= 0) {
                    optList->Status[lp][ul] -= 1;
                }               
                else {
                    optList->Status[lp][ul] = 0;
                }
            
                if (abs(optList->Status[lp][ul]) > 2) {
                    optList->Trend[lp][ul] = signof(optList->Status[lp][ul]);
                }
            }
            else if ( optList->Trend[lp][ul] == 1 && (returnValues[rl] > utilities[ul].value) && optList->Status[lp][ul] >= 0 ) {
                    optList->Status[lp][ul] += 1;
            }
            else if ( optList->Trend[lp][ul] == -1 && (returnValues[rl] > utilities[ul].value) && optList->Status[lp][ul] <= 0) {
                    optList->Status[lp][ul] -= 1;
            }
            else {
                    optList->Status[lp][ul] = 0;
                    optList->Trend[lp][ul] = 0; 
            }



        }
    }
  }
  else if (rc == 31337) {   
         std::cout << "No case found for parameter: " << lp << std::endl; 
  }
   searchOps[lp] = 0;


}


// updating slope matrix..
// AS OF NOW VALID ONLY FOR ONE UTILITY 
    for (int i = 0; i < radioInfo->numParameters; i++) {
        if ( (uList[0].goal == "min" && optList->Trend[i][0] < 0) || (uList[0].goal == "max" && optList->Trend[i][0] > 0) ) {
           optList->Slope[i] = -1;
        }
        else if ( (uList[0].goal == "min" && optList->Trend[i][0] >= 0) || (uList[0].goal == "max" && optList->Trend[i][0] <= 0) ) {  
           optList->Slope[i] = 1;       
        }
    }

   std::cout << "Ptune " << optList->Ptune << std::endl;
   std::cout << "Status1 " << optList->Status[0][0] << std::endl;
   std::cout << "Status2 " << optList->Status[1][0] << std::endl;
   std::cout << "Slope1 " << optList->Slope[0] << std::endl;
   std::cout << "Slope2 " << optList->Slope[1] << std::endl;
   std::cout << "Trend1 " << optList->Trend[0][0] << std::endl;
   std::cout << "Trend2 " << optList->Trend[1][0] << std::endl;

 /// end of MAIN CODE //


}

void
CBR_CE::BuildCognitiveEngine()
{
    string filename = "exdb";
    string tablename1 = "data1";
    string tablename2 = "data2";

        //// NEW SET OF VARIABLES ///

        optList->Uweights = new float[radioInfo->numUtilities];
        optList->Pweights = new float[radioInfo->numParameters];
        optList->Slope = new int[radioInfo->numParameters];

///// we have to assume 10 utilities maxxx!!!! VERY important

        optList->Status = new float[radioInfo->numParameters][10];
        optList->Trend = new float[radioInfo->numParameters][10];
//////////////////////////////////////////////////////////////  


////////////initializing Opt_List members here/////

        optList->PoC = 0.01;
        optList->Ptune = 0; // starting with most tunable parameter.. (widest range .. )

        for (int x = 0; x < radioInfo->numParameters; x++) {
                optList->Pweights[x] = 1/(pList[x].step);
                optList->Slope[x] = 1;
        }



        for (size_t i = 0; i < radioInfo->numUtilities; i++) {
                optList->Uweights[i] = 10;
        }


        for (size_t i = 0; i < radioInfo->numParameters; i++) {
                for (size_t k = 0; k < radioInfo->numUtilities; k++) {
                        optList->Status[i][k] = 0;
                        optList->Trend[i][k] = 0;
                }
        }
////////////////////////////////////////////////////////////////////////




    uint32_t numberColumns = radioInfo->numParameters + radioInfo->numUtilities \
                             + radioInfo->numObservables + 1;

    string cols[numberColumns];
    size_t columnIndex = 0;


    for (size_t i = 0; i < radioInfo->numParameters; i++){
        cols[columnIndex] = pList[i].name;
        columnIndex++;
    }
    for (size_t i = 0; i < radioInfo->numUtilities; i++){
        cols[columnIndex] = uList[i].name;
        columnIndex++;
    }      
    for (size_t i = 0; i < radioInfo->numObservables; i++){   
        cols[columnIndex] = oList[i].name;
        columnIndex++;
    }
    cols[columnIndex] = "TotalWeight";  

    myCBR1 = new CBR(filename, tablename1, cols, numberColumns);        

    myCBR2 = new CBR(filename, tablename2, cols, numberColumns);        


}


void 
CBR_CE::PerformUpdatePerformance()
{

    /* Receive Set of current Parameters */
    char buffer[256];
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD, buffer);
    uint32_t numParameters = atoi(buffer);

    Parameter *p = new Parameter[numParameters];

    for(size_t i = 0; i < numParameters; i++) {
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        p[i].name = std::string(buffer);

        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        p[i].value = atof(buffer);
    } 


    /* Receive Set of Observables */
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD, buffer);
    uint32_t numObservables = atoi(buffer);

    Observable *o = new Observable[numObservables];

    for(size_t i = 0; i < numObservables; i++) {
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        o[i].name = std::string(buffer);

        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        o[i].value = atof(buffer);
    }


    /* Receive Set of Utilities */
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD, buffer);
    uint32_t numUtilities = atoi(buffer);
    
    Utility *u = new Utility[numUtilities];

    for(size_t i = 0; i < numUtilities; i++) {
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        u[i].name = std::string(buffer);
        
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        u[i].value = atof(buffer);
    }
 
    ReceiveFeedback(o, p, u);

    delete [] o;
    delete [] p;
    delete [] u;
}


void
CBR_CE::PerformRequestOptimization()
{
    /* Receive Set of Observables */
    LOG("\nCognitive Engine:: Receiving Observables\n");

    char buffer[256];
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD,buffer);
    uint32_t numObservables = atoi(buffer);

    Observable *o = new Observable[numObservables];

    for(size_t i = 0; i < numObservables; i++) {
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        o[i].name = std::string(buffer);

        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        o[i].value = atof(buffer);
    }  

    /* Receive Set of current Parameters */
    LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n");

    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD, buffer);
    uint32_t numCurrentParameters = atoi(buffer);

    Parameter *cp = new Parameter[numCurrentParameters];

    for(size_t i = 0; i < numCurrentParameters; i++) {
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        cp[i].name = std::string(buffer);

        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        cp[i].value = atof(buffer);
    }

    /* Receive Set of Utilities */
    LOG("Cognitive Engine:: Receiving Utilities\n");

    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD, buffer);
    uint32_t numUtilities = atoi(buffer);

    Utility *u = new Utility[numUtilities];

    for(size_t i = 0; i < numUtilities; i++) {
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        u[i].name = std::string(buffer);

        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        u[i].value = atof(buffer);
    }



  
    LOG("Cognitive Engine:: Processing parameters....\n");

    Parameter *solutionSet;
    
    solutionSet = GetSolution(o,cp,u);

 
   
    LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n");
    char numParametersChar[10];
    char solutionValue[50];
    sprintf(numParametersChar, "%i", radioInfo->numParameters);
    SendMessage(commandSocketFD, numParametersChar);
    for(size_t i = 0; i < radioInfo->numParameters; i++) {
        SendMessage(commandSocketFD, solutionSet[i].name.c_str());
        memset(solutionValue, 0, 50);
        sprintf(solutionValue, "%f", solutionSet[i].value);
        SendMessage(commandSocketFD, solutionValue);
    }

    delete [] o;
    delete [] cp;
    delete [] u;
}


void
CBR_CE::PerformResetEngineCognitive()
{
    Reset();
}


void
CBR_CE::PerformShutdownEngineCognitive()
{
    Shutdown();
}

void
CBR_CE::FineTune()
{

        std::cout << "UNDER DEVELOPMENT" << std::endl;

}