---

dlanguage.cpp

Go to the documentation of this file.

    const bool test_applier = false;
    //const bool test_applier = true;
#include <stdlib.h>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <math.h>
#include <string>
#ifdef HAVE_HASH_MAP
#include <hash_map>
#endif
#ifdef HAVE_EXT_HASH_MAP
#include <ext/hash_map>
#endif
#include <mak/hash_string.h>

#include "punnets.h"

using namespace __gnu_cxx;
using namespace std;
using namespace mak;
using namespace punnets;

const real a1_offset = 1.0;
const real weight_scale = 1.0;
const ntime_t coindet_duration_period = 0.002;
const real coindet_offset = 0.0015;

const ntime_t inhibitor_delay = 0.00001;
const ntime_t gates_delay = 0.00001;
const real synchro_gate_delay = 0.001;
const real delayed_gate_delay = 0.1;
const real delayed_gate_gap   = 0.009;
const real synchro_hidden_offset = 0.0002;
const real delayed_hidden_offset = 0.03;
const ntime_t suppress_delay = -0.0001;
const ntime_t coindet_delay = 0.00003;
const ntime_t incoindet_delay = 0.003 - inhibitor_delay;
const ntime_t sgate_sig_hv_period = 0.003;
const ntime_t sgate_thr_hv_period = 0.003;
const ntime_t dgate_sig_hv_period = 0.0045;
const ntime_t dgate_thr_hv_period = 0.01;
const real sgate_hidden_thr_raise = 16;
const real dgate_hidden_thr_raise = 32;
const real coindet_suppress_weight = 15.0;
const real delay_weight_decrease = 0.5;
const real synch_weight_decrease = 0.0;
const real inhibitor_suppress_weight = 30.0;
const ntime_t synch_minus_preceding = 0.00001;
const ntime_t delay_minus_preceding = 0.00045;

const ntime_t test_until = 3.25;

enum pos_t {
    pos_n1,
    pos_n3,
    pos_n,
    pos_pn3,
    pos_vi,
    pos_vt,
    pos_vt_subj,
    pos_det,
    pos_max
};

const string posstrs[] = { "pronoun 1st", "pronoun 3rd", "noun", "proper noun", 
        "vi", "vt", "vt_subj", "det" };

enum flg_t
{
    flg_none = 0,
    flg_nom = 1,
    flg_acc = 2,
//  flg_poss = 4,
    flg_plu = 8,
    flg_male = 16,
    flg_female = 32,
    flg_food = 64,
    flg_reading = 128,
    flg_countable = 128,
    flg_love = 256,
};

struct word_t {
    string word;
    pos_t pos;
    int flag;
};

const word_t words[] = 
    { { "I", pos_n1, flg_nom },
      { "me", pos_n1, flg_acc },
      { "he", pos_n3, flg_nom | flg_male},
      { "him", pos_n3, flg_acc | flg_male },
      { "she", pos_n3, flg_nom | flg_female },
      { "her", pos_n3, flg_acc | flg_female },
//    { "they", pos_n3, flg_nom | flg_plu },
//    { "them", pos_n3, flg_acc | flg_plu },
      { "Mary", pos_pn3, flg_female },
      { "John", pos_pn3, flg_male },
      { "Susan", pos_pn3, flg_female },
      { "Mike", pos_pn3, flg_male },
      { "man", pos_n, flg_male | flg_countable },
      { "lady", pos_n, flg_female | flg_countable },
      { "boy", pos_n, flg_male | flg_countable },
      { "girl", pos_n, flg_female | flg_countable },
      { "book", pos_n, flg_reading | flg_countable },
      { "paper", pos_n, flg_reading },
      { "mail", pos_n, flg_reading | flg_countable },
      { "bread", pos_n, flg_food },
      { "lemon", pos_n, flg_food | flg_countable },
      { "banana", pos_n, flg_food | flg_countable },
      { "runs", pos_vi, 0 },
      { "sleeps", pos_vi, 0 },
      { "smiles", pos_vi, 0 },
      { "likes", pos_vt, flg_love | flg_reading | flg_food },
      { "(liker)", pos_vt_subj, flg_love | flg_reading | flg_food },
      { "has", pos_vt, flg_reading | flg_food },
      { "(owner)", pos_vt_subj, flg_reading | flg_food },
      { "loves", pos_vt, flg_love },
      { "(lover)", pos_vt_subj, flg_love },
      { "reads", pos_vt, flg_reading },
      { "(reader)", pos_vt_subj, flg_reading },
      { "eats", pos_vt, flg_food },
      { "(eater)", pos_vt_subj, flg_food },
      { "a", pos_det, flg_countable },
      { "the", pos_det, 0 }
};

hash_map<string, unsigned int> str_to_wordid;

