proc.c

/* File: proc.c
 *
 * Processing modules of DISCERN.
 *
 * Copyright (C) 1994 Risto Miikkulainen
 *
 *  This software can be copied, modified and distributed freely for
 *  educational and research purposes, provided that this notice is included
 *  in the code, and the author is acknowledged in any materials and reports
 *  that result from its use. It may not be used for commercial purposes
 *  without expressed permission from the author.
 *
 * $Id: proc.c,v 1.38 1994/09/20 10:46:59 risto Exp $
 */

#include <stdio.h>
#include <math.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>

#include "defs.h"
#include "globals.c"


/************ processing module constants *************/

/* keywords expected in procsimu */
#define PROCSIMU_NHIDREP "network-nhidrep" /* hidden layer size in procsimu */
#define PROCSIMU_WEIGHTS "network-weights" /* procmodule weights in procsimu */


/******************** Function prototypes ************************/

/* global functions */
#include "prototypes.h"

/* functions local to this file */
static void parse_sentence __P((SENTSTRUCT sent, int taski));
static void gener_sentence __P((SENTSTRUCT sent, int taski));
static void forward_propagate __P((int modi));
static void proc_iterate_weights __P((void (*dofun) (FILE *, double *,
						     double, double),
				      FILE *fp, double par1, double par2));


/*********************  parsing routines ***************************/

