C#

Nicholas Butler wrote:

It's on Safari

Application.DoEvents()

private void trainingANN_instance_LogReportSynch(string stringname)
 {
     if (this.InvokeRequired)
     {
         DelegateToCrossThread_String del = new DelegateToCrossThread_String(trainingANN_instance_LogReportSynch);
         this.Invoke(del);
     }
     else
     {
         //Application.DoEvents();
         this.tbVeryBig.Text += stringname;
     }
 }

this.tbVeryBig.Text += "[" + DateTime.Now.TimeOfDay.ToString() + "]: txt [" + inN+ "]\r\n";

Luc Pattyn wrote:

When using the InvokeRequired/Invoke pattern, I hesitate to use Control.BeginInvoke() as that modifies the semantics of the method: when on the right thread, it works synchronously, whereas on another thread it only executes asynchronously. I am aware the thread switches are expensive though.

trainingANN_instance_LogReportSynch

private void butTraining_MouseClick(object sender, MouseEventArgs e)
       {

           this.trainingANN_thread = new Thread(new ThreadStart(this.Initiate_ANN_Training));

           LockOptions();

           this.tbVeryBig.Clear();

           //trainingANN_thread.IsBackground = true;

           this.trainingANN_thread.Start();

           this.tbVeryBig.Text += "[" + DateTime.Now.TimeOfDay.ToString() + "]: INITIALIZATION\r\n";
       }

private void SettingsInfoDisplay()
{
    if (this.InvokeRequired)
    {
        DelegateToCrossThread_None crossThreader = new DelegateToCrossThread_None(SettingsInfoDisplay);
        this.Invoke(crossThreader);
    }
    else
    {
        this.tboxOutputNeuron.Text = "" + outputNeurons;
        this.tboxInputNeuron.Text = "" + inputNeurons;
        this.tboxHiddenNeuron.Text = "" + tbarHiddenN.Value;

        this.tboxErrorTreshold.Text = "" + (this.tbarErrorTreshold.Value / 100.0);
        this.tboxTrainingRate.Text = "" + (this.tbarTrainingRate.Value / 100.0);

        this.tbBadF.Text = "<not defined>";
        this.tbAccuracy.Text = "<not defined>";
        this.tbConvergeRate.Text = "<not defined>";
        this.tbErrorCounter.Text = "<not defined>";
        this.tbRatio.Text = "<not defined>";
        this.tbGoodF.Text = "<not defined>";
        this.tbEpoch.Text = "<not defined>";
    }
}

/// </summary>
      private void Options()
      {
          if (this.InvokeRequired)
          {
              DelegateToCrossThread_None crossThreader = new DelegateToCrossThread_None(Options);
              this.Invoke(crossThreader);
          }
          else
          {
              errorTreshold = (double)((tbarErrorTreshold.Value) / 100.0); //error filter
              learningRate = (double)((tbarTrainingRate.Value) / 100.0); //learning rate
              hiddenNeurons = tbarHiddenN.Value;

              //progress filter (converge rate)
              //skipped

              //log options
              if (this.cboxLog.Checked != true)
              {
                  logOption = false; //brief, performance OK
              }
              else
                  logOption = true; //detailed, performance BAD
          }
      }

