DCNlearning.cpp

   1 // Implementation of Dynamic Computational Network learning class
   2 // Copyright © 2009 The University of Chicago
   3 #include "DCNlearning.h"
   4
   5 #include <cstdlib>
   6 #include <ctime>
   7 #include <QString>
   8 #include <QFile>
   9 #include <Q3TextStream>
  10
  11 #include "DCNgrammar.h"
  12 #include "DCNnetwork.h"
  13 #include "DCNsnetwork.h"
  14 #include "ui/Status.h"
  15 #include "random.h"
  16
  17 namespace {
  18         using linguistica::ui::status_user_agent;
  19 }
  20
  21 learning::learning()
  22 {
  23
  24 }
  25
  26 learning::~learning()
  27 {
  28
  29 }
  30
  31 void learning::runHelper(Q3TextStream& logstream, status_user_agent& status)
  32 {
  33         using std::srand;
  34         using std::time;
  35
  36         srand(static_cast<unsigned>(time(0)));
  37
  38         successful = false;
  39
  40         //careful, i'm specifying values
  41         float                           T = TfromUser;
  42         int                                     cutoff = cutoffFromUser;
  43         int                                     corpusIndex = 0;
  44
  45         int                                     maxCorpusIndex = numberOfWords;
  46
  47         int                                     syl = 10;
  48
  49         float                           alpha;
  50         float                           beta;
  51         float                           I;
  52         float                           F;
  53         F = 0;
  54         I = 0;
  55         beta = 0;
  56         alpha = 0;
  57
  58
  59         snetwork                        snet(2, 15);
  60
  61         theGrammar.setValues(startingAlpha,startingBeta, startingI, startingF, 0, 0);
  62
  63         status.progress.clear();
  64         status.progress.set_denominator(cutoffFromUser);
  65         int updateNumber = 0;
  66         while (T > 0.01 && cutoff >= 0) {
  67                 status.progress = updateNumber;
  68                 logstream
  69                         << "T:  "               << T                                            << "\t"
  70                         << "it:  "              << cutoffFromUser - cutoff      << "\t"
  71                         << "alpha:  "   << theGrammar.getAlpha()        << "\t"
  72                         << "beta:  "    << theGrammar.getBeta()         << "\t"
  73                         << "initial:  " << theGrammar.getI()            << "\t"
  74                         << "final:  "   << theGrammar.getF()            << "\n";
  75                 QString string = corpus[corpusIndex];
  76
  77                 syl = string.length();
  78                 network theNetwork(syl);
  79                 theNetwork.setGrammar(&theGrammar);
  80                 theNetwork.equilibrium();
  81
  82                 QString word = theNetwork.getStress();
  83
  84                 if (word != corpus[corpusIndex]) {
  85                         using linguistica::random_small_float;
  86
  87                         // random float between -1 and 1
  88                         float deltaAlpha = T * random_small_float();
  89                         alpha = theGrammar.getAlpha() + deltaAlpha;
  90
  91                         float deltaBeta = T * random_small_float();
  92                         beta = theGrammar.getBeta() + deltaBeta;
  93
  94                         float deltaI = T * random_small_float();
  95                         I = theGrammar.getI() + deltaI;
  96
  97                         float deltaF = T * random_small_float();
  98                         F = theGrammar.getF() + deltaF;
  99
 100                         //theGrammar.setValues(alpha, beta, I, F, 0, 0);
 101
 102                         possibleGrammar.setValues(alpha, beta, I, F, 0, 0);
 103                         snet.setGrammar(&possibleGrammar);
 104                         snet.equilibrium();
 105
 106                         if (snet.isTotallyConverged())
 107                         {
 108                                 // alpha * beta > .3 may be another thing to put in here
 109                                 if (alpha > 0)
 110                                         alpha *= -1;
 111                                 if (beta > 0)
 112                                         beta  *= -1;
 113                                 theGrammar.setValues(alpha, beta, I, F, 0, 0);
 114                         }
 115                         T = T + increaseWhenWrong;
 116                         //T = T + sqrt( pow(deltaAlpha, 2.0) + pow(deltaBeta, 2.0)
 117                         //      + pow(deltaI, 2.0) + pow(deltaF, 2.0) );
 118
 119                 }
 120                 else if (word == corpus[corpusIndex])
 121                 {
 122                         T = T * decreaseWhenRight;
 123                 }
 124                 //T = T - .01;
 125                 cutoff--; updateNumber++;
 126                 corpusIndex = (corpusIndex + 1)%maxCorpusIndex;
 127         }
 128         status.progress.clear();
 129
 130         possibleGrammar.setValues(alpha, beta, I, F, 0, 0);
 131         snet.setGrammar(&possibleGrammar);
 132         snet.equilibrium();
 133         if (cutoff > 2 && snet.isTotallyConverged())
 134                 successful = true;
 135 }
 136
 137 void learning::run(status_user_agent& status_display)
 138 {
 139         using std::time_t;
 140         using std::time;
 141         using std::ctime;
 142
 143         QFile logfile( "DCNlog.txt" ); // added : -cs-
 144         if( logfile.open( QIODevice::WriteOnly | QIODevice::Append ) ) // added : -cs-
 145         { // added : -cs-
 146                 Q3TextStream logstream( &logfile ); // added : -cs-
 147                 time_t rawtime;
 148
 149                 time ( &rawtime );
 150                 logstream << "Learning Algorithm run at " << ctime(&rawtime);
 151
 152                 for (int i = 0; i < numberOfTries; i++)
 153                 {
 154                         logstream << "\n\tTRIAL NUMBER " << i+1 << "\n";
 155                         runHelper(logstream, status_display);
 156                         if (this->isSuccessful()) break;
 157                 }
 158                 logfile.close();
 159         } // added : -cs-
 160 }
 161
 162 void learning::setCorpus(corpusType corpus, int numberOfWords)
 163 {
 164         this->corpus = corpus;
 165         this->numberOfWords = numberOfWords;
 166 }
 167
 168 grammar* learning::returnGrammar()
 169 {
 170         grammar* returnGrammar = new grammar(theGrammar);
 171         return returnGrammar;
 172 }
 173