const unsigned int NWORDS = sizeof(words) / sizeof(word_t);
const unsigned int NELEMS = (int)pos_max;



struct neuinfo {
    string layername;
    unsigned int nneuron;
    tneuron_base *ref;
    neuinfo() { }
    neuinfo(string il, unsigned int in, tneuron_base *ir) : layername(il), nneuron(in), ref(ir) { }
};
    

void read_file(vector<tneuron_ext *> &neuin, vector<tneuron *> &neuhid, vector<tneuron *> &neuout, tneuron &inhibitor, tneuron &coindet, string fname, ntime_t delay1, ntime_t delay_input_gap, real decay_level, real hidden_offset, bool synch)
{
    tneuron &incoindet = inhibitor;
    cout << "Read file " << fname << ", decay_level=" << decay_level << endl;
    const bool debug_readfile = false;

    ifstream ifs(fname.c_str());

    string s;
    ifs >> s;

    hash_map<string, neuinfo, hash_string> nmap;

    while(ifs.good())
    {
        if( s != "layer" ) { cout << "input file bad <" << s << ">" << endl; abort();}

        string layername;
        int layersize;
        ifs >> layername;
        if( debug_readfile ) cout << "layer " << layername << endl;

        ifs >> s;
        while( ifs.good() )
        {
            if( s == "size" )
            {
                ifs >> layersize;
                if( debug_readfile ) cout << "size " << layersize << endl;
                ifs >> s;
            }
            else if( s == "neurons" )
            {
                if( debug_readfile ) cout << "neurons " << layersize << endl;
                for( int i=0; i<layersize; i++ )
                {
                    ifs >> s;
                    if( layername == "a1_layer" )
                        nmap[s] = neuinfo(layername, i, &inhibitor);
                    else if( layername == "input_layer" )
                        nmap[s] = neuinfo(layername, i, (neuin[i % neuin.size()]));
                    else if( layername == "output_layer" )
                        nmap[s] = neuinfo(layername, i, (neuout[i % neuout.size()]));
                    else if( layername == "hidden_layer" )
                    {
                        ostringstream oss; oss << i;
                        tneuron *neu = new tneuron((synch ? "shidden(" : "dhidden(") + oss.str() + ")", 
                            synch ? sgate_sig_hv_period : dgate_sig_hv_period, 
                            synch ? sgate_thr_hv_period : dgate_thr_hv_period, 
                            a1_offset, a1_offset+(synch ? sgate_hidden_thr_raise : dgate_hidden_thr_raise) );
                        nmap[s] = neuinfo(layername, i, neu);
                        neuhid.push_back(neu);
                    }
                    else
                    {
                        cout << "Unknown layer name " << layername << endl;
                        abort();
                    }
                }
                ifs >> s;
            }
            else if( s == "connection" )
            {
                string dstname;
                int nconn;
                ifs >> dstname >> nconn;
                if( nmap.find(dstname) == nmap.end() ) { cout << "unknown neuron " << dstname << endl; abort();}
                if( debug_readfile ) cout << "connection " << nconn << endl;
                tneuron_base *dest = nmap[dstname].ref;
                for( int i=0; i<nconn; i++ )
                {
                    string srcname;
                    real weight;
                    int idelay;
                    ifs >> srcname >> weight >> idelay;
                    if( nmap.find(srcname)== nmap.end()  ) { cout << "unknown neuron " << srcname << endl; abort();}
                    tneuron_base *src = nmap[srcname].ref;
                    weight *= weight_scale;
                    if( nmap[srcname].layername == "a1_layer" ) 
                    {
                        tsynapse *p1, *p2, *p3 = NULL;
                        real delay = delay1 - inhibitor_delay;
                        if( nmap[dstname].layername == "hidden_layer" )
                            delay += -hidden_offset;
                        weight += a1_offset;

                        real inhibitor_fix = 0.0;
                        if( ! synch )
                        {
                            weight -= a1_offset;
                            incoindet.addSynapse(p3 = new tsynapse(*dest, delay - 0.00002 - incoindet_delay - coindet_offset, ((weight < 0 ? weight : 0) - inhibitor_suppress_weight)) );
//                          inhibitor.addSynapse(p3 = new tsynapse(*dest, delay + 0.003 - 0.00001 - incoindet_delay , 0.3)) ;
//                          inhibitor.addSynapse(p2 = new tsynapse(*dest, delay + coindet_duration_period, 1.0 ));
                            inhibitor_fix = ((weight < 0 ? weight : 0) - inhibitor_suppress_weight) * pow(decay_level, (delayed_gate_gap + coindet_offset) / coindet_duration_period );
//                          cout << nmap[dstname].layername << "(" << nmap[dstname].nneuron << ") weight=" << weight << ", level=" << decay_level << ", pow=" << pow(decay_level, (delayed_gate_gap + coindet_offset) / coindet_duration_period ) << ", fix=" << inhibitor_fix << endl;
                            weight += a1_offset;
                        }
                        coindet.addSynapse(p1 = new tsynapse(*dest, 
                                delay + (! synch ? -coindet_duration_period : - 0.00001), 
                                ((weight < 0 ? weight : 0) - coindet_suppress_weight)/sqrt(decay_level)));
                        coindet.addSynapse(p2 = new tsynapse(*dest, 
                                delay, 
                                ((weight > 0 ? weight : 0) + coindet_suppress_weight)*sqrt(decay_level) - inhibitor_fix - (!synch ? delay_weight_decrease : synch_weight_decrease)));
//                      if( nmap[dstname].layername == "output_layer" && 
//                      (   nmap[dstname].nneuron == str_to_wordid["the"] || nmap[dstname].nneuron == NWORDS + pos_det 
//                       || nmap[dstname].nneuron == str_to_wordid["girl"] || nmap[dstname].nneuron == NWORDS + pos_n ))
//                       {
//                          cout << "debug synapse " << nmap[srcname].nneuron << " -> " << nmap[dstname].nneuron << endl;
//                          p1->setDeb(true);
//                          p2->setDeb(true);
//                          if( p3 )
//                              p3->setDeb(true);
//                       }
                    }
                    else
                    {
                        real delay = (nmap[srcname].layername == "input_layer" && nmap[srcname].nneuron >= neuin.size()) ? delay1 + delay_input_gap : delay1;
                        if( nmap[srcname].layername == "hidden_layer" )
                            delay = hidden_offset;
                        else if( nmap[dstname].layername == "hidden_layer" )
                            delay -= hidden_offset;
                        tsynapse *p;
                        if( weight < 0.0 )
                        {
                            delay -= synch ? synch_minus_preceding : delay_minus_preceding;
                            if( !synch )
                                weight /= pow(decay_level, delay_minus_preceding / coindet_duration_period );
                        }
                        src->addSynapse(p = new tsynapse(*dest, delay - (! synch ? coindet_offset : 0), weight));
//                      if( nmap[dstname].nneuron == str_to_wordid["the"] || nmap[dstname].nneuron == NWORDS + pos_det 
//                       || nmap[dstname].nneuron == str_to_wordid["girl"] || nmap[dstname].nneuron == NWORDS + pos_n )
//                       {
//                          cout << "debug synapse " << nmap[srcname].nneuron << " -> " << nmap[dstname].nneuron << endl;
//                          p->setDeb(true);
//                       }
                    }
                }
                ifs >> s;
            }
            else
                break;
        }
    }
}


