예제 #1
0
        public static int[] ClusterWithART2a(double[,] trainingData)
        {
            //DataTools.WriteMinMaxOfFeatures(trainingData);
            //if (true) Console.ReadLine();

            //string paramsFpath = @"C:\etc";
            int trnSetSize = trainingData.GetLength(0);
            int F1Size = trainingData.GetLength(1);
            int F2Size = trnSetSize;
            int numberOfRepeats = 1;
            int maxIterations = 100;
            LoggedConsole.WriteLine("trnSetSize=" + trnSetSize + "  F1Size=" + F1Size + "  F2Size=" + F2Size);
            bool[] uncommittedJ = new bool[F2Size];               // : PtrToArrayOfBool;
            int[] noOfCommittedF2 = new int[numberOfRepeats];    // : array[1..MaxRepeatNo] of word;{# committed F2Neta units}
            int[] iterToConv = new int[numberOfRepeats];         // : array[1..MaxRepeatNo] of word;{for training only}

            int code = 0;        //        : word; {used for getting error messages}

            //{************************** INITIALISE VALUES *************************}

            //double[,] parameters = ART.ReadParameterValues(paramsFpath);
            //int simulationsCount = parameters.GetLength(0);
            //int paramCount = parameters.GetLength(1);
            int simulationsCount = 1;
            double alpha = 0.4;  //increasing alpha proliferates categories - 0.57 is good value
            double beta = 0.5;   //beta=1 for fast learning/no momentum. beta=0 for no change in weights
            double rho = 0.99;   //vigilance parameter - increasing rho proliferates categories
            double theta = 0.05; //threshold for contrast enhancing

            ART_2A art2a = new ART_2A(F1Size, F2Size);

            //{********** DO SIMULATIONS WITH DIFFERENT PARAMETER VALUES ***********}
            for (int simul = 0; simul < simulationsCount; simul++)
            {
                //pass the eight params for this run of ART2A - alpha, beta, c, d, rho, theta, add1, rhoStar
                art2a.SetParameterValues(alpha, beta, rho, theta);
                art2a.WriteParameters();

                //art2a.SetParameterValues(parameters[simul, 0], parameters[simul, 1], parameters[simul, 2], parameters[simul, 3],);
                //Console.ReadLine();

                //{********** DO REPEATS ***********}
                for (int rep = 0; rep < numberOfRepeats; rep++)
                {
                    //{********* RUN NET for ONE SET OF PARAMETERS for ALL ITERATIONS *********}
                    art2a.InitialiseArrays();
                    code = 0;
                    art2a.TrainNet(trainingData, maxIterations, simul, rep, code);

                    if (code != 0)
                    {
                        break;
                    }

                    noOfCommittedF2[rep] = art2a.CountCommittedF2Nodes();

                    //ScoreTrainingResults (noOfCommittedF2[rep], noClasses, F2classLabel, F2classProb);
                    //wtsFpath = ART.ARTDir + ART.wtsFname + "s" + simul + rep + ART.wtsFExt;
                    //art2a.WriteWts(wtsFpath, F2classLabel, F2classProb);
                    //if (DEBUG) LoggedConsole.WriteLine("wts= " + wtsFpath + "  train set= " + trnSetFpath);
                    LoggedConsole.WriteLine("Number Of Committed F2 Nodes after rep" + rep + " = " + noOfCommittedF2[rep]);
                } //end; {for rep   = 1 to norepeats do}       {***** END OF REPEATS *****}
            } //end; {for simul = 1 to noSimulationsInRun do}  {**** END OF SIMULATE *****}

            int[] keepScore = art2a.inputCategory;
            return keepScore;
        } //END of ClusterShapes.
