После запуска исполняемого файла "faces1. exe" можно использовать демо в двух режимах: автоматический и ручной.

Автоматический демо-режим

ORL базы данных лиц (www.cam-orl. co. uk/facedatabase.html) должны быть размещены в каталоге "\ orl_faces" в той же папке с программой файл "faces1. exe". Для запуска демо выбрать из меню "Демо", а затем "Пуск". В начале появляется форма с установочными параметрами:

Можно выбрать один из трех вариантов обработки изображений:

· Уменьшение размерности изображений лиц с помощью рециркуляционной нейронной сети.

· Распознавание лиц в пространстве с низким разрешением

· Распознавания лиц с помощью нейронных сетей (многослойный перцептрон)

Также можно использовать вручную загружаемые базы данных вместо базы данных лиц ORL. Чтобы сделать это, следует отметить опцию "Use manually loaded face database”.

Start Slideshow immediately: в этом режиме одновременно после запуска демо обучается нейронная сеть и начинается слайд-шоу. Каждый слайд представляет пример обучения нейронной сети, общую ошибку распознавания или пример реконструкции. Изображения лица выбирается случайным образом. При первом запуске выбор может происходить как из множества обучения, так и из множества тестирования, в дальнейшем же - только из обучающего множества.

Параметр "Pause between slides" позволяет настроить время между показом слайдов. Слайд, показывающий результат обучения нейронной сети (распознавание или ошибку), будет загружаться в десять раз дольше, чем остальные.

Параметр "Number of slides for new neural work training " позволяет установить количество слайдов, после показа которых будет сделан новый тестовый набор и нейронная сеть будет обучаться повторно.

Для запуска нажмите "ОК". Появится рабочая форма:

"Train Network": запуск процесса обучения сети. После завершения процесса обучения эта кнопка будет переименована в "Recognise" или "Reconstruct" в зависимости от режима.

"Start/Stop Slideshow" позволяет прервать или возобновить показ слайдов.

Уменьшение размерности изображений лиц с помощью рециркуляционной нейронной сети

Демонстрация метода изменения размерности изображения. В пространстве изображения-источника образуется N-мерный вектор, в котором каждое измерение представлено соответствующим пикселем, и яркость пикселя определяет положение на оси измерения. N равно количеству пикселей в изображении.

Сжатие изображения и реконструкция выполняются с помощью рециркуляционной нейронной сети (РНН). Преимуществом такого подхода является то, что процесс обучения РНН довольно быстрый и не имеет проблем, присущих при решении матричных уравнений.

Распознавание лиц в пространстве с низким разрешением

Демонстрация распознавания лиц на изображениях с низким разрешением. В предыдущем примере происходит сокращение размера изображения, и новое M-мерное пространство формируется на выходе м скрытых единиц РНН. Каждая единица соответствует оси в ограниченном пространстве, а значение стоимости выхода - позиции по этой оси.

Процесс распознавания предварительно вычисляет евклидово расстояние в пространстве с низким разрешением неизвестного изображения до всех изображений обучающего множества. Изображение с минимальным расстоянием рассматривается как ближайшее и указывает на принадлежность к классу.

Распознавание лиц с помощью нейронных сетей (многослойный перцептрон)

Демонстрация способности многослойного персептрона (MLP) к распознаванию лиц. Входными данными для MLP являются яркость всех пикселей изображения и количество входных единиц, равное числу пикселей. Количество выходных единиц соответствует числу классов. Каждая единица выхода дает значение "+1" для своего класса и "-1" для всех остальных классов. После обучения все выходные единицы будут в диапазоне [-1; +1].

Выбор класса с самым высоким значением соответствующих ему выходных единиц означает принадлежность изображения этому классу.

Заключение

#include <stdio. h>

#include <math. h>

#include <stdlib. h>

#include "fclass. h"

#define N 12000 /* Max number of units allowed in net */

#define SIGMOID 1 /* Unit_type is SIGMOID with output = +0.5 to - 0.5 */