int main(int argc, char **argv)
{
    cout << "Punnets language simulation program  (c) 2003 Makino Takaki." << endl;
    cout << "Punnets is free software, covered by the GNU General Public License." << endl;
    cout << endl;

    const char *datafilename = "lang.dat";
    const char *plotfilename = "lang.plt";

    const unsigned int nexts = NWORDS + NELEMS;
    vector<tneuron_ext *> exts(nexts);
    vector<tneuron *> hidden;
    vector<tneuron *> sgates(nexts);
    vector<tneuron *> dgates(nexts);
    tneuron inhibitor("inhibitor", 0.0005, 0.0005, 1.0, 128.0);
    tneuron coindet("coindet", 0.003, 0.05, 1.0, 5.0);
    tneuron incoindet("incoindet", 0.003, 0.003, 1.0, 2.0);

    inhibitor.addSynapse(new tsynapse(coindet, inhibitor_delay, 0.67));
    inhibitor.addSynapse(new tsynapse(coindet, inhibitor_delay + delayed_gate_gap, 0.67));
    inhibitor.addSynapse(new tsynapse(incoindet, incoindet_delay, 1.2));
    inhibitor.addSynapse(new tsynapse(incoindet, incoindet_delay + delayed_gate_gap, 1.2));
    coindet.addSynapse(new tsynapse(incoindet, incoindet_delay - inhibitor_delay - 0.0015, -4));

    for( unsigned int i=0; i<NWORDS; i++ )
        str_to_wordid[ words[i].word ] = i;
    

    tscheduler scheduler;

    ofstream ofs(datafilename);
    cout << "Produce simulation log file '" << datafilename << "'." << endl;
    tlogger logger(ofs, 0.001, 0.01, test_until);
//  tlogger logger(ofs, 0.00001, 0.609,0.621);

    for( unsigned int i=0; i<nexts; i++ )
    {
        ostringstream oss;
        exts[i] = new tneuron_ext("repre'" + (i < NWORDS ? words[i].word : posstrs[i-NWORDS]) + "'", 0.0045);
        sgates[i] = new tneuron("sgate'" + (i < NWORDS ? words[i].word : posstrs[i-NWORDS]) + "'", 
                sgate_sig_hv_period, sgate_thr_hv_period, a1_offset, a1_offset+64 );
        dgates[i] = new tneuron("dgate'" + (i < NWORDS ? words[i].word : posstrs[i-NWORDS]) + "'", 
                dgate_sig_hv_period, dgate_thr_hv_period, a1_offset, a1_offset+64 );

//if(! test_applier) {
//      exts[i]->addExt(new func_const(-1.3));
//      exts[i]->addExt(new func_sine(1.0 /* width */, 8 * 2*M_PI /* angle velo */, 0.0 /* phase */ ));
//      exts[i]->addExt(new func_sineshot_int(1 /* width */, 1.6 * 2*M_PI /* angle velo */ ));
//      inhibitor.addSynapse(new tsynapse_addfunc(*exts[i], 0.0001, new func_sineshot(-0.7, (1/0.027) * 2*M_PI, -1.0), -0.8));
//}

        exts[i]->addExt(new func_const(-1.4));
if( ! test_applier ) {
        exts[i]->addExt(new func_sine(1.0 /* width */, 8 * 2*M_PI /* angle velo */, 0.0 /* phase */ ));
        exts[i]->addExt(new func_sineshot_int(1.27 /* width */, 1.59 * 2*M_PI /* angle velo */ ));
        inhibitor.addSynapse(new tsynapse_addfunc(*exts[i], 0.0001, new func_sineshot(-0.7, (1/0.021) * 2*M_PI, -1.0), new func_sineshot::message_set_t0, -0.25));
}
        exts[i]->addSynapse(new tsynapse(inhibitor, inhibitor_delay, 1.5));
        exts[i]->addSynapse(new tsynapse(*exts[i], inhibitor_delay, -4.0));
        exts[i]->setLoopBack(scheduler, 0.0);
if( ! test_applier ) {
        sgates[i]->addSynapse(new tsynapse(*exts[i], gates_delay, 4.0));
        dgates[i]->addSynapse(new tsynapse(*exts[i], gates_delay, 5.5));
}

        if( 
            i == str_to_wordid["the"] || i == NWORDS + pos_det 
        ||  i == str_to_wordid["Mary"] || i == NWORDS + pos_pn3
        ||  i == str_to_wordid["girl"] || i == NWORDS + pos_n
        ||  i == str_to_wordid["loves"] || i == NWORDS + pos_vt
        ||  i == str_to_wordid["(lover)"] || i == NWORDS + pos_vt_subj
            )
        {
            real off =
                       (i == str_to_wordid["Mary"] || i == NWORDS + pos_pn3) ? 40 : 
                       (i == str_to_wordid["(lover)"] || i == NWORDS + pos_vt_subj) ? 30 : 
                       (i == str_to_wordid["loves"] || i == NWORDS + pos_vt) ? 20 : 
                       (i == str_to_wordid["the"] || i == NWORDS + pos_det) ? 10 : 0;
            off += (i >= NWORDS) ? 4 : 0;
            logger.add(*exts[i], 0, false, false, off * 3.5 / 5);
            // logger.add(*sgates[i], 0, false, false, off);    
            // logger.add(*dgates[i], 0, false, false, 1.0 + off);
//          exts[i]->setDeb(true);
//          sgates[i]->setDeb(true);
//          dgates[i]->setDeb(true);
        }
    }

//  logger.add( inhibitor, 0, false, false, -8.0 );

    read_file(exts, hidden, sgates, inhibitor, inhibitor, "synch.dat", synchro_gate_delay, 0.0             , 
        1.0 , synchro_hidden_offset, true);
    read_file(exts, hidden, dgates, incoindet, coindet  , "delay.dat", delayed_gate_delay, delayed_gate_gap, 
        exp(-(M_LN2 / dgate_sig_hv_period)*(coindet_duration_period)) , delayed_hidden_offset, false );

    ofstream ofs2(plotfilename);
    cout << "Produce GNUPLOT plotting file '" << plotfilename << "'." << endl;
    logger.gnuplot_def(ofs2, datafilename);

    logger.schedule(scheduler);

    scheduler.scheduleEvent( 0.61, makePulse( * exts[ str_to_wordid[ "Mary" ] ], 5.0 ) );
    scheduler.scheduleEvent( 0.975, makePulse( * exts[ str_to_wordid[ "loves" ] ], 5.0 ) );
    scheduler.scheduleEvent( 1.725, makePulse( * exts[ str_to_wordid[ "the" ] ], 5.0 ) );
    scheduler.scheduleEvent( 2.225, makePulse( * exts[ str_to_wordid[ "girl" ] ], 5.0 ) );

    scheduler.run(test_until);

    cout << "Simulation finished." << endl;
    return 0;
}

---