예제 #2
0
        } //end;

        //public static bool ParamValuesOK(int versionID)
        //{
        //var
        //    bool AllOK = true;
        //    File ParamsF;   //    : text;
        //    double[] parameters = new double[MaxARTparamsNo]; // of real;
        //    int noValues;  //   : word;
        //    int simul, pn;  //  : word; // {parameter counter}
        //    char key;      //        : char;
        //    int i;         //:word;

        //    TextBackGround (1); //  {blue background}
        //    ClrScr;
        //    LoggedConsole.WriteLine;
        //    LoggedConsole.WriteLine ("  CHECKING PARAMETER VALUES for Net version ",ARTversion);
        //    LoggedConsole.WriteLine;

        //    assign (ParamsF, ParamsFPath);       // {prepare parameters file}
        //    reset  (ParamsF);
        //    readln (ParamsF, NoSimulationsInRun);

        //    for (int simul= 0; simul < noSimulationsInRun; simul++)
        //    {
        //        ReadParameterValues(noValues, ParamsF, parameters);
        //        LoggedConsole.WriteLine ("  Line "+simul+ " is OK");

        //        //if (noValues != MaxARTparamsNo-1 )
        //        //{
        //        //    for (pn = 1 to maxARTParamsNo-1)    //  {display all 8 parameter values}
        //        //    LoggedConsole.WriteLine ("  (",pn,") ",paramNames[versionID, pn]:10,"  = ",parameters[pn]:7:4);
        //        //    LoggedConsole.WriteLine;
        //        //    LoggedConsole.WriteLine ("  Fault in values for simulation ",simul);
        //        //    LoggedConsole.WriteLine ("  Must have exactly  ",maxARTparamsNo-1, " parameter values.");
        //        //    LoggedConsole.WriteLine ("  Press any key to return to main menu.");
        //        //    key = readkey;
        //        //    ParamvaluesOK = false;
        //        //    exit;
        //        //}  //end;

        //        //{make sure theta is less than 1/sqrM}
        //        //if  ((versionID != verFuzzyART)&& (versionID != verfuzzyARTMAP) )
        //        //    if (parameters[Theta] >= (1/Sqrt(F1SizeofNeta)) )  )
        //        //{
        //        //    parameters[Theta] = (1/Sqrt(F1SizeofNeta) - 0.01);
        //        //    //for (pn = 1 to maxARTParamsNo-1)  //{display first 7 parameter values}
        //        //    //LoggedConsole.WriteLine ("  (",pn,") ",paramNames[versionID, pn]:10,"  = ",parameters[pn]:7:4);
        //        //    LoggedConsole.WriteLine;
        //        //    LoggedConsole.WriteLine ("  Fault in values for simulation " + simul);
        //        //    LoggedConsole.WriteLine ("  Theta must be < 1/sqrtM ie 1/sqrt(F1size of net a)");
        //        //    LoggedConsole.WriteLine ("  Have automatically set  theta = 1/sqrtM - 0.01");
        //        //    LoggedConsole.WriteLine ("  Press any key to continue.");
        //        //    key = readkey;
        //        //}  //end;

        //        //{calc sigma and rho*}
        //        if (versionID == verART2a )
        //        {
        //            Sigma = (Params[c]*ARTParams[d]) / (1-ARTParams[d]);
        //            if (sigma > 1)
        //            {
        //                //for (pn = 1 to maxARTParamsNo-1)  //{display first 7 parameter values}
        //                //LoggedConsole.WriteLine ("  ("+pn+") "+paramNames[versionID, pn]:10+"  = "+parameters[pn]:7:4);
        //                LoggedConsole.WriteLine;
        //                LoggedConsole.WriteLine ("  Fault in values for simulation ",simul);
        //                LoggedConsole.WriteLine ("  Sigma = cd/1-d > 1.0. Choose proper values for c & d");
        //                LoggedConsole.WriteLine ("  Press any key to continue.");
        //                key = readkey;
        //                ParamvaluesOK = false;
        //                exit;
        //            }  //end;
        //        }  //end; {if verionsID = verART2a}

        //    }  //end; {for simul = 1 to noSimulationsInRun do}

        //    Close (ParamsF);
        //    if (AllOK )
        //    {
        //        LoggedConsole.WriteLine; write ("  ALL OK! Press any key to continue ... ");
        //        key = readkey;
        //        clrscr;
        //    }  //end;
        //    ParamvaluesOK = AllOK;
        //}  //end;

        //{This method finds the class which gained max Score for a given F2 unit
        //and assigns that class label to the unit. It also calculates a Class
        //probability Score ie ClassNumber/TotalNumber for each F2unit.}
//    public static void ScoreTrainingResults (noCommitted, noClasses:word; var classLabel:array of word; var classProb:array of real)
//    {
////var
//  uNo, cNo : word; {unit and class counter}
//  ScoreArray : array[1..maxClassNo] of word;
//  index, count{dummy var}, maxValue, total : word;

