learningdialog.ui.h

Go to the documentation of this file.

/****************************************************************************
** ui.h extension file, included from the uic-generated form implementation.
**
** If you want to add, delete, or rename functions or slots, use
** Qt Designer to update this file, preserving your code.
**
** You should not define a constructor or destructor in this file.
** Instead, write your code in functions called init() and destroy().
** These will automatically be called by the form's constructor and
** destructor.
*****************************************************************************/

# include <qstring.h>
# include <qlineedit.h>
# include <qslider.h>
# include <qfile.h>
# include <qtextstream.h>
# include <qcanvas.h>
# include <qfiledialog.h>
# include <qstatusbar.h>
# include <qtextedit.h>
# include <qtimer.h>
# include <qdatetime.h>
# include <qwt_plot.h>

# include <inn.h>
# include <learningThread.h>
# include <network.h>

extern Inn * inn ;
extern Network * network;

QwtPlot *sigPlot, *errPlot;
long sig, sigDer;
double sigX[120];
double sigY[120];
double sigDerY[120];

QTimer *timer;
QTime *elapsed;
LearningThread lt;

void LearningDialog::init() {
        network->setEPS(4);
        network->setExampleOrder(SEQUENTIAL);
        
        sigPlot = new QwtPlot("Sigmoid");
        sigPlot->setFixedSize(400, 300);
        sigPlot->setTitle("Sigmoid and Derived");
        sigPlot->enableGridX();
        sigPlot->enableGridY();
        sigPlot->setAxisTitle(sigPlot->gridXAxis(), "X");
        sigPlot->setAxisTitle(sigPlot->gridYAxis(), "Y");
        sigPlot->setCanvasBackground(QColor(255,255,255));
        sigPlot->setLegendFrameStyle(QFrame::PopupPanel | QFrame::Plain);
        
        errPlot = new QwtPlot("Error Evolution");
        errPlot->setFixedSize(400, 300);
        errPlot->setTitle("Error Evolution");
        errPlot->enableGridX();
        errPlot->enableGridY();
        errPlot->setAxisTitle(errPlot->gridXAxis(), "Epoch");
        errPlot->setAxisTitle(errPlot->gridYAxis(), "Average Error");
        errPlot->setCanvasBackground(QColor(255,255,255));
        errPlot->setLegendFrameStyle(QFrame::PopupPanel | QFrame::Plain);
        
    lineEdit5->setText(QString::number(network->getK(), 'f', 3)) ;
    lineEdit8->setText(QString::number(network->getEPS()));
    slider1->setValue((int)(network->getK()*1000));
    
    timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this , SLOT(timerEvent()));
}


void LearningDialog::slotSigmoidChanged( void ) {
    network->setK(((double)slider1->value())/1000) ;
    lineEdit5->setText(QString::number(network->getK(), 'f', 3)) ;
    slotShowSigmoid();
}


void LearningDialog::slotBrowse( void ) {
        network->clearErrorEvolution();
        
    QString filename = QFileDialog::getOpenFileName(
                    ".",
                    "CSV file (*.csv)",
                    this,
                    "open file a teaching file",
                    "Choose a file to open" ) ;
        lineEdit1->setText(filename);
}


void LearningDialog::slotStartLearning( void ) {
        if (!lt.running()) {
                if ( (lineEdit1->displayText() == "") || (lineEdit2->displayText() == "")
                        || (lineEdit3->displayText() == "" ) || (lineEdit4->displayText() == "" ) ) {
                                QMessageBox::warning(0, "Warning", "Please fill in all the fields");
                } else {
                    inn->console->append("learning started ...") ;
                        inn->statusBar()->message( "learning started ...", 2000 );
                        lt.init(lineEdit1->text(), lineEdit3->text().toDouble(), lineEdit2->text().toInt(), lineEdit4->text().toDouble());
                        lt.start();
                        lt.setState(PLAY);
                        elapsed = new QTime();
                        elapsed->start() ;
                        timer->start(10);
                }
        } else if (lt.getState() == PAUSE) {
                inn->console->append("learning restarted ...") ;
                inn->statusBar()->message( "learning restarted ...", 2000 );
                pauseButton->setOn(false);
                elapsed = new QTime();
                elapsed->start();
                lt.setState(PLAY);
        }
}


void LearningDialog::slotShowSigmoid( void ) {
        double valX = -6.0;
        
        for (int i=0; i<120; i++) {
                sigX[i] = valX;
                sigY[i] = 1 / (1 + exp(-1 * network->getK() * valX));
                sigDerY[i] = sigY[i] * (1 - sigY[i]);
                valX += 0.1;
        }

        sigPlot->clear();
        sig = sigPlot->insertCurve("Sigmoid");
        sigDer = sigPlot->insertCurve("Sigmoid Derived");
        sigPlot->setCurveStyle(sig, QwtCurve::Spline);
        sigPlot->setCurveStyle(sigDer, QwtCurve::Spline);
        sigPlot->enableLegend(true, sig);
        sigPlot->enableLegend(true, sigDer);
        sigPlot->setCurvePen(sig, QPen(QColor(0,0,255), 1));
        sigPlot->setCurvePen(sigDer, QPen(QColor(0,255,0), 1));
        sigPlot->setCurveData(sig, sigX, sigY, 120);
        sigPlot->setCurveData(sigDer, sigX, sigDerY, 120);
        sigPlot->replot();
        sigPlot->show() ;
}