#define ASYMSIGMOID 2 /* ASYMSIGMOID with output = 0.0 to 1.0 */

/* Global variables */

int Epoch; /* Current epoch number */

float WeightRange; /* Random-init weights in range [-WR,+WR] */

float SigmoidPrimeOffset; /* Add to sigmoid-prime to kill flat spots */

int HyperErr; /* 1 => use atanh error function */

int SplitEpsilon; /* 1 => divide epsilon by fan-in before use */

float Epsilon; /* For grad descent if last step was (almost) 0 */

float Momentum; /* Normal old momentum term */

float ModeSwitchThreshold; /* Inside thresh, do grad descent; outside, jump. */

float MaxFactor; /* Don't jump more than this times last step */

float Decay; /* Weight decay */

int SinglePass; /* 1 => Pause after forward/backward cycle */

int SingleEpoch; /* 1 => Pause after each training epoch */

int Step; /* Turned to 1 after each pause, briefly */

int Restart; /* 1 => restart when max epochs reached */

int KeepScore; /* 1 => accumulate error score for each epoch */

float TotalError; /* Total output error for one epoch */

float ScoreThreshold; /* This close to desired value => bit is correct */

int TotalErrorBits; /* Total # bits in epoch that were wrong */

int DidGradient; /* Total # patterns that did gradient descent */

int Nunits; /* Total number of units in net */

int Ninputs; /* Number of input units */

int FirstHidden; /* Index of 1st hidden unit */

int Nhidden; /* Number of hidden units */

int FirstOutput; /* Index of 1st output unit */

int Noutputs; /* Number of output units */

int Unit_type; /* Type of hidden and Output Units: 1=> SIGMOID,and

2 => ASYMSIGMOID */

float Outputs [N]; /* Final output value for each unit */

float ErrorSums [N]; /* Total error activation for each unit */

float Errors [N]; /* Final error value for each unit */

int Nconnections [N]; /* # of INCOMING connections per unit */

// int Connections [N] [N]; /* C [i] [j] lists jth unit projecting to unit i */

// float Weights [N] [N]; /* W [i] [j] holds weight of C [i] [j] */

// float DeltaWeights [N] [N]; /* Change between previous weight and current one */

// float Slopes [N] [N]; /* Accumulated slope value for each position */

// float PrevSlopes [N] [N]; /* Similarly, for the last position visited */

int *Connections [N]; /* C [i] [j] lists jth unit projecting to unit i */

float *Weights [N]; /* W [i] [j] holds weight of C [i] [j] */

float *DeltaWeights [N]; /* Change between previous weight and current one */

float *Slopes [N]; /* Accumulated slope value for each position */

float *PrevSlopes [N]; /* Similarly, for the last position visited */

int NTrainingPatterns; /*!! Not in Lisp version. Needed here. */

int NTestPatterns; /*!! Not in Lisp version. Needed here. */

#define MAX_PATTERNS200

float *TrainingInputs [MAX_PATTERNS];

float TrainingOutputs [MAX_PATTERNS] [N];

float *TestInputs [MAX_PATTERNS];

float TestOutputs [MAX_PATTERNS] [N];

float tinputs [N]; /* Input vector to be tested. */

GET_NETWORK_CONFIGURATION (char fname []);

DUMP_WEIGHTS (char fname []);

GET_WEIGHTS (char fname []);

INITIALIZE_GLOBALS ();

BUILD_DATA_STRUCTURES (int ninputs, int nhidden, int noutputs);

float RANDOM_WEIGHT (float range);

CONNECT_LAYERS (int start1, int end1, int start2, int end2);

INIT_WEIGHTS ();

CLEAR_SLOPES ();

float ACTIVATION (float sum);

float ACTIVATION_PRIME (float value);

float ERRFUN (float desired, float actual);

FORWARD_PASS (float input []);

BACKWARD_PASS (float goal []);

UPDATE_WEIGHTS ();

TRAIN_ONE_EPOCH ();

TRAIN (int times);

TEST ();

