machine.h

Go to the documentation of this file.

/*

Copyright (c) 2003, Cornell University
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

   - Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.
   - Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
   - Neither the name of Cornell University nor the names of its
       contributors may be used to endorse or promote products derived from
       this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.

*/

// -*- C++ -*-

#if !defined(_CLUS_MACHINE_H)
#define _CLUS_MACHINE_H

#include "general.h"
#include "vec.h"
#include "normaliz.h"
#include <stdlib.h>
#include "traingen.h"
#include "filter.h"
#include <fstream>
#include <string>
#include <iostream>
#include <iomanip>
#include <stdio.h>

#ifdef CLUS_USE_XML
#include "xml.h"
#endif

extern Vector<double> DummyVector;

using namespace TNT;

namespace CLUS
{

class Machine;

/// this function constructs a machine when given a list of its parameters
Machine* MachineFactory(int nrpar,...);

/// this function constructs a machine when given it's definition file
Machine* MachineFactory(char* filename);

/** Every machine has an input vector, an output one and a real output one
    should provide a constructor from file.
    A constructor of the form Cons(int nrpar, int* pararray) and one of the form
    Cons(FILE* filename, int inDim, int outDim) 
 */
class Machine : public Filter
{
protected:
    Subscript            maxIter;
    double               convergenceLim, Criterion;
    Vector<Scale>        scale;
    TrainingData*        training;
    TrainingData*        pruning;
    char*                savePattern;
    char*                saveInferPattern;
    int                  inDim, outDim;

    /// number of subparts
    int                  N; 

    virtual double IdentifyStep(int iter)
    {
        return 0.0;
    }
public:
    Machine():Filter(),scale()
    {}
    ;

    Machine(Subscript InDim, Subscript OutDim, Vector<double>* Input=NULL):
            Filter(Input, OutDim), scale(InDim+OutDim), inDim(InDim), outDim(OutDim)
    {
        maxIter=30;
        convergenceLim=1.0e-4;
        savePattern=NULL;
        saveInferPattern=NULL;
    }

    /// Get the number of input dimensions
    virtual int InDim(void)
    {
        return inDim;
    }

    /// Get the number of output dimensions
    int OutDim(void)
    {
        return outDim;
    }

    /// Do the inference
    virtual void Infer(void)
    {}
    ;

    /// Process more data for the epoch
    virtual bool Tick(void)
    {
        Infer();
        return true;
    }

    /// Use the training data to learn a new structure
    virtual void Identify(void)
    {
        if (training!=NULL)
        {
            int iter;
            double err=0;
            //   cerr << "MaxIter=" << maxIter << ", ConvLim=" << convergenceLim << endl;

            for (iter=0; iter<maxIter && (err=IdentifyStep(iter))>convergenceLim; iter++)
            {
                cout << iter << " " << N << " " << err << "  " << setprecision(8) << Criterion << endl;
                if (savePattern!=NULL)
                {
                    char filename[256];
                    sprintf(filename,savePattern,iter);
                    SaveToFile(filename);
                }
            }

            // if it stopped because of convergence limit print the information
            if (iter<maxIter)
                cout << iter << " " << N << " " << err << "  " << setprecision(8) << Criterion << endl;

            // save the last machine
            if (savePattern!=NULL && iter<=maxIter)
            {
                char filename[256];
                sprintf(filename,savePattern,iter);
                SaveToFile(filename);
            }
        }
    }

    /// Prune the structure
    virtual void Prune(void)
    { }

    /// @deprecated
    virtual double FindBestParameter(char* name)
    {
        return 0.0;
    }

    /// Set the training data for this machine
    ///
    /// @param Training
    inline void SetTrainingData(TrainingData* Training)
    {
        training=Training;
    }

    /// Set the pruning data for this machine
    ///
    /// @param Pruning
    void SetPruningData(TrainingData* Pruning)
    {
        pruning=Pruning;
    }

    /// Scale the training data
    ///
    /// @param type          interval or distribution
    inline void ScaleData(Scale::NormType type)
    {
        if (training!=NULL)
            training->Normalize(scale, type, inDim);
        else
            throw ErrMsg("No training data and scaling atempted");

    }

    const Vector<Scale>& GetScaleFactors(void) const
    {
        return scale;
    }

    /// @deprecated
    virtual void GenerateStructure(string Type)
    {}

    /// Output the structure data to a file
    ///
    /// @param filename      name of save file
    inline void SaveToFile(char* filename)
    {
        ofstream ostr(filename);
        SaveToStream(ostr);
    }

    /// Output the structure data to a stream
    ///
    /// @param out           stream for output
    virtual void SaveToStream(ostream &out)
    {}

#ifdef CLUS_USE_XML

    void SaveXmlToFile(char* filename)
    {
        ofstream ostr(filename);
        PrintToXmlStream(ostr);
    }

    virtual void PrintToXmlStream(ostream &output)
    {
        output << "<Machine";
        PrintAttribute(output, "maxIter", maxIter);
        PrintAttribute(output, "convergenceLim", convergenceLim);
        PrintAttribute(output, "inDim", inDim);
        PrintAttribute(output, "outDim", outDim);
        output << ">" << endl;
        // save scale;
        output << "</Machine>" << endl;

    }

#endif

    /// Get the type of this object
    ///
    /// @return              name of object type as a string
    virtual string TypeName(void)
    {
        return string("Machine");
    };

    /// @deprecated
    virtual bool SetOptionOnComponents(char* optName,double value)
    {
        return false;
    };

    /// Set an option for the machine
    ///
    /// @param name          name of option to be set
    /// @param val           value of option
    virtual int SetOption(char* name,char* val)
    {
        if (strcmp(name,"MaxIter")==0)
            maxIter=atoi(val);
        else if (strcmp(name,"ConvergenceLimit")==0)
            convergenceLim=atof(val);
        else if (strcmp(name,"SavePattern")==0)
        {
            if (savePattern!=NULL)
                free(savePattern);
            if (val!=NULL)
            {
                savePattern=(char*)malloc(strlen(val)+1);
                strcpy(savePattern,val);
            }
            else
                savePattern=NULL;
        }
        else if (strcmp(name,"SaveInferPattern")==0)
        {
            if (saveInferPattern!=NULL)
                free(saveInferPattern);
            if (val!=NULL)
            {
                saveInferPattern=(char*)malloc(strlen(val)+1);
                strcpy(saveInferPattern,val);
            }
            else
                saveInferPattern=NULL;
        }
        else
            return 0;
        return 1;
    }
};

}


#endif    /* _MACHINE_H */

---