void
parse_story ()
/* read a sequence of sentence case-role representations into a 
   slot-filler representation of the entire story. 
   Calls parse_sentence as a subroutine to get each case-role rep. */
{
  int i, j, k,
  senti,			/* sentence number in the input file */
  step = 0,			/* actual sentence number in the sequence */
  modi = STORYPARSMOD;		/* module number */

  printcomment ("\n", "parsing input story:", "\n");

  /* first clean up the network display */
  if (displaying)
    {
      proc_clear_network (modi);
      display_current_proc_net (modi);
    }
  
  /* get the target slot-filler indices */
  for (i = 0; i < noutputs[modi]; i++)
    targets[modi][i] = story.slots[i];
  /* form the target activation vector */
  for (i = 0; i < noutputs[modi]; i++)
    for (j = 0; j < nsrep; j++)
      tgtrep[modi][i * nsrep + j] = swords[targets[modi][i]].rep[j];
  /* display the target activation */
  if (displaying)
    {
      display_labeled_layer (modi, noutputs[modi], tgtrep[modi], targets[modi],
			     net[modi].tgtx, net[modi].tgty, BELOW);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  /* previous hidden layer is blank in the beginning of the sequence */
  for (i = 0; i < nhidrep[modi]; i++)
    prevhidrep[modi][i] = 0.0;
  /* process each sentence included in the input story */
  for (senti = 0; senti < story.nsent; senti++)
    if (story.sents[senti].included)
      {
	/* first form the case-role representation for the sentence */
	parse_sentence (story.sents[senti], PARATASK);

	/* get the indices of the correct case-role representation */
	for (i = 0; i < ninputs[modi]; i++)
	  inputs[modi][i] = story.sents[senti].caseroles[i];
	/* if the modules are in a chain,
	   use sentence parser output as input */
	if (chain)
	  for (i = 0; i < ncaserep; i++)
	    inprep[modi][i] = caserep[i];
	else
	  /* use the correct case-role rep as input */
	  for (i = 0; i < ninputs[modi]; i++)
	    for (j = 0; j < nsrep; j++)
	      inprep[modi][i * nsrep + j] = swords[inputs[modi][i]].rep[j];

	/* display the input representation and the previous hidden layer */
	if (displaying)
	  {
	    display_labeled_layer (modi, ninputs[modi], inprep[modi],
				   inputs[modi],
				   net[modi].inpx, net[modi].inpy, ABOVE);
	    display_assembly (modi, net[modi].prevx, net[modi].prevy,
			      prevhidrep[modi], nhidrep[modi]);
	    wait_and_handle_events ();  /* stop if stepping, check events */
	  }

	/* propagate from input and prevhid layer to the output */
	forward_propagate (modi);
	/* display hidden layer, output, and the log line */
	if (displaying)
	  {
	    display_assembly (modi, net[modi].hidx, net[modi].hidy,
			      hidrep[modi], nhidrep[modi]);
	    display_labeled_layer (modi, noutputs[modi], outrep[modi],
				   targets[modi],
				   net[modi].outx, net[modi].outy, BELOW2);
	    display_error (modi, outrep[modi], noutputs[modi],
			   targets[modi], swords, nsrep, ++step);
	    wait_and_handle_events ();  /* stop if stepping, check events */
	  }
	/* update the previous hidden layer */
	for (k = 0; k < nhidrep[modi]; k++)
	  prevhidrep[modi][k] = hidrep[modi][k];
      }

  printcomment ("\n", "into internal rep:", "\n");
  /* collect statistics about the output accuracy of this module */
  collect_stats (PARATASK, modi);

  /* if the modules are in a chain, establish the result to be used
     for the episodic memory or storygen */
  if (chain)
    for (i = 0; i < nslotrep; i++)
      slotrep[i] = outrep[modi][i];
}


static void
parse_sentence (sent, taski)
/* read a sequence of input word representations into a case-role
   representation of the sentence. Calls the input_lexicon to transform
   lexical to the semantic representation. */
     SENTSTRUCT sent;		/* indices of the words in the sentence */
     int taski;			/* paraphrasing or question answering */
{
  int i, j, k,
  wordi,			/* word number in the input file */
  step = 0,			/* actual word number in the sequence */
  modi = SENTPARSMOD;		/* module number */

  /* first clean up the network display */
  if (displaying)
    {
      proc_clear_network (modi);
      display_current_proc_net (modi);
    }

  /* get the target caserole indices */
  for (i = 0; i < noutputs[modi]; i++)
    targets[modi][i] = sent.caseroles[i];
  /* form the target activation vector */
  for (i = 0; i < noutputs[modi]; i++)
    for (j = 0; j < nsrep; j++)
      tgtrep[modi][i * nsrep + j] = swords[targets[modi][i]].rep[j];

  /* display the target activation */
  if (displaying)
    {
      display_labeled_layer (modi, noutputs[modi], tgtrep[modi], targets[modi],
			     net[modi].tgtx, net[modi].tgty, BELOW);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  /* previous hidden layer is blank in the beginning of the sequence */
  for (i = 0; i < nhidrep[modi]; i++)
    prevhidrep[modi][i] = 0.0;

  /* process each word */
  for (wordi = 0; wordi < sent.nseq; wordi++)
    {
      /* present the word to the lexicon to obtain
	 the semantic representation */
      if (withlex)
	input_lexicon (taski, sent.words[wordi]);
      else if (babbling)
	printf ("%s ", swords[sent.words[wordi]].chars);
      /* index of the current input word */
      inputs[modi][0] = sent.words[wordi];
      /* if the modules are in a chain and lexicon translation is modeled,
	 use the lexicon output as input */
      if (chain && withlex)
	for (i = 0; i < nsrep; i++)
	  inprep[modi][i] = swordrep[i];
      else
	/* use the correct semantic word representation */
	for (i = 0; i < nsrep; i++)
	  inprep[modi][i] = swords[inputs[modi][0]].rep[i];

      /* display the sentence read so far, the input representation, 
	 and the previous hidden layer activation */
      if (displaying)
	{
	  /* include the current word in the sentence read so far */
	  sprintf (net[modi].sequence, "%s %s",
		   net[modi].sequence, net[modi].newitem);
	  display_sequence (modi, net[modi].inpx, net[modi].inpy);
	  display_labeled_layer (modi, ninputs[modi], inprep[modi],
				 inputs[modi],
				 net[modi].inpx, net[modi].inpy, ABOVE);
	  display_assembly (modi, net[modi].prevx, net[modi].prevy,
			    prevhidrep[modi], nhidrep[modi]);
	  wait_and_handle_events ();  /* stop if stepping, check events */
	}

      /* propagate from input and prevhid layer to the output */
      forward_propagate (modi);
      /* display hidden layer, output, and the log line */
      if (displaying)
	{
	  display_assembly (modi, net[modi].hidx, net[modi].hidy,
			    hidrep[modi], nhidrep[modi]);
	  display_labeled_layer (modi, noutputs[modi], outrep[modi],
				 targets[modi],
				 net[modi].outx, net[modi].outy, BELOW2);
	  display_error (modi, outrep[modi], noutputs[modi], targets[modi],
			 swords, nsrep, ++step);
	  wait_and_handle_events ();  /* stop if stepping, check events */
	}

      /* update the previous hidden layer */
      for (k = 0; k < nhidrep[modi]; k++)
	prevhidrep[modi][k] = hidrep[modi][k];
    }
  if (babbling)
    putchar ('\n');
  /* collect statistics about the output accuracy of this module */
  collect_stats (taski, modi);

  /* if the modules are in a chain, establish the result to be used
     for the story parser or cue former */
  if (chain)
    for (i = 0; i < ncaserep; i++)
      caserep[i] = outrep[modi][i];
}


/*********************  generation routines ***************************/

void
gener_story ()
/* generate a paraphrase of the story from its slot-filler representation.
   Generates a sequence of sentence case-role representations and calls
   gener_sentence as a subroutine to output the words of each sentence. */
{
  int i, j, k,
  senti,			/* sentence number in the input file */
  step = 0,			/* actual sentence number in the sequence */
  modi = STORYGENMOD;		/* module number */

  printcomment ("\n", "generating paraphrase:", "\n");

  /* first clean up the network display */
  if (displaying)
    {
      proc_clear_network (modi);
      display_current_proc_net (modi);
    }
  
  /* get the input slot-filler indices */
  for (i = 0; i < ninputs[modi]; i++)
    inputs[modi][i] = story.slots[i];
  /* form the input activation vector */
  if (chain)
    /* if the modules are in a chain, use the current slotrep (either from
       the story parser or from the episodic memory) as input */
    for (i = 0; i < nslotrep; i++)
      inprep[modi][i] = slotrep[i];
  else
    /* otherwise use the correct representation */
    for (i = 0; i < ninputs[modi]; i++)
      for (j = 0; j < nsrep; j++)
	inprep[modi][i * nsrep + j] = swords[inputs[modi][i]].rep[j];

  /* display the input representation */
  if (displaying)
    {
      display_labeled_layer (modi, ninputs[modi], inprep[modi], inputs[modi],
			     net[modi].inpx, net[modi].inpy, BELOW);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  /* previous hidden layer is blank in the beginning of the sequence */
  for (i = 0; i < nhidrep[modi]; i++)
    prevhidrep[modi][i] = 0.0;

  /* generate the output sentences */
  for (senti = 0; senti < story.nsent; senti++)
    {
      /* display the previous hidden layer */
      if (displaying && senti != 0)
	{
	  display_assembly (modi, net[modi].prevx, net[modi].prevy,
			    prevhidrep[modi], nhidrep[modi]);
	  wait_and_handle_events ();	/* stop if stepping, check events */
	}

      /* get the indices for the target case-role representation */
      for (i = 0; i < noutputs[modi]; i++)
	targets[modi][i] = story.sents[senti].caseroles[i];
      /* form the target case-role representation */
      for (i = 0; i < noutputs[modi]; i++)
	for (j = 0; j < nsrep; j++)
	  tgtrep[modi][i * nsrep + j] = swords[targets[modi][i]].rep[j];

      /* propagate from input to the output */
      forward_propagate (modi);
      /* display hidden layer, output, target, and the log line */
      if (displaying)
	{
	  display_assembly (modi, net[modi].hidx, net[modi].hidy,
			    hidrep[modi], nhidrep[modi]);
	  display_labeled_layer (modi, noutputs[modi], outrep[modi],
				 targets[modi],
				 net[modi].outx, net[modi].outy, ABOVE2);
	  display_layer (modi, noutputs[modi], tgtrep[modi],
			 net[modi].tgtx, net[modi].tgty, nsrep);
	  display_error (modi, outrep[modi], noutputs[modi],
			 targets[modi], swords, nsrep, ++step);
	  wait_and_handle_events ();	/* stop if stepping, check events */
	}

      /* update the previous hidden layer */
      for (k = 0; k < nhidrep[modi]; k++)
	prevhidrep[modi][k] = hidrep[modi][k];

      /* collect statistics about the output accuracy of this module */
      collect_stats (PARATASK, modi);

      /* if the modules are in a chain, establish the result to be used
	 by the sentence generator */
      if (chain)
	for (i = 0; i < ncaserep; i++)
	  caserep[i] = outrep[modi][i];

      /* generate the words for the sentence */
      gener_sentence (story.sents[senti], PARATASK);
    }
}


static void
gener_sentence (sent, taski)
/* generate the semantic words of the sentence one at a time from its internal
   case-role representation, call the lexicon to translate them into
   lexical words */
     SENTSTRUCT sent;		/* indices of the words in the sentence */
     int taski;			/* paraphrasing or question answering */
{
  int i, j, k,
  wordi,			/* word number in the input file */
  step = 0,			/* actual word number in the sequence */
  modi = SENTGENMOD;		/* module number */

  /* first clean up the network display */
  if (displaying)
    {
      proc_clear_network (modi);
      display_current_proc_net (modi);
    }

  /* get the input case-role indices */
  for (i = 0; i < ninputs[modi]; i++)
    inputs[modi][i] = sent.caseroles[i];
  /* form the input activation vector */
  for (i = 0; i < ninputs[modi]; i++)
    for (j = 0; j < nsrep; j++)
      /* if the modules are in a chain, use the current caserep (either from
	 the story generator or from the answer produces) as input */
      if (chain)
	inprep[modi][i * nsrep + j] = caserep[i * nsrep + j];
      else
	/* otherwise use the correct representation */
	inprep[modi][i * nsrep + j] = swords[inputs[modi][i]].rep[j];

  /* display the input representation */
  if (displaying)
    {
      display_labeled_layer (modi, ninputs[modi], inprep[modi], inputs[modi],
			     net[modi].inpx, net[modi].inpy, BELOW);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  /* previous hidden layer is blank in the beginning of the sequence */
  for (i = 0; i < nhidrep[modi]; i++)
    prevhidrep[modi][i] = 0.0;

  /* generate the output words */
  for (wordi = 0; wordi < sent.nseq; wordi++)
    {
      /* display the previous hidden layer */
      if (displaying && wordi != 0)
	{
	  display_assembly (modi, net[modi].prevx, net[modi].prevy,
			    prevhidrep[modi], nhidrep[modi]);
	  wait_and_handle_events ();	/* stop if stepping, check events */
	}

      /* get the index of the target word */
      targets[modi][0] = sent.words[wordi];
      /* form the target semantic word representation */
      for (j = 0; j < nsrep; j++)
	tgtrep[modi][j] = swords[targets[modi][0]].rep[j];

      /* propagate from input to the output */
      forward_propagate (modi);
      /* display hidden layer, sentence so far, output, target,
	 and the log line */
      if (displaying)
	{
	  display_assembly (modi, net[modi].hidx, net[modi].hidy,
			    hidrep[modi], nhidrep[modi]);
	  /* include the current word in the sentence produced so far */
	  sprintf (net[modi].sequence, "%s %s",
		   net[modi].sequence, net[modi].newitem);
	  display_sequence (modi, net[modi].tgtx, net[modi].tgty);
	  display_labeled_layer (modi, noutputs[modi], outrep[modi],
				 targets[modi],
				 net[modi].outx, net[modi].outy, ABOVE2);
	  display_layer (modi, noutputs[modi], tgtrep[modi],
			 net[modi].tgtx, net[modi].tgty, nsrep);
	  display_error (modi, outrep[modi], noutputs[modi], targets[modi],
			 swords, nsrep, ++step);
	  wait_and_handle_events ();	/* stop if stepping, check events */
	}

      /* update the previous hidden layer */
      for (k = 0; k < nhidrep[modi]; k++)
	prevhidrep[modi][k] = hidrep[modi][k];

      /* collect statistics about the output accuracy of this module */
      collect_stats (taski, modi);
      /* if the modules are in a chain and lexicon is included in the
	 simulation, establish the result to be used as input to the
	 lexicon */
      if (chain && withlex)
	for (j = 0; j < nsrep; j++)
	  swordrep[j] = outrep[modi][j];
      /* if lexicon is included, translate the semantic word to its
	 lexical counterpart */
      if (withlex)
	output_lexicon (taski, sent.words[wordi]);
      /* if generating an answer to a text_question and the current word
	 is the period, generate no more words */
      if (text_question &&
	  find_nearest (outrep[modi], swords, nsrep, nswords)
	  == sentdelimindex)
	break;
    }
  if (babbling)
    putchar ('\n');
}


/*********************  question answering  ***************************/

void
formcue ()
/* given a question case-role representation as input, form a cue
   slot-filler representation for the episodic memory. Calls parse_sentence
   as a subroutine to obtain the case-role representation. */
{
  int i, j,
  step = 0,			/* there is no sequence, so this is always 0 */
  modi = CUEFORMMOD;		/* module number */

  printcomment ("\n", "parsing question:", "\n");

  /* first clean up the network display */
  if (displaying)
    {
      proc_clear_network (modi);
      display_current_proc_net (modi);
    }
  
  /* form the case-role representation for the question */
  parse_sentence (qa.question, QATASK);
  /* get the input case-role indices */
  for (i = 0; i < ninputs[modi]; i++)
    inputs[modi][i] = qa.question.caseroles[i];
  /* if the modules are in a chain, use the current caserep (from
     the sentence parser) as input */
  if (chain)
    for (i = 0; i < ncaserep; i++)
      inprep[modi][i] = caserep[i];
  else
    /* otherwise use the correct representation */
    for (i = 0; i < ninputs[modi]; i++)
      for (j = 0; j < nsrep; j++)
	inprep[modi][i * nsrep + j] = swords[inputs[modi][i]].rep[j];

  /* display the input representation */
  if (displaying)
    {
      display_labeled_layer (modi, ninputs[modi], inprep[modi], inputs[modi],
			     net[modi].inpx, net[modi].inpy, ABOVE);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  /* get the target story slot-filler indices */
  for (i = 0; i < noutputs[modi]; i++)
    targets[modi][i] = qa.slots[i];
  /* form the target activation vector */
  for (i = 0; i < noutputs[modi]; i++)
    for (j = 0; j < nsrep; j++)
      tgtrep[modi][i * nsrep + j] = swords[targets[modi][i]].rep[j];

  /* propagate from input to the output */
  forward_propagate (modi);
  /* display hidden layer, output, target, and the log line */
  if (displaying)
    {
      display_assembly (modi, net[modi].hidx, net[modi].hidy,
			hidrep[modi], nhidrep[modi]);
      display_labeled_layer (modi, noutputs[modi], outrep[modi], targets[modi],
			     net[modi].outx, net[modi].outy, BELOW2);
      display_layer (modi, noutputs[modi], tgtrep[modi],
		     net[modi].tgtx, net[modi].tgty, nsrep);
      display_error (modi, outrep[modi], noutputs[modi], targets[modi],
		     swords, nsrep, ++step);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  printcomment ("\n", "into cue:", "\n");
  /* collect statistics about the output accuracy of this module */
  collect_stats (QATASK, modi);

  /* if the modules are in a chain and the episodic memory is included in the
     simulation, establish the result to be used as input to the memory */
  if (chain && withhfm)
    for (i = 0; i < nslotrep; i++)
      slotrep[i] = outrep[modi][i];
}


void
produceanswer ()
/* given the question case-role representation and the story slot-filler
   representation as input, generates the case-role representation of
   the answer sentence, and calls sentence generator to output it word
   by word. */
{
  int i, j,
  step = 0,			/* there is no sequence, so this is always 0 */
  modi = ANSWERPRODMOD;		/* module number */

  /* first clean up the network display */
  if (displaying)
    {
      proc_clear_network (modi);
      display_current_proc_net (modi);
    }
  
  /* get the input case-role indices and the input slot-filler indices */
  for (i = 0; i < ncase; i++)
    inputs[modi][i] = qa.question.caseroles[i];
  for (i = 0; i < nslot; i++)
    inputs[modi][ncase + i] = qa.slots[i];
  /* if the modules are in a chain, use the current caserep (from
     the sentence parser) and the current slotrep (from the episodic
     memory) as input */
  if (chain)
    {
      for (i = 0; i < ncaserep; i++)
	inprep[modi][i] = caserep[i];
      for (i = 0; i < nslotrep; i++)
	inprep[modi][i + noutrep[0]] = slotrep[i];
    }
  else
    /* otherwise use the correct representations */
    for (i = 0; i < ninputs[modi]; i++)
      for (j = 0; j < nsrep; j++)
	inprep[modi][i * nsrep + j] = swords[inputs[modi][i]].rep[j];

  /* display the input representation */
  if (displaying)
    {
      /* question part of the input layer */
      display_labeled_layer (modi, ncase, inprep[modi], inputs[modi],
			     net[modi].inpx, net[modi].inpy, BELOW);
      /* story part */
      display_labeled_layer (modi, nslot, &inprep[modi][ncaserep],
			     &inputs[modi][ncase],
			     net[modi].inp1x, net[modi].inp1y, BELOW);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  /* get the target case-role indices */
  for (i = 0; i < noutputs[modi]; i++)
    targets[modi][i] = qa.answer.caseroles[i];
  /* form the target activation vector */
  for (i = 0; i < noutputs[modi]; i++)
    for (j = 0; j < nsrep; j++)
      tgtrep[modi][i * nsrep + j] = swords[targets[modi][i]].rep[j];

  /* propagate from input to the output */
  forward_propagate (modi);
  /* display hidden layer, output, target, and the log line */
  if (displaying)
    {
      display_assembly (modi, net[modi].hidx, net[modi].hidy,
			hidrep[modi], nhidrep[modi]);
      display_labeled_layer (modi, noutputs[modi], outrep[modi], targets[modi],
			     net[modi].outx, net[modi].outy, ABOVE2);
      display_layer (modi, noutputs[modi], tgtrep[modi],
		     net[modi].tgtx, net[modi].tgty, nsrep);
      display_error (modi, outrep[modi], noutputs[modi], targets[modi],
		     swords, nsrep, ++step);
      wait_and_handle_events ();  /* stop if stepping, check for events */
    }

  printcomment ("\n", "generating answer:", "\n");
  /* collect statistics about the output accuracy of this module */
  collect_stats (QATASK, modi);
  /* if the modules are in a chain, establish the result to be used as 
     input to the sentence generator */
  if (chain)
    for (i = 0; i < ncaserep; i++)
      caserep[i] = outrep[modi][i];	/* activate result */
  /* generate the word of the answer sentence */
  gener_sentence (qa.answer, QATASK);
}


/*********************  propagation ******************************/

static void
forward_propagate (modi)
/* propagate activation from input and (possibly) previous hidden layer
   to the output layer */
     int modi;				/* module number */
{
  int i, k, p;

  /* hidden layer biases */
  for (k = 0; k < nhidrep[modi]; k++)
    hidrep[modi][k] = hidbias[modi][k];
  /* propagate from the previous hidden layer (if the network has one)
     to the hidden layer */
  if (modi != CUEFORMMOD && modi != ANSWERPRODMOD)
    for (p = 0; p < nhidrep[modi]; p++)
      for (k = 0; k < nhidrep[modi]; k++)
	hidrep[modi][k] += prevhidrep[modi][p] * wph[modi][p][k];
  /* propagate from the input layer to the hidden layer */
  for (i = 0; i < ninprep[modi]; i++)
    for (k = 0; k < nhidrep[modi]; k++)
      hidrep[modi][k] += inprep[modi][i] * wih[modi][i][k];
  /* pass the weighted sums through the sigmoid to get activations
     of the hidden layer units */
  for (k = 0; k < nhidrep[modi]; k++)
    hidrep[modi][k] = 1.0 / (1.0 + exp (-hidrep[modi][k]));

  /* output layer biases */
  for (i = 0; i < noutrep[modi]; i++)
    outrep[modi][i] = outbias[modi][i];
  /* propagate from the hidden layer to the output layer */
  for (k = 0; k < nhidrep[modi]; k++)
    for (i = 0; i < noutrep[modi]; i++)
      outrep[modi][i] += hidrep[modi][k] * who[modi][k][i];
  /* pass the weighted sums through the sigmoid to get activations
     of the output layer units */
  for (i = 0; i < noutrep[modi]; i++)
    outrep[modi][i] = 1.0 / (1.0 + exp (-outrep[modi][i]));
}


/*********************  initializations ******************************/

void
proc_init ()
/* initialize the processing modules */
{
  int modi;				/* module number */
  FILE *fp;				/* proc module definition file */
  char rest[MAXSTRL + 1];		/* temporarily holds the nhidreps */

  /* set up numbers of input/output words for convenience */
  /* one word representation wide */
  ninputs[SENTPARSMOD] = noutputs[SENTGENMOD] = 1;
  /* case-role representations */
  noutputs[SENTPARSMOD] = ninputs[STORYPARSMOD] = ninputs[CUEFORMMOD]
    = noutputs[ANSWERPRODMOD] = noutputs[STORYGENMOD] = ninputs[SENTGENMOD]
    = ncase;
  /* slot-filler representations */
  noutputs[STORYPARSMOD] = noutputs[CUEFORMMOD] = ninputs[STORYGENMOD] = nslot;
  /* answerprod has both case-role and slot-filler in its input */
  ninputs[ANSWERPRODMOD] = ncase + nslot;

  /* set up input/output dimensions for convenience */
  for (modi = 0; modi < NPROCMODULES; modi++)
    {
      ninprep[modi] = ninputs[modi] * nsrep;
      noutrep[modi] = noutputs[modi] * nsrep;
    }

  /* open the weight file */
  printf ("Reading processing modules from %s...", procfile);
  open_file (procfile, "r", &fp, REQUIRED);

  /* ignore everything until the hidden layer sizes */
  read_till_keyword (fp, PROCSIMU_NHIDREP, REQUIRED);

  /* read the size string */
  fgetline (fp, rest, MAXSTRL);
  /* convert the string to numbers and load */
  if (text2ints (nhidrep, NPROCMODULES, rest) != NPROCMODULES)
    {
      fprintf (stderr, "Wrong number of %s %s specifications\n",
	       procfile, PROCSIMU_NHIDREP);
      exit (EXIT_DATA_ERROR);
    }
  for (modi = 0; modi < NPROCMODULES; modi++)
    if (nhidrep[modi] > MAXHIDREP || nhidrep[modi] <= 0)
      {
	fprintf (stderr, "%s %s[%d] exceeds array size\n",
		 procfile, PROCSIMU_NHIDREP, modi);
	exit (EXIT_SIZE_ERROR);
      }
  /* then ignore everything until the weights */
  read_till_keyword (fp, PROCSIMU_WEIGHTS, REQUIRED);

  /* read the weights */
  proc_iterate_weights (readfun, fp, NOT_USED, NOT_USED);
  fclose (fp);
  printf ("Done.\n");
}


static void
proc_iterate_weights (dofun, fp, par1, par2)
/* read the weights from the file */
     /* reading function (as parameter so that randomization or writing
     could be done with proc_iterate_weights as well) */
     void (*dofun) __P((FILE *, double *, double, double));
     FILE *fp;				/* weight file */
     double par1, par2;			/* not used (in reading weights) */
{
  int modi, i, j, k;

  /* read weights for each of the processing modules */
  for (modi = 0; modi < NPROCMODULES; modi++)
    {
      /* input-to-hidden weights */
      for (i = 0; i < ninprep[modi]; i++)
	for (k = 0; k < nhidrep[modi]; k++)
	  (*dofun) (fp, &wih[modi][i][k], par1, par2);

      /* hidden layer biases */
      for (k = 0; k < nhidrep[modi]; k++)
	(*dofun) (fp, &hidbias[modi][k], par1, par2);

      /* previous hidden layer to hidden layer weights
         (for parsers and generators) */
      if (modi != CUEFORMMOD && modi != ANSWERPRODMOD)
	for (j = 0; j < nhidrep[modi]; j++)
	  for (k = 0; k < nhidrep[modi]; k++)
	    (*dofun) (fp, &wph[modi][j][k], par1, par2);

      /* hidden-to-output weights */
      for (k = 0; k < nhidrep[modi]; k++)
	for (i = 0; i < noutrep[modi]; i++)
	  (*dofun) (fp, &who[modi][k][i], par1, par2);

      /* output layer biases */
      for (i = 0; i < noutrep[modi]; i++)
	(*dofun) (fp, &outbias[modi][i], par1, par2);
    }
}


void
proc_clear_network (modi)
/* clear the activations and input/target indices and display strings */
     int modi;				/* module number */
{
  int i;

  for (i = 0; i < ninputs[modi]; i++)
    inputs[modi][i] = BLANKINDEX;
  for (i = 0; i < noutputs[modi]; i++)
    targets[modi][i] = BLANKINDEX;
  for (i = 0; i < ninprep[modi]; i++)
    inprep[modi][i] = 0.0;
  for (i = 0; i < noutrep[modi]; i++)
    outrep[modi][i] = 0.0;
  for (i = 0; i < noutrep[modi]; i++)
    tgtrep[modi][i] = 0.0;
  for (i = 0; i < nhidrep[modi]; i++)
    hidrep[modi][i] = 0.0;
  for (i = 0; i < nhidrep[modi]; i++)
    prevhidrep[modi][i] = 0.0;
  sprintf (net[modi].sequence, "%s", "");	/* clear word sequence */
  sprintf (net[modi].newitem, "%s", "");	/* clear new item in seq */
  sprintf (net[modi].log, "%s", "");		/* clear log line */
}