extern CFaceDB facedb;

extern CFaceImg faceimg;

extern CClassSet<float> fraw;

extern float w_input_scale;

main ()

{

long seed;

long lrand48 ();

int i, j, epox, response;

float RANDOM_WEIGHT ();

char fname [80];

/* Start up the random number generator */

// printf ("Enter seed for random number generator: ");

// scanf ("%d", &seed);

srand (time (0));

INITIALIZE_GLOBALS ();

/* Get network */

// printf ("Enter name of network: ");

// scanf ("%s", fname);

GET_NETWORK_CONFIGURATION (fname);

/* printf ("Want to retrieve old weights [0=>no, 1=>yes]?");

scanf ("%d", &response);

if (response)

GET_WEIGHTS (fname);

*/

/* Train the sucker. */

// epox = 34;

// while (epox! = 0)

{

printf ("Enter number of epochs to train: ");

scanf ("%d", &epox);

if (epox! = 0)

TRAIN (epox);

}

/* Test the sucker. */

/* printf ("Want to test [0=>no, 1=>yes]?");

scanf ("%d", &response);

if (response! = 0) */

TEST ();

printf ("done");

getchar ();

getchar ();

/* printf ("Want to dump weights [0=>no, 1=>yes]?");

scanf ("%d", &response);

if (response)

DUMP_WEIGHTS (fname);

*/}

/*

* Get and initialize a network.

*/

GET_NETWORK_CONFIGURATION (char fname [])

{

facedb. pfi = &faceimg;

// facedb. dbtype = 0;

// facedb. scale = 2;

// facedb. division = 6;

facedb. dbtype = dbBMP;

facedb. scale = 0;

facedb. division = 6;

facedb. load ("C: \\_Temp\\Projects\\faces1\\norm_orl_faces_hb\\");

facedb. set_division_percentage ();

facedb. divide_whole_set ();

float w_temp_scale;

switch (facedb. scale)

{

case 0: w_temp_scale = 6400; break;

case 1: w_temp_scale = 2560; break;

case 2: w_temp_scale = 1280; break;

case 3: w_temp_scale = 640; break;

}

w_input_scale = w_temp_scale;

facedb. input_type = 1;

facedb. calculate_input ();

BUILD_DATA_STRUCTURES (facedb. sample_size, 60, facedb. count);

const float PERFECT_OUTPUT = 0.5;

NTrainingPatterns = NTestPatterns = 0;

for (int i = 0; i < facedb. count; i++)

for (int j = 0; j < facedb [i]. count; j++)

if (facedb [i] [j]. training) {

TrainingInputs [NTrainingPatterns] = fraw [i] [j];

for (int k = 0; k < facedb. count; k++)

TrainingOutputs [NTrainingPatterns] [k] = k == i? +PERFECT_OUTPUT: - PERFECT_OUTPUT;

NTrainingPatterns++;

} else {

TestInputs [NTestPatterns] = fraw [i] [j];

for (int k = 0; k < facedb. count; k++)

TestOutputs [NTestPatterns] [k] = k == i? +PERFECT_OUTPUT: - PERFECT_OUTPUT;

NTestPatterns++;

}

/* // Connect layers.

fscanf (infile, "%s %d", junk [0], &connect);

for (i=0; i<connect; i++) // Reading CONNECT_LAYERS lines

{

fscanf (infile, "%d %d %d %d",

&temp [0], &temp [1], &temp [2], &temp [3]);

CONNECT_LAYERS (temp [0], temp [1], temp [2], temp [3]);

}

*/

CONNECT_LAYERS (1, Ninputs, Ninputs+1, Ninputs+Nhidden);

CONNECT_LAYERS (Ninputs+1, Ninputs+Nhidden, Ninputs+Nhidden+1, Ninputs+Nhidden+Noutputs);

/* Read in number of training patterns, then patterns themselves */

/* fscanf (infile, "%s %d", junk [0], &NTrainingPatterns);

for (i=0; i<NTrainingPatterns; i++)

{

for (j=0; j<Ninputs; j++)

fscanf (infile, "%f", &TrainingInputs [i] [j]);

for (j=0; j<Noutputs; j++)

fscanf (infile, "%f", &TrainingOutputs [i] [j]);

}

*/

/* Read in number of test patterns, then patterns themselves */

/* fscanf (infile, "%s %d", junk [0], &NTestPatterns);

for (i=0; i<NTestPatterns; i++)

{

for (j=0; j<Ninputs; j++)

fscanf (infile, "%f", &TestInputs [i] [j]);

for (j=0; j<Noutputs; j++)

fscanf (infile, "%f", &TestOutputs [i] [j]);

}

fclose (infile);

*/

}