//for (uNo = 1 to noCommitted{nodes}) //for all units
//  {
//    //{first transfer F2 Scores to Score array. This is to avoid passing
//    // the zero index in the F2ScoreMatrix to the MaxIndex procedure}
//    total = 0;
//    for cNo = 1 to noClasses do
//    {
//      total   = total + F2ScoreMatrix^[uNo][cNo]; {sum over classes}
//      ScoreArray[cNo] = F2ScoreMatrix^[uNo, cNo];
//    }  //end;
//    {MaxIndex returns class with largest count. Random choice if =max}
//    MaxIndex (noClasses, ScoreArray, index, count, maxValue);
//    classLabel[uNo]= index+1; {+1 because array processed as 0 to n-1}

//    if total = 0
//      ) ClassProb[uNo] = 0
//      else ClassProb[uNo] = maxValue/total;
//    classLabel[0] = 0; {zero index will be used to indicate unmatched test sig}
////(***
////for cNo = 1 to noClasses do write (lst, F2ScoreMatrix^[uNo, cNo]:4);
////LoggedConsole.WriteLine (lst);
////LoggedConsole.WriteLine (lst, " max=",maxValue:3, " lbl=",classLabel[uNo]:3, " prob=",ClassProb[uNo]:4:1);
////***)
//  }  //}  //end;  {of all units}

//}  //}  //end; ScoreTrainingResults

//public static void ScoreTestResults
//{

////var
//  oneVote      : array[0..maxClassNo]  of word;
//  repeatsArray : array[1..MaxRepeatNo] of word;
//  count:word; //{(! used. Returns # of first place getters in case tied vote}
//  sigNum, rep, cls :word; {counters}
//  maxVote, maxValue{(! used}, correctClass :word;

//for sigNum = 1 to tstSetSize do {find the winning vote for every signal}
//  {
//    for cls= 0 to noClasses do oneVote[cls] = 0;      {init OneVote}
//    {transfer votes from matrix to OneVote array and ) find the maximum}
//    for rep = 1 to norepeats  do inc(oneVote[DecisionMatrix^[sigNum,rep] ]);
//    maxIndex (noClasses+1, oneVote, maxVote, count, maxValue);
//    decisionMatrix^[sigNum, 0] = maxVote;  {store vote winner in zero index}
//  }  //end; {of all signals}

//  //{summarise results for classified signals and store the test results
//   in test Score matrix}
//  for cls =  0 to noClasses+1 do
//    for rep = 0 to norepeats  do
//      tstScoreMatrix^[cls,rep] = 0;         {initialise test Score matrix}
//  for sigNum = 1 to tstSetSize do
//    for rep = 0 to norepeats do
//    {
//      correctClass = tstSetTargets^[sigNum];
//      if decisionMatrix^[sigNum, rep] = 0 )
//        inc (tstScoreMatrix^[ 0, rep]) //{skipped or no match sigs go in row 0}
//      else
//      if decisionMatrix^[sigNum, rep] = correctClass )
//      {
//        inc (tstScoreMatrix^[ correctClass, rep]);
//        inc (tstScoreMatrix^[ noClasses+1,  rep]);
//      }  //end;
//    }  //end;

//  for cls = 0 to noClasses+1 do
//  {
//   {first transfer rep Scores from matrix to an array which can be passed
//    to the moment procedure which returns the statistics.}
//    for rep = 1 to norepeats do
//          repeatsArray[rep] = tstScoreMatrix^[cls, rep];
//    moment(repeatsArray, norepeats, tstResult^[cls].mean,
//                                    tstResult^[cls].sd,
//                                    tstResult^[cls].min,
//                                    tstResult^[cls].max);
//    tstResult^[cls].vote = tstScoreMatrix^[cls,0]; {transfer vote counts}
//    tstResult^[noClasses+1].tot = tstSetSize;
//  }  //end;
//}  //}  //end; ScoreTestResults

//public static void WriteDecisionMatrix (var F: text)
//{
//    //var
//  sigNum, rep, i  : word; {counter}

//  LoggedConsole.WriteLine(F, "THE DECISION MATRIX");
//  write  (F, "sig#  vote");
//  for rep = 1 to norepeats do write(lst, rep:5);
//  LoggedConsole.WriteLine (F, "   target");
//  for i = 1 to 100 do write (F,"-"); LoggedConsole.WriteLine(F);  {draw horiz line}