void LearningDialog::slotShowError( void ) {
        int err;
        vector<double> *error = network->getErrorEvolution();
        vector<double>::iterator iter = error->begin();
        double *x = new double[error->size()];
        double *y = new double[error->size()];
        for (unsigned int i=0; i<error->size(); i++) {
                x[i] = i;
                y[i] = (*iter);
                iter++;
        }
        
        errPlot->clear();
        err = errPlot->insertCurve("Error Evolution");
        errPlot->setCurveData(err, x, y, error->size());
        errPlot->setCurveStyle(err, QwtCurve::Spline);
        errPlot->setCurvePen(err, QPen(QColor(0,0,255), 1));
        errPlot->enableLegend(true, err);
        
        errPlot->replot();
        errPlot->show();
}


void LearningDialog::timerEvent() {
        QString s, s1;
        s.setNum(network->getCurrentEpoch() - 1);
        lineEdit6->setText(s) ;
        s1.setNum(network->getCurrentAverageError());
        lineEdit7->setText(s1);
        
        if (elapsed != NULL) {
                QTime t ;
                t.setHMS(
                        (elapsed->elapsed()/(60*60*1000))%60, 
                        (elapsed->elapsed()/(60*1000))%60,
                        (elapsed->elapsed()/(1000))%60,
                        elapsed->elapsed()%(1000)) ;
                lineEdit9->setText(t.toString("hh:mm:ss.zzz")) ;
        }
        
        if (!lt.running()) stopSlot();
}


void LearningDialog::LearningDialog_destroyed( QObject * ) {
        
}


void LearningDialog::slotEpochsPerSecondChanged( void ) {
        network->setEPS(slider2->value()) ;
    lineEdit8->setText(QString::number(slider2->value())) ;
}


void LearningDialog::pauseSlot() {
        if (lt.running()) {
                if (pauseButton->isOn()) {
                        inn->console->append("learning paused ...") ;
                        inn->statusBar()->message( "learning paused ...", 2000 );
                        delete elapsed;
                        elapsed = NULL;
                        lt.setState(PAUSE);
                } else {
                        inn->console->append("learning restarted ...") ;
                        inn->statusBar()->message( "learning restarted ...", 2000 );
                        elapsed = new QTime();
                        elapsed->start();
                        lt.setState(PLAY);
                }
        } else {
                pauseButton->setOn(false);
                inn->statusBar()->message( "you cannot pause a thing that has not yet been started ...", 2000 );
        }
}


void LearningDialog::stopSlot() {
        if (lt.running()) {
                inn->console->append("learning stopped ...") ;
                inn->statusBar()->message( "learning stopped ...", 2000 );
                lt.setState(PAUSE);
                lt.terminate();
                timer->stop() ;
                delete elapsed;
                elapsed = NULL;
                pauseButton->setOn(false);
        } else {
                timer->stop();
                delete elapsed;
                elapsed = NULL;
                if (network->getCurrentEpoch() < lineEdit2->text().toInt() 
                        && network->getCurrentAverageError() > lineEdit3->text().toDouble())
                        inn->statusBar()->message( "you cannot stop a thing that has not yet been started ...", 2000 );
        }
}


void LearningDialog::stepSlot() {
        if (lt.running()) {
                if (lt.getState() != PAUSE) {
                        inn->statusBar()->message( "you must first pause the learning ...", 2000 );
                } else {
                        inn->statusBar()->message( "next step ...", 2000 );
                        lt.nextStep();  
                }
        } else {
                if ( (lineEdit1->displayText() == "") || (lineEdit2->displayText() == "")
                        || (lineEdit3->displayText() == "" ) || (lineEdit4->displayText() == "" ) ) {
                                QMessageBox::warning(0, "Warning", "Please fill in all the fields");
                } else {
                    inn->console->append("learning started in step by step mode...") ;
                        inn->statusBar()->message( "learning started in step by step mode...", 2000 );
                        pauseButton->setOn(true);
                        lt.init(lineEdit1->text(), lineEdit3->text().toDouble(), lineEdit2->text().toInt(), lineEdit4->text().toDouble());
                        lt.setState(PAUSE);
                        lt.start();
                        elapsed = NULL;
                        timer->start(10);
                }
        }
}


void LearningDialog::sequentialOrder() {
        network->setExampleOrder(SEQUENTIAL);
}


void LearningDialog::randomWithOrder() {
        network->setExampleOrder(RANDOM_WITH);
}


void LearningDialog::randomWithoutOrder() {
        network->setExampleOrder(RANDOM_WITHOUT);
}

---