/*

* Dump weights in the specified file.

*/

DUMP_WEIGHTS (char fname [])

{

FILE *outfile;

int i, j;

char realfname [80];

/* Dump weights */

sprintf (realfname, "%s. wts", fname);

outfile = fopen (realfname, "w");

for (i=0; i<N; i++)

for (j=0; j<N; j++)

if (Weights [i] [j]! = 0.0)

fprintf (outfile, "%d %d %f", i, j, Weights [i] [j]);

fprintf (outfile, "%d %d %f", - 1, - 1, - 1.0); /* Signal EOF */

fclose (outfile);

}

/*

* Get weights from the specified file.

*/

GET_WEIGHTS (char fname [])

{

FILE *infile;

int i, j;

float inweight;

char realfname [80];

/* Get weights */

sprintf (realfname, "%s. wts", fname);

infile = fopen (realfname, "r");

for (i=0; i<N; i++)

for (j=0; j<N; j++)

Weights [i] [j] = 0.0; /* Default weight */

i = 11; /* Arbitrary +ive */

while (i >= 0)

{

fscanf (infile, "%d %d %f", &i, &j, &inweight);

if (i >= 0)

Weights [i] [j] = inweight;

}

fclose (infile);

}

INITIALIZE_GLOBALS ()

{

Unit_type = SIGMOID;

Epoch = 0;

WeightRange = 0.7;

SigmoidPrimeOffset = 0.1;

HyperErr = 1;

SplitEpsilon = 1;

Epsilon = 0.55; /* 1.0 */

Momentum = 0.9; /* 0.0 */

ModeSwitchThreshold = 0.0;

MaxFactor = 1.75; /* 1.75 */

Decay = - 0.0001; /* - 0.0001 */

SinglePass = SingleEpoch = 0;

Step = KeepScore = 0;

Restart = 1;

TotalError = 0.0;

ScoreThreshold = 0.35;

TotalErrorBits = 0;

}

BUILD_DATA_STRUCTURES (int ninputs, int nhidden, int noutputs)

{

int i;

Nunits = 1 + ninputs + nhidden + noutputs;

Ninputs = ninputs;

FirstHidden = 1 + ninputs;

Nhidden = nhidden;

FirstOutput = 1 + ninputs + nhidden;

Noutputs = noutputs;

for (i=0; i<=Nunits; i++) Outputs [i] = 0.0;

for (i=0; i<=Nunits; i++) ErrorSums [i] = 0.0;

for (i=0; i<=Nunits; i++) Errors [i] = 0.0;

for (i=0; i<=Nunits; i++) Nconnections [i] = 0;

Outputs [0] = 1.0; /* The bias unit */

for (i = 0; i < Nunits; i++)

{

Connections [i] = new int [Nunits];

Weights [i] = new float [Nunits];

DeltaWeights [i] = new float [Nunits];

Slopes [i] = new float [Nunits];

PrevSlopes [i] = new float [Nunits];

}

}

/*

* Return a float between - range and +range.

*/

float RANDOM_WEIGHT (float range)

{

return ( (float) (range * (rand () %1000/500.0)) - range);

}

/*

* Build a connection from every unit in range1 to every unit in range2.

* Also add a connection from the bias unit (unit 0) to every unit in

* range2. Set up random weights on links.

*/