//  for sigNum = 1 to tstSetSize do
//  {
//    write (F, sigNum:4,"|");
//    for rep = 0 to norepeats do
//      write (F, decisionMatrix^[sigNum, rep]:5);
//    LoggedConsole.WriteLine (F, "  |", tstSetTargets^[sigNum]:4);
//  }  //end;
//  LoggedConsole.WriteLine (F);
//  LoggedConsole.WriteLine (F, formfeed);
//} // }  //end; WriteDecisionMatrix

//public static void writeTestResults (var F:text)
//{
////var
//  k : word;
//  cls, rep: word;
//  size : word;
//  mean, sd : real;
//  min, max : word;

//  LoggedConsole.WriteLine (F, "TEST RESULTS/Score from file: ",ResultsFPath);
//  printDateAndTime (F);
//  LoggedConsole.WriteLine (F, "ART VERSION = ",versionNames[versionID]);
//  write   (F, "Training Set file = ",TrnSetFPath);
//  LoggedConsole.WriteLine (F, "   Train set size = ",trnSetSize, " signals");
//  LoggedConsole.WriteLine (F, "Train target file = ",TrnTarFPath);
//  write   (F, "Test Set     file = ",TstSetFPath);
//  LoggedConsole.WriteLine (F, "   Test  set size = ",tstSetSize, " signals");
//  LoggedConsole.WriteLine (F, "Test  target file = ",TstTarFPath);
//  LoggedConsole.WriteLine (F, "Weights file      = ",wtsFpath);
//  for k = 1 to MaxARTparamsNo do
//    write (F, paramNames[versionID, k]:9);
//  LoggedConsole.WriteLine (F);
//  for k = 1 to MaxARTparamsNo do write (F, ARTparams[k]:9:4);
//  LoggedConsole.WriteLine (F);
//  LoggedConsole.WriteLine (F);

//  write  (F, "rep number  ");
//  for rep = 1 to norepeats do write(F, rep:6);
//  LoggedConsole.WriteLine (F, "   av");
//  for k = 1 to 80 do write (F,"-"); LoggedConsole.WriteLine(F);  {draw horiz line}
//  write  (F, "categories  ");
//  for rep = 1 to norepeats do write(F, noOfCommittedF2[rep]:6);
//  moment(noOfCommittedF2, norepeats, mean, sd, min, max);
//  LoggedConsole.WriteLine (F, mean:6:1,"+/-",sd:3:1);
//  write  (F, "iter to conv");
//  for rep = 1 to norepeats do write(F, iterToConv[rep]:6);
//  moment(iterToConv, norepeats, mean, sd, min, max);
//  LoggedConsole.WriteLine (F, mean:6:1,"+/-",sd:3:1);
//  write  (F, "# skipped   ");
//  for rep = 1 to norepeats do write(F, SkippedBecauseFull[rep]:6);
//  LoggedConsole.WriteLine (F);
//  LoggedConsole.WriteLine (F);

//  size = tstResult^[noClasses+1].tot; {ie size of the test set or tstSetSize}
//  LoggedConsole.WriteLine(F, "THE TEST Score MATRIX");
//  write  (F, "class   vote");
//  for rep = 1 to norepeats do write(F, rep:6);
//  LoggedConsole.WriteLine (F);
//  for k = 1 to 80 do write (F,"-"); LoggedConsole.WriteLine(F);  {draw horiz line}
//  for cls= 0 to noClasses+1 do
//  {
//    write (F, cls:6);
//    for rep = 0 to norepeats do
//      write (F, tstScoreMatrix^[cls, rep]:6);
//    if cls = 0 ) LoggedConsole.WriteLine (F, " <- no match")
//    else
//    if cls = noClasses+1 ) LoggedConsole.WriteLine (F," <- total correct")
//    else LoggedConsole.WriteLine (F, " <- num correct in class");
//  }  //end; {end of all classes}
//  LoggedConsole.WriteLine (F);

////(****
////  LoggedConsole.WriteLine(lst);
////  LoggedConsole.WriteLine(lst,"Rep No:","":12,"No match   Classes 1 to ",noClasses,"  Total");
////  for rep=1 to norepeats do
////  {
////    write(lst, rep:2,"":9);
////    for cls = 0 to noClasses+1 do write (lst, tstScoreMatrix^[cls, rep]:5);
////    LoggedConsole.WriteLine(lst);
////  }  //end;
////  LoggedConsole.WriteLine(lst); LoggedConsole.WriteLine(lst);
////****)
//  LoggedConsole.WriteLine (F,"No match":21, "Classes 1 to ":30, noClasses, "Total":20);
//  write   (F,"totals  ");
//  for cls= 0 to noClasses+1 do  write (F, tstResult^[cls].tot:14);
//  LoggedConsole.WriteLine (F);

