---

VowelClassifier.h

/* VowelClassifier.h
 *
 * Copyright (C) 2002-2003 -- Sebastian Nowozin
 */

#ifndef VOWELCLASSIFIER_H
#define VOWELCLASSIFIER_H

#include <vowel/VowelSample.h>
#include <neuralnet/PerceptronNetwork.h>
#include <neuralnet/RandomFunction.h>

#include <vector>
#include <map>
#include <fstream>


typedef struct {
        vector<double>          vstat;

        vector<vector<double> > net_result;

        VowelSampleType         guessed_type;
} VowelClassification;


typedef struct {
        vector<unsigned int>    net1;
        vector<unsigned int>    net2;
        vector<unsigned int>    net3;
} VowelClassifierLayout;


typedef struct {
        double  epsilon;

        double  optimal_tolerance;

        double  weight_decay;

        double  momentum_term;
} VowelClassifierLearnParams;



class
VowelClassifier {
public:
        static vector<double> correct_results[3][(VowelSampleType) Unknown + 1];

        VowelClassifier (unsigned int input_dim,
                const VowelClassifierLayout *layout);


        /* Default constructor. (To be used with the load method).
         */
        VowelClassifier (void);

        ~VowelClassifier (void);

        VowelClassifier (VowelClassifier& source);

        /* LOAD/SAVE methods */

        bool load (fstream& fs);

        void save (fstream& fs) const;

        VowelClassification classifyVowel (const VowelSample *input);

        void learnVowel (const VowelSample *input);

        void updateLearned (void);

        void resetLearned (void);

        void setLearningParameters (VowelClassifierLearnParams params);

        VowelClassifierLearnParams getLearningParameters (void) const;

        const char *getExpertName (unsigned int expert_number);

        void randomizeExpert (unsigned int expert);

        void setRandomizationParameters (unsigned int expert,
                double weight_low, double weight_high,
                double theta_low, double theta_high);

        bool setActivationFunction (unsigned int expert_number,
                PerceptronLayerType type, const char *fact_name);

        PerceptronNetwork * getNetwork (unsigned int expert_number) const;

private:

        vector<double> getExpertResults (PerceptronNetwork *exp,
                vector<double> in);

        void singleExpertLearn (PerceptronNetwork *exp, vector<double> input,
                vector<double> optimal);

        PerceptronNetwork *     nn_a_ou_ei;

        PerceptronNetwork *     nn_o_u_aei;

        PerceptronNetwork *     nn_e_i_aou;

        VowelClassifierLearnParams      lpar;

        vector<RandomInterval>  weight_initializations;

        vector<RandomInterval>  theta_initializations;

        /* STATIC elements */

        struct VScompare {
                bool operator () (const VowelSampleType s1,
                        const VowelSampleType s2) const
                {
                        return (s1 < s2);
                }
        };

        void initializeCorrectResults (void);
};



#endif

---