//Gatter all the settings for the ANN and initiate training
       private void Initiate_ANN_Training()
       {
           if (this.InvokeRequired)
           {
               DelegateToCrossThread_None crossThreader = new DelegateToCrossThread_None(Initiate_ANN_Training);
               this.Invoke(crossThreader);
           }
           else
           {
               SettingsInfoDisplay(); //displaying information for visual guiding
               Options(); //options for training

               this.tbVeryBig.AppendText("text");

               //instanciate training class
               trainingANN_instance = new ANN_Training();

               this.tbVeryBig.Text += "[" + DateTime.Now.TimeOfDay.ToString() + "]: ANN TRAINING STARTED!\r\n";

               trainingANN_instance.GoodFactsSynch += new StatsSynch(trainingANN_instance_GoodFactsSynch); //updates textbox of good facts
               trainingANN_instance.BadFactsSynch += new StatsSynch(trainingANN_instance_BadFactsSynch); //updates tbox of bad
               trainingANN_instance.RatioSynch += new StatsSynch(trainingANN_instance_RatioSynch); //updates tbox ratio
               trainingANN_instance.ConvergeRateSynch += new StatsSynch(trainingANN_instance_ConvergeRateSynch); //converge
               trainingANN_instance.EpochSynch += new StatsSynch(trainingANN_instance_EpochSynch);//epoch
               trainingANN_instance.LogReportSynch += new StringSynch(trainingANN_instance_LogReportSynch); //log reporter
               trainingANN_instance.BadFactsForGraphSynch += new StatsSynch(trainingANN_instance_BadFactsForGraphSynch); //graph
               //trainingANN_instance.WHMatrixSynch += new Weights_MatrixSynch(trainingANN_instance_WHMatrixSynch);
               //trainingANN_instance.WOMatrixSynch += new Weights_MatrixSynch(trainingANN_instance_WOMatrixSynch);

               //training ANN
               trainingANN_instance.Training(inputNeurons, hiddenNeurons, outputNeurons, errorTreshold, learningRate, progressFilter, logOption);

               this.tbVeryBig.Text += "[" + DateTime.Now.TimeOfDay.ToString() + "]: ANN TRAINING FINISHED!\r\n";

               //result stats of the training & recognition
               double ratio = (trainingANN_instance.good / trainingANN_instance.bad * 100);
               this.tbRatio.Text = (Math.Round(ratio, 5)) + "%";
               this.tbEpoch.Text = trainingANN_instance.epoch.ToString();
               this.tbBadF.Text = trainingANN_instance.bad.ToString();
               this.tbGoodF.Text = trainingANN_instance.good.ToString();
               this.tbConvergeRate.Text = Math.Round((trainingANN_instance.progressRatio_temp), 5).ToString() + "%";

               this.tbVeryBig.Text += "[" + DateTime.Now.TimeOfDay.ToString() + "]: RESULTS:\r\n EPOCH: " + trainingANN_instance.epoch.ToString();
               this.tbVeryBig.Text += "\r\n BAD FACTS: " + trainingANN_instance.bad.ToString();
               this.tbVeryBig.Text += "\r\n GOOD FACTS: " + trainingANN_instance.good.ToString();
               this.tbVeryBig.Text += "\r\n RATIO: " + ratio + "\r\n CONVERGE RATE: " + Math.Round((trainingANN_instance.progressRatio_temp), 5).ToString() + "%";
               //unlock options
               UnlockOptions();
               //terminate thread
               trainingANN_thread.Abort();
           }
       }

private void trainingANN_instance_RatioSynch(double variable)
{
    if (this.InvokeRequired)
    {
        DelegateToCrossThread_Double del = new DelegateToCrossThread_Double(trainingANN_instance_RatioSynch);
        this.Invoke(del);
    }
    else
    {
        //Application.DoEvents();
        this.tbRatio.Text = "" + variable;
    }
}

private void Initiate_ANN_Training()
{
        SettingsInfoDisplay(); //displaying information for visual guiding
        Options(); //options for training

        DisplayInformation(); //dynamic log reporter

        //instanciate training class
        trainingANN_instance = new ANN_Training();

        ANN_Events();


        StartTraining();

Daniel Grunwald wrote:

letting the background operation wait for the textbox).

readonly object loggerLock = new object();
StringBuilder loggerBuffer = new StringBuilder();

private void trainingANN_instance_LogReportSynch(string stringname)
{
   // no need to invoke as we're not directly accessing tbVeryBig
   lock (loggerLock) {
      loggerBuffer.Append(stringname);
   }
}

void logTimer_Tick(object sender, EventArgs e)
{
   string newText;
   lock (loggerLock) {
      newText = loggerBuffer.ToString();
      loggerBuffer.Length = 0; // reset buffer
   } // leave lock as soon as possible so that the calculation never has to wait for long
   if (newText.Length > 0)
     tbVeryBig.AppendText(newText);
}