name: NeuralNetwork

synopsis:


g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_pr.a

#include <NeuralNetwork.h>

boolean setEpochs(long arg);
long getEpochs();
boolean setLearningRate(float arg);
float getLearningRate();
boolean setMomentum(float arg);
float getMomentum();
boolean setBias(float arg);
float getBias();
boolean init(long epochs, long units, long layers = DEF_HIDDEN_LAYERS, float bias = DEF_BIAS, float rate = DEF_ETA, float momentum = DEF_MOMENTUM);
boolean loadFeatures(String& arg);
boolean loadOutputs(String& arg);
boolean loadTestFeatures(String& arg);
boolean loadTestOutputs(String& arg);
boolean train(String& train, String& output, String& model);
boolean test(String& model, String& test, String& output);
boolean writeModel(String& arg);

quick start:


none.

description:

A class that implements a massively distributed processor made up of simple processing units, which has a natural propensity for storing experiential knowladge and making it available for use.

References:

[1] Elaine, Rich and Knight, "Artificial Intelligence", Second Edition, McGraw Hill, New York, 1991.

[2] S. Haykin, "Neural Networks", Second Edition, Prentice Hall, New Jersey, 1999.

dependencies:

public constants:

define class name:
```
static const String CLASS_NAME;
```

define i/o constants:

static const String DEF_PARAM;

static const String DEF_COMMENT_TAG;

define public constants:

static const float DEF_ETA = 0.35;

static const float DEF_BIAS = 1.0;

static const float DEF_MOMENTUM = 0.1;

static const long DEF_EPOCHS = 1;

static const long DEF_HIDDEN_UNITS = 1;

static const long DEF_HIDDEN_LAYERS = 1;

Vector<VectorFloat> features_d;

Vector<VectorFloat> outputs_d;

Vector<VectorFloat> test_features_d;

Vector<VectorFloat> test_outputs_d;

error codes:

none.

protected data:

declare the debugging parameters:
```
static Integral::DEBUG debug_level_d;
```
declare the memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:
```
static const String& name();
```

debug methods:

static boolean diagnose(Integral::DEBUG debug_level);

static boolean setDebug(Integral::DEBUG level);

boolean debug(const unichar* msg) const;

destructor/constructor(s):

~NeuralNetwork();

NeuralNetwork();

NeuralNetwork(const NeuralNetwork& arg);

assign methods:

boolean assign(const NeuralNetwork& copy_node);

operator= method:

NeuralNetwork& operator= (const NeuralNetwork& arg);

i/o methods:
```
not present.
```
equality methods:
```
not present.
```

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE cmode = Integral::DEF_CMODE);

class-specific public methods:

declare class specific methods:

boolean setEpochs(long arg);

long getEpochs();

boolean setLearningRate(float arg);

float getLearningRate();

boolean setMomentum(float arg);

float getMomentum();

boolean setBias(float arg);

float getBias();

boolean init(long epochs, long units, long layers = DEF_HIDDEN_LAYERS, float bias = DEF_BIAS, float rate = DEF_ETA, float momentum = DEF_MOMENTUM);

boolean loadFeatures(String& arg);

boolean loadOutputs(String& arg);

boolean loadTestFeatures(String& arg);

boolean loadTestOutputs(String& arg);

boolean train(String& train, String& output, String& model);

boolean test(String& model, String& test, String& output);

boolean writeModel(String& arg);

private data:

declare private data:

float bias_d;

float eta_d;

float momentum_d;

long epochs_d;

MatrixFloat w1_d;

MatrixFloat w2_d;

Vector<MatrixFloat> h1_d;

Vector<VectorFloat> hidden_layers_d;

VectorFloat input_layer_d;

VectorFloat output_layer_d;

examples:

none.

notes:

none.