CONNECT_LAYERS (int start1, int end1, int start2, int end2)

{

int n, i, j, k;

Epoch = 0;

for (i=start2; i<=end2; i++)

{

if (Nconnections [i] == 0) {

Nconnections [i] += 1;

Connections [i] [0] = 0;

Weights [i] [0] = RANDOM_WEIGHT (WeightRange);

DeltaWeights [i] [0] = 0.0;

Slopes [i] [0] = 0.0;

PrevSlopes [i] [0] = 0.0;

k = 1;

}

else

k = Nconnections [i];

/*k = start1; Bug found by

Richard Dale Romero <rr2p+@andrew. cmu.edu> */

for (j=start1; j<=end1; j++) {

Nconnections [i] += 1;

Connections [i] [k] = j;

Weights [i] [k] = RANDOM_WEIGHT (WeightRange);

DeltaWeights [i] [k] = 0.0;

Slopes [i] [k] = 0.0;

PrevSlopes [i] [k] = 0.0;

k++;

}

}

}

/*

* For each connection, select a random initial weight between WeightRange

* and its negative. Clear delta and previous delta values.

*/

INIT_WEIGHTS ()

{

int i, j;

for (i=0; i<Nunits; i++)

for (j=0; j<Nconnections [i]; j++)

{

Weights [i] [j] = RANDOM_WEIGHT (WeightRange);

DeltaWeights [i] [j] = 0.0;

Slopes [i] [j] = 0.0;

PrevSlopes [i] [j] = 0.0;

}

}

/*

* Save the current slope values as PrevSlopes, and "clear" all current

* slopes (actually set to corresponding weight, decayed a bit).

*/

CLEAR_SLOPES ()

{

int i, j;

for (i=FirstHidden; i<Nunits; i++)

for (j=0; j<Nconnections [i]; j++)

{

PrevSlopes [i] [j] = Slopes [i] [j];

Slopes [i] [j] = (Decay * Weights [i] [j]);

}

}

/*

* Given the sum of weighted inputs, compute the unit's activation value.

* Defined unit types are SIGMOID and ASYMSIGMOID.

*/

float ACTIVATION (float sum)

{

switch (Unit_type) {

case SIGMOID:

/* Symmetrical sigmoid function in range - 0.5 to +0.5. */

if (sum < - 15.0)

return (-0.5);

else if (sum > 15.0)

return (0.5);

else

return (1.0 / (1.0 + exp (-sum)) - 0.5);

case ASYMSIGMOID:

/* asymmetrical sigmoid function in range 0.0 to 1.0. */

if (sum < - 15.0)

return (0.0);

else if (sum > 15.0)

return (1.0);

else

return (1.0/ (1.0+exp (-sum)));

}

}

/*

* Given the unit's activation value and sum of weighted inputs, compute

* the derivative of the activation with respect to the sum. Defined unit

* types are SIGMOID and ASYMSIGMOID.

*/

float ACTIVATION_PRIME (float value)

{

switch (Unit_type) {

case SIGMOID:

/* Symmetrical sigmoid function. */

return (SigmoidPrimeOffset + (0.25 - value*value));

case ASYMSIGMOID:

/* asymmetrical sigmoid function in range 0.0 to 1.0. */

return (SigmoidPrimeOffset + (value * (1.0 - value)));

}

}

/*

* Compute the error for one output unit.

* HyperErr==0 => use squared error.

* HyperErr==1 => use atanh.

*/

float ERRFUN (float desired, float actual)

{

float dif;

dif = desired - actual;

if (KeepScore)

{

TotalError += dif*dif;

if (fabs (dif) >= ScoreThreshold)

TotalErrorBits++;

}

if (HyperErr == 0) /* Not using atanh for error */

{

if ( (-0.1 < dif) && (dif < 0.1))

return (0.0);

else

return (dif);

}

else /* Using atanh for error */

{

if (dif < - .9999999)

return (-17.0);

else if (dif >.9999999)

return (17.0);

else

return (log ( (1.0+dif) / (1.0-dif)));

}

}