//  write   (F, "mean    ");
//  for cls= 0 to noClasses+1 do
//    write (F, tstResult^[cls].mean:7:1,"(",pc(tstResult^[cls].mean, size):4:1,"%)");
//  LoggedConsole.WriteLine (F);

//  write   (F, "std dev ");
//  for cls= 0 to noClasses+1 do
//    write (F, tstResult^[cls].sd:7:1,  "(",pc(tstResult^[cls].sd,   size):4:1,"%)");
//  LoggedConsole.WriteLine (F);

//  write   (F, "minimum ");
//  for cls= 0 to noClasses+1 do write (F, tstResult^[cls].min:14);
//  LoggedConsole.WriteLine (F);

//  write   (F, "maximum ");
//  for cls= 0 to noClasses+1 do write (F, tstResult^[cls].max:14);
//  LoggedConsole.WriteLine (F);

//  write   (F, "VOTE    ");
//  for cls= 0 to noClasses+1 do
//    write (F, tstResult^[cls].vote:7,"(",pc(tstResult^[cls].vote, size):4:1,"%)");
//  LoggedConsole.WriteLine (F);

//  write (F, formFeed);
//}  //}  //end;  writeTestResults (var F:text)

        //public static void MAINMENU()
        //{
        //    //var
        //    int i;  //      : word;
        //    string FPath; //  : PathStr;
        //    char choice, key;  // : char;
        //    //dirInfo: searchRec;

        //    Repeat
        //        ReadConfigFile;
        //        //TextBackGround (1);   //{blue background}
        //        //ClrScr;
        //        LoggedConsole.WriteLine();
        //        LoggedConsole.WriteLine ("                   ART MAIN MENU");
        //        LoggedConsole.WriteLine ("  All setting up to be entered in CONFIG file.");
        //        LoggedConsole.WriteLine();
        //        LoggedConsole.WriteLine ("  C) edit  CONFIGURATION file:- ",ConfigFpath);
        //        LoggedConsole.WriteLine ("  R) edit  PARAMETERS file   :- ",ParamsFpath);
        //        LoggedConsole.WriteLine ("  P) PRINT configuration file.");
        //        LoggedConsole.WriteLine ("  D) Display contents of OUTPUT directory.");
        //        LoggedConsole.WriteLine ("  T) Print TEXT file.");
        //        LoggedConsole.WriteLine ("  M) Print decision MATRIX.");
        //        LoggedConsole.WriteLine();
        //        LoggedConsole.WriteLine ("  O) OK, continue            Esc) HALT program");

        //    Repeat
        //        Choice = Upcase(readkey);
        //    Until choice in ["O", Esc, "R","C","P","D","M","T"];

        //    Case choice of
        //    "C":{
        //        SwapVectors;
        //        Exec("c:\\DOS\\edit.com", ConfigFPath);
        //        SwapVectors;
        //        If DOSError <> 0 ) LoggedConsole.WriteLine ("DOS Error # ",DosError);
        //        ClrScr;
        //        ReadConfigFile;
        //        DisplayConfiguration;
        //    }  //end;|
        //    "R":{
        //        SwapVectors;
        //        Exec("c:\\DOS\\edit.com", ParamsFPath);
        //        SwapVectors;
        //        If DOSError <> 0 ) LoggedConsole.WriteLine ("DOS Error # ",DosError);
        //        ClrScr;
        //      }  //end;
        //    "P":if (! printerOn ) Printer(!OnMessage
        //        else PrintTextFile(ConfigFName);
        //    "D":{
        //        ClrScr;
        //        LoggedConsole.WriteLine ("List of files in the directory :- ", OUTPUTdir);
        //        LoggedConsole.WriteLine;
        //        FindFirst (OUTPUTdir+"/*.*", AnyFile, DirInfo);
        //        i = 0;
        //        while (DosError = 0)  do
        //        {
        //          inc (i);
        //          write (DirInfo.name:15);
        //          FindNext (DirInfo);
        //          if (i MOD 5 = 0) ) LoggedConsole.WriteLine;
        //        }  //end;
        //        LoggedConsole.WriteLine;
        //        LoggedConsole.WriteLine ("Press <space bar> to return to main menu");
        //        key = readKey;
        //      }  //end;
        //    "T": {
        //        LoggedConsole.WriteLine;
        //        write ("   Enter full path name of text file to print -> ");
        //        readln (FPath);
        //        if (! FileExists(FPath) )
        //        {
        //          LoggedConsole.WriteLine;
        //          write (" File does (! exist!!   Press any key ->");
        //          key = readkey;
        //        end else
        //        if (! printerOn ) Printer(!OnMessage
        //                else printTextFile (FPath);
        //            }  //end;
        //    "M":if (! printerOn ) Printer(!OnMessage
        //        else writeDecisionMatrix (lst);
        //        Esc: HALT;
        //}  //end; {case choice of}

        //Until (choice = "O"{OK}) ;
        //}  //end;  MAINMENU

        //{***********************************************************************************************************************************}
        //{***********************************************************************************************************************************}
        //{***********************************************************************************************************************************}
        //{***********************************************************************************************************************************}
        //{***********************************************************************************************************************************}
        //{***********************************************************************************************************************************}
        //{***********************************************************************************************************************************}

        // {*** MAIN PROGRAM ***}

        public static void Main()
        {
            Tasks  task     = Tasks.TRAIN;
            string wtsFname = "output";

            double[,] trainingData = null;
            int trnSetSize = 0;

            //int tstSetSize = 0;
            int F1Size = 0;
            int F2Size = 0;

            bool[] uncommittedJ    = new bool[F2Size];         // : PtrToArrayOfBool;
            int[]  noOfCommittedF2 = new int[numberOfRepeats]; // : array[1..MaxRepeatNo] of word;{# committed F2Neta units}
            int[]  iterToConv      = new int[numberOfRepeats]; // : array[1..MaxRepeatNo] of word;{for training only}

            //char key = '0';        //      : char;
            int code = 0;    //        : word; {used for getting error messages}

            //int Score = 0;       //        : word;

            //double[]  DataArray  = new double[maxDataDim];
            //double[,] dataMatrix = new double[maxTrnSetSize, maxDataDim]; //of PdataArray;
            //int[]     keepScore = new int[maxTrnSetSize]; //stores the assigned class for every input signal. Used to test for stabilisation/convergence}
            //int[] SkippedBecauseFull = new int[numberOfRepeats];  // : array[1..MaxRepeatNo] of word;

            string wtsFpath     = "";
            string resultsFPath = ""; //  : PathStr;
            string trnSetFpath  = "";

            //string trnTarFpath = ""; //  : pathStr;
            string tstSetFpath = "";

            //string tstTarFpath = ""; //  : pathStr;
            //bool targetFileExists; // : boolean;
            //string ARTVersion;     //   : string[50];
            //int VersionID;         //    : integer;
            //int[] F2classLabel = new int[maxF2Size];       //: array [0..maxF2Size] of word;
            //double[] F2classProb = new double[maxF2Size];  // : array [0..maxF2Size] of real;
            //int KeepScore; //    : PKeepScore;

            //{************************** INITIALISE VALUES *************************}

            //F2ScoreMatrix = new ();   //{used to assign classes to F2 nodes after training}
            //decisionMatrix = new ();  //{matrix: tst sig number x repeats }
            //tstScoreMatrix = new ();  //{matrix: tst sig class  x repeats }
            //tstResult = new ();       //{array of record: class x tst Score results}
            //tstSetTargets = new ();

            //CONFIGURE AND CHECK PARAMETERS
            //ReadConfigFile;
            //code = 0;
            //CheckConfiguration (code);
            //if(code == 0) ParamValuesOK(versionID);

            if (task == Tasks.TRAIN || task == Tasks.TRAINTEST)
            {
                trnSetFpath  = dataFpath;
                trainingData = FileTools.ReadDoubles2Matrix(dataFpath);
                trnSetSize   = trainingData.GetLength(0);
                F1Size       = trainingData.GetLength(1);
                F2Size       = trainingData.GetLength(0);
            }

            double[,] parameters = ReadParameterValues(paramsFpath);
            int simulationsCount = parameters.GetLength(0);
            int paramCount       = parameters.GetLength(1);

            ART_2A art2a = new ART_2A(F1Size, F2Size);

            if (task == Tasks.TEST) // {load the test file weights}
            {
                //Case versionID of
                //    verART2A      : ReadWtsART2a    (wtsFPath, F1SizeOfNeta, F2SizeOfNeta, F2classLabel, F2classProb, code);
                //    verFuzzyART   : ReadWtsFuzzyART (wtsFPath, F1SizeOfNeta, F2SizeOfNeta, F2classLabel, F2classProb, code);
                //    verARTMAP2a   : { {ReadWtsARTMAP2a;} }  //end;
                //    verFuzzyARTMAP: ReadWtsFuzzyARTMAP(wtsFPath, F2classLabel, F2classProb, code);
                //}  //end; {Case Les.algID of}
                //ReadWtsART2a    (wtsFPath, F1SizeOfNeta, F2SizeOfNeta, F2classLabel, F2classProb, code);
            }

            //if (code != 0)
            //{
            //    LoggedConsole.WriteLine("WARNING!!!!!!!! ERROR READING WTS FILE.");
            //    LoggedConsole.WriteLine(" F1 & F2 sizes in config file and wts file are NOT equal");
            //    LoggedConsole.WriteLine(" Press any key to return to main menu");
            //    key = readkey;
            //    goto TheBeginning;
            //}

            //{Initialise screen for graphics display of F2 weight graphs}
            //InitialiseGraphicsMode;

            //{********** DO SIMULATIONS WITH DIFFERENT PARAMETER VALUES ***********}
            for (int simul = 0; simul < simulationsCount; simul++)
            {
                //pass the eight params for this run of ART2A
                //alpha, beta, rho, theta, rhoStar
                art2a.SetParameterValues(parameters[simul, 0], parameters[simul, 1], parameters[simul, 2], parameters[simul, 3]);

                //set up file name for simulation test results}
                resultsFPath = ARTDir + wtsFname + "s" + simul.ToString("D2") + "_results.txt";

                //init array to count committed F2 nodes
                //int[] noOfCommittedF2 = new int[ART.numberOfRepeats];

                //initialise decision matrix for processing test data}
                //int[,] decisionMatrix = new int[tstSetSize,norepeats];  //{matrix: tst sig number x repeats }

                //{********** DO REPEATS ***********}
                for (int rep = 0; rep < numberOfRepeats; rep++)
                {
                    LoggedConsole.WriteLine("RUN=", simul, " rep=", rep);

                    //{********* RUN NET for ONE SET OF PARAMETERS for ALL ITERATIONS *********}
                    if (task == Tasks.TRAIN)
                    {
                        art2a.InitialiseArrays();
                        code = 0;
                        art2a.TrainNet(trainingData, maxIterations, simul, rep, code);

                        if (code != 0)
                        {
                            break;
                        }

                        noOfCommittedF2[rep] = art2a.CountCommittedF2Nodes();

                        //ScoreTrainingResults (noOfCommittedF2[rep], noClasses, F2classLabel, F2classProb);

                        wtsFpath = ARTDir + ART.wtsFname + "s" + simul + rep + wtsFExt;

                        //art2a.WriteWts(wtsFpath, F2classLabel, F2classProb);
                        if (DEBUG)
                        {
                            LoggedConsole.WriteLine("wts= " + wtsFpath + "  train set= " + trnSetFpath);
                        }
                    }

                    if (task == Tasks.TEST)
                    {
                        //{wts file was loaded above.
                        //art2a.TestNet(testData, simul, rep, code) ;
                        //if (code != 0) goto EndOfSimulations;
                        //if (DEBUG) LoggedConsole.WriteLine("wts= " + wtsFpath + "  test set= " + tstSetFpath);
                    }

                    if (task == Tasks.TRAINTEST)
                    {
                        //Case versionID of        {initialise the weight arrays}
                        //verART2A      : InitWtsART2a;
                        //verFuzzyART   : InitWtsFuzzyART;
                        //{   verARTMAP2a   : InitWtsARTMAP2a;  }
                        //verFuzzyARTMAP: InitWtsFuzzyARTMAP;
                        //}  //Case Les.algID of}
                        art2a.InitialiseArrays();
                        art2a.TrainNet(trainingData, maxIterations, simul, rep, code);

                        if (code != 0)
                        {
                            break;
                        }

                        noOfCommittedF2[rep] = art2a.CountCommittedF2Nodes();

                        //ScoreTrainingResults (noOfCommittedF2[rep], noClasses, F2classLabel, F2classProb);

                        wtsFpath = ARTDir + ART.wtsFname + "s" + simul + rep + wtsFExt;

                        //Case versionID of
                        //verART2A      : WriteWtsART2a (wtsFPath, F1SizeOfNeta, F2SizeOfNeta, F2classLabel, F2classProb);
                        //verFuzzyART   : WriteWtsFuzzyART(wtsFPath, F1SizeOfNeta, F2SizeOfNeta,F2classLabel, F2classProb);
                        //verFuzzyARTMAP: WriteWtsFuzzyARTMAP(wtsFPath, F2classLabel, F2classProb);
                        //}  //Case Les.algID of}
                        //art2a.WriteWts(wtsFPath, F2classLabel, F2classProb);

                        //art2a.TestNet(testData, simul, rep, code);
                        //if (code != 0) goto EndOfSimulations;
                        if (DEBUG)
                        {
                            LoggedConsole.WriteLine("wts= " + wtsFpath + "  test set= " + tstSetFpath + "  Press any key");
                        }
                    }

                    //{************** DISPLAY RECONSTRUCTED SIGNALS **************}

                    //for F2uNo = 1 to F2SizeOfNeta do   {Calculate the average signal values}
                    //{
                    //  {for j = 0 to noClasses+1 do write (lst, F2ScoreMatrix^[F2uNo][j]:4);
                    //  LoggedConsole.WriteLine (lst);}
                    //  Score = F2ScoreMatrix^[F2uNo][noClasses+1];
                    //  for F1uNo = 1 to F1SizeOfNeta do
                    //    if  Score = 0 )
                    //         avSig^[F2uNo]^[F1uNo] = 0.0
                    //    else avSig^[F2uNo]^[F1uNo] = avSig^[F2uNo]^[F1uNo] /Score;
                    //}  //end;

                    //{*********** FinalScreenDisplay ***********}
                    //if (DEBUG)FinalScreenDisplay(F1sizeOfNeta,F2SizeOfNeta,F2ScoreMatrix,avSig^,WtsNeta^);
                    //{
                    //    InitialiseDisplayOfF2Weights (F1sizeOfNeta, noOfCommittedF2[rep]);
                    //    for (int F2uNo = 0; F2uNo < noOfCommittedF2[rep]; F2uNo++)
                    //    {
                    //        DisplayF2WtsAndSig(F2uNo, F1sizeOfNeta, noOfCommittedF2[rep], F2ScoreMatrix[F2uNo,noClasses+1],
                    //                    avSig[F2uNo], wtsNetA[F2uNo], avSigRange, wtsRange);
                    //    }
                    //} //end; {if display on do final display}
                } //end; {for rep   = 1 to norepeats do}       {***** END OF REPEATS *****}

                //ScoreTestResults;
                //if (printTestResults) writeTestResults(lst); //            {write to printer.....}
                //else   //{...else write to file}
                //{
                //  assign (resultsF, resultsFPath);
                //  rewrite(resultsF);
                //  writeTestResults (resultsF);
                //  close  (resultsF);
                //}  //end;

                //if (printDecisionMatrix) writeDecisionMatrix(lst);
            } //end; {for simul = 1 to noSimulationsInRun do}  {**** END OF SIMULATE *****}

            //if (printerOn) PrintTextFile(ConfigFpath);

            //{LABEL} EndOfSimulations:
            //close  (ParamsF);
            //CloseGraph;
            //Case versionID of
            //  verART2A      : DisposeART2a;
            //  verFuzzyART   : DisposeFuzzyART;
            //{  verARTMAP2a   : DisposeARTMAP2a;}
            //  verFuzzyARTMAP: DisposeFuzzyARTMAP;
            //}  //end; {Case Les.algID of}

            //GoTo TheBeginning;

            //    {****************** DISPOSE OF HEAP VARIABLES ******************}
            //for j = 1 to MaxTrnSetSize do dispose (DataMatrix[j]);
            //dispose (keepScore);
            //dispose (F2ScoreMatrix);   {used to assign classes to F2 nodes}
            //dispose (decisionMatrix);  {matrix: tst sig number x repeats }
            //dispose (tstScoreMatrix);  {matrix: tst sig class  x repeats }
            //dispose (tstResult);       {array of record: class x tst Score results}
            //dispose (TstSetTargets);
        } //END of MAIN METHOD.