/*

* This is it, ya Habaayib: the forward pass in BP.

*/

FORWARD_PASS (float input [])

{

int i, j;

float sum;

/* Load in the input vector */

for (i=0; i<Ninputs; i++)

Outputs [i+1] = input [i];

/* For each unit, collect incoming activation and pass through sigmoid. */

for (j=FirstHidden; j<Nunits; j++)

{

sum = 0.0;

for (i=0; i<Nconnections [j]; i++)

sum += (Outputs [Connections [j] [i]] * Weights [j] [i]);

Outputs [j] = ACTIVATION (sum);

}

}

/*

* Goal is a vector of desired values for the output units. Propagate

* the error back through the net, accumulating weight deltas.

*/

BACKWARD_PASS (float goal [])

{

int i, j, cix; /* cix is "connection index" */

/* Compute error sums for output and other nodes */

for (i=FirstOutput; i<Nunits; i++) /*!! should it really be "<"? */

ErrorSums [i] = ERRFUN (goal [i-FirstOutput], Outputs [i]);

for (i=0; i<FirstOutput; i++)

ErrorSums [i] = 0.0;

/* Back-prop. When we reach a given unit in loop, error from all later

* units will have been collected.

*/

for (j=Nunits-1; j>=FirstHidden; j--)

{

Errors [j] = ACTIVATION_PRIME (Outputs [j]) * ErrorSums [j];

for (i=0; i<Nconnections [j]; i++)

{

cix = Connections [j] [i];

ErrorSums [cix] += (Errors [j] * Weights [j] [i]);

Slopes [j] [i] += (Errors [j] * Outputs [cix]);

}

}

}

/*

* Update all weights in the network as a function of each weight's current

* slope, previous slope, and the size of the last jump.

*/

UPDATE_WEIGHTS ()

{

int i, j;

float next_step, shrink_factor;

shrink_factor = MaxFactor / (1.0 + MaxFactor);

for (j=FirstHidden; j<Nunits; j++)

for (i=0; i<Nconnections [j]; i++)

{

next_step = 0.0;

if (DeltaWeights [j] [i] > ModeSwitchThreshold)

{ /* Last step was signif. +ive.. */

if (Slopes [j] [i] > 0.0) /* Add in epsilon if +ive slope */

next_step += (SplitEpsilon?

( (Epsilon * Slopes [j] [i]) / Nconnections [j]):

(Epsilon * Slopes [j] [i]));

/* If slope > (or close to) prev slope, take max size step. */

if (Slopes [j] [i] > (shrink_factor * PrevSlopes [j] [i]))

next_step += (MaxFactor * DeltaWeights [j] [i]);

else /* Use quadratic estimate */

next_step += ( (Slopes [j] [i] / (PrevSlopes [j] [i] - Slopes [j] [i]))

* DeltaWeights [j] [i]);

}

else if (DeltaWeights [j] [i] < - ModeSwitchThreshold)

{ /* Last step was signif. - ive. */

if (Slopes [j] [i] < 0.0) /* Add in epsilon if - ive slope */

next_step += (SplitEpsilon?

( (Epsilon * Slopes [j] [i]) / Nconnections [j]):

(Epsilon * Slopes [j] [i]));

/* If slope < (or close to) prev slope, take max size step. */

if (Slopes [j] [i] < (shrink_factor * PrevSlopes [j] [i]))

next_step += (MaxFactor * DeltaWeights [j] [i]);

else /* Use quadratic estimate */

next_step += ( (Slopes [j] [i] / (PrevSlopes [j] [i] - Slopes [j] [i]))

* DeltaWeights [j] [i]);

}

else /* Normal gradient descent, complete with momentum */

{

DidGradient++;

next_step += ( (SplitEpsilon?

( (Epsilon * Slopes [j] [i]) / Nconnections [j]):

(Epsilon * Slopes [j] [i]))

+ (Momentum * DeltaWeights [j] [i]));

}

/* Set delta weight, and adjust the weight itself. */

DeltaWeights [j] [i] = next_step;

Weights [j] [i] += next_step;

}

}

/*

* Perform forward and back propagation once for each pattern in the

* training set, collecting deltas. Then burn in the weights.

*/

TRAIN_ONE_EPOCH ()

{

int i;

CLEAR_SLOPES ();

for (i=0; i<NTrainingPatterns; i++)

{

FORWARD_PASS (TrainingInputs [i]);

BACKWARD_PASS (TrainingOutputs [i]);

}

UPDATE_WEIGHTS ();

Epoch++;

}

/*

* Train the network for the specified number of epochs, printing out

* performance stats every 10 epochs.

*/

TRAIN (int times)

{

int i, report;

report = 50;

for (i=0; i<times; i++)

{

if (Epoch % report == 0) /* Time to report status */

{

DidGradient = 0;

KeepScore = 1;

TotalError = 0.0;

TotalErrorBits = 0;

TRAIN_ONE_EPOCH ();

int ncorrect = 0;

for (int j = 0; j < NTestPatterns; j++)

{

int i;

for (i=0; i<Ninputs; i++)

tinputs [i] = TestInputs [j] [i];

FORWARD_PASS (tinputs);

float max = - 1;

int imax;

for (i = 0; i < Noutputs; i++)

if (Outputs [FirstOutput+i] > max)

{

imax = i;

max = Outputs [FirstOutput+i];

}

if (TestOutputs [j] [imax] > 0)

ncorrect++;

}

printf ("Epoch %d: %d Bits Wrong, Total Error = %f/%d, DidGradient = %d. \n",

(Epoch - 1), TotalErrorBits, TotalError, NTestPatterns-ncorrect, DidGradient);

KeepScore = 0;

}

else

TRAIN_ONE_EPOCH ();

}

}

TEST ()

{

int i,j;

tinputs [0] = 1.0; /* Initial nonzero value */

FILE * f = fopen ("log. txt", "wt");

int ncorrect = 0;

while (tinputs [0] >= 0.0)

{

/* printf ("Enter the %d input values [first one less than 0.0 => quit]: ",

Ninputs);

for (i=0; i<Ninputs; i++)

scanf ("%f", &tinputs [i]);

*/

for (j = 0; j < NTrainingPatterns; j++)

{

for (i=0; i<Ninputs; i++)

tinputs [i] = TrainingInputs [j] [i];

FORWARD_PASS (tinputs);

fprintf (f, "Output for training pattern %d is: ",j);

float max = - 1;

int imax;

for (i = 0; i < Noutputs; i++)

{

fprintf (f, "%f", Outputs [FirstOutput+i]);

if (Outputs [FirstOutput+i] > max)

{

imax = i;

max = Outputs [FirstOutput+i];

}

}

fprintf (f, " [%d] = %f/%f", imax, max, TrainingOutputs [j] [imax]);

fprintf (f, "\n");

// if (TrainingOutputs [j] [imax] > 0)

// ncorrect++;

}

fprintf (f, "\n");

for (j = 0; j < NTestPatterns; j++)

{

for (i=0; i<Ninputs; i++)

tinputs [i] = TestInputs [j] [i];

FORWARD_PASS (tinputs);

fprintf (f, "Output for test pattern %d is: ",j);

float max = - 1;

int imax;

for (i = 0; i < Noutputs; i++)

{

fprintf (f, "%f", Outputs [FirstOutput+i]);

if (Outputs [FirstOutput+i] > max)

{

imax = i;

max = Outputs [FirstOutput+i];

}

}

fprintf (f, " [%d] = %f/%f", imax, max, TestOutputs [j] [imax]);

fprintf (f, "\n");

if (TestOutputs [j] [imax] > 0)

ncorrect++;

}

tinputs [0] = - 0.5;

}

fprintf (f, "\n%d/%d", NTestPatterns-ncorrect, NTestPatterns);

fclose (f);

}

Размещено на Allbest.ru