emacs-orgmode
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Orgmode] bug in org-store-link


From: Scott Otterson
Subject: [Orgmode] bug in org-store-link
Date: Tue, 26 Feb 2008 12:40:21 -0800
User-agent: Thunderbird 1.5.0.12 (X11/20071018)

Small bug in org store link. To reproduce, put the cursor on line 1007 and run org-store-link. Then use the result to create a hyperlink in an org file, which for me looks like:

[[file:~/lib/c/pkgs/quicknet/qnstrn.cc::ftr1_window_offset%20ftr1_window_len][call]]

Then click on that hyperlink. I get sent to line 899 instead of line 1007. It looks like the reason is that org tosses out puncutation (+>,). I've found that, when linking to source code, punctuation is a big deal, so, if possible, it would be nice if org mode was made sensitive to it.

Keep up the good work,

Scott

#ifndef NO_RCSID
const char* qnstrn_rcsid = 
    "$Header: /homes/scotto/lib/cvsroot/lib/c/pkgs/quicknet/qnstrn.cc,v 1.5 
2007/01/24 00:07:46 scotto Exp $";
#endif

#include <QN_config.h>
#include <assert.h>
#include <float.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#ifdef QN_HAVE_LIMITS_H
#include <limits.h>
#endif
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS (0)
#define EXIT_FAILURE (1)
#endif
#include <sys/types.h>
#ifdef QN_HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef QN_HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#include <unistd.h>

#if !QN_HAVE_DECL_SRAND48
extern "C" {
void srand48(long);
}
#endif

#ifdef QN_HAVE_SET_NEW_HANDLER
extern "C" {
    typedef void (*new_handler)(void);
    new_handler set_new_handler (new_handler);
}
#endif


#ifndef FILENAME_MAX
#define FILENAME_MAX (MAXPATHLEN)
#endif

#include "QuickNet.h"

static struct {
    char* ftr1_file;
    char* ftr1_format;
    int ftr1_width;
    char* ftr1_conf_file;
    char* ftr2_file;
    char* ftr2_format;
    int ftr2_width;
    char* unary_file;
    char* hardtarget_file;
    char* hardtarget_format;
    char* softtarget_file;
    char* softtarget_format;
    int softtarget_width;
    char* ftr1_norm_file;
    char* ftr2_norm_file;
    int ftr1_ftr_start;
    int ftr2_ftr_start;
    int ftr1_ftr_count;
    int ftr2_ftr_count;
    int hardtarget_lastlab_reject;
    int window_extent;
    int ftr1_window_offset;
    int ftr2_window_offset;
    int unary_window_offset;
    int hardtarget_window_offset;
    int softtarget_window_offset;
    int ftr1_window_len;
    int ftr2_window_len;
    int ftr1_delta_order;
    int ftr1_delta_win;
    char* ftr1_norm_mode_str;
    int ftr1_norm_mode;
    double ftr1_norm_am;
    double ftr1_norm_av;
    int ftr2_delta_order;
    int ftr2_delta_win;
    char* ftr2_norm_mode_str;
    int ftr2_norm_mode;
    double ftr2_norm_am;
    double ftr2_norm_av;
    long train_cache_frames;
    int train_cache_seed;
    long train_sent_start;
    long train_sent_count;
    char* train_sent_range;
    long cv_sent_start;
    long cv_sent_count;
    char* cv_sent_range;

    QN_Arg_ListFloat init_random_bias_min;
    QN_Arg_ListFloat init_random_bias_max;

    QN_Arg_ListFloat init_random_weight_min;
    QN_Arg_ListFloat init_random_weight_max;

    int init_random_seed;
    char* init_weight_file;
    char* log_weight_file;
    char* out_weight_file;
    char* learnrate_schedule;
    QN_Arg_ListFloat learnrate_vals;
    long learnrate_epochs;
    float learnrate_scale;
    int unary_size;
    int mlp3_input_size;
    int mlp3_hidden_size;
    int mlp3_output_size;
    char* mlp3_output_type;
    int mlp3_fx;                // NO LONGER USED
    int mlp3_weight_bits;       // NO LONGER USED
    int mlp3_in2hid_exp;        // NO LONGER USED
    int mlp3_hid2out_exp;       // NO LONGER USED
    int mlp3_bunch_size;
    int mlp3_blas;
    int mlp3_pp;
    int threads;
    int slaves;                 // NO LONGER USED
    char *cpu;                  // NO LONGER USED
    char* log_file;             // Stream for storing status messages.
    int verbose;
    int debug;                  // Debug level.
} config;

static void
set_defaults(void)
{
    static float default_learnrate[1] = { 0.008 };
    static float default_bias_min[1] = { -4.1 };
    static float default_bias_max[1] = { -3.9 };
    static float default_weight_min[1] = { -0.1 };
    static float default_weight_max[1] = { 0.1 };
    
    config.ftr1_file = "";
    config.ftr1_format = "pfile";
    config.ftr1_width = 0;
    config.ftr1_conf_file = "";
    config.ftr2_file = "";
    config.ftr2_format = "pfile";
    config.ftr2_width = 0;
    config.unary_file = "";
    config.hardtarget_file = "";
    config.hardtarget_format = "";
    config.softtarget_file = "";
    config.softtarget_format = "pfile";
    config.softtarget_width = 0;
    config.ftr1_norm_file = "";
    config.ftr2_norm_file = "";
    config.ftr1_ftr_start = 0;
    config.ftr2_ftr_start = 0;
    config.ftr1_ftr_count = 0;
    config.ftr2_ftr_count = 0;
    config.hardtarget_lastlab_reject = 0;
    config.window_extent = 9;
    config.ftr1_window_offset = 0;
    config.ftr2_window_offset = 4;
    config.unary_window_offset = 3;
    config.hardtarget_window_offset = 0;
    config.softtarget_window_offset = 0;
    config.ftr1_window_len = 9;
    config.ftr2_window_len = 0;
    config.ftr1_delta_order = 0;
    config.ftr1_delta_win = 9;
    config.ftr1_norm_mode_str = NULL;
    config.ftr1_norm_mode = QN_NORM_FILE;
    config.ftr1_norm_am = QN_DFLT_NORM_AM;
    config.ftr1_norm_av = QN_DFLT_NORM_AV;
    config.ftr2_delta_order = 0;
    config.ftr2_delta_win = 9;
    config.ftr2_norm_mode_str = NULL;
    config.ftr2_norm_mode = QN_NORM_FILE;
    config.ftr2_norm_am = QN_DFLT_NORM_AM;
    config.ftr2_norm_av = QN_DFLT_NORM_AV;
    config.train_cache_frames = 10000;
    config.train_cache_seed = 0;
    config.train_sent_start = 0;
    config.train_sent_count = INT_MAX;
    config.train_sent_range = 0;
    config.cv_sent_start = 0;
    config.cv_sent_count = INT_MAX;
    config.cv_sent_range = 0;

    config.init_random_bias_min.count = 1;
    config.init_random_bias_min.vals = &default_bias_min[0];
    config.init_random_bias_max.count = 1;
    config.init_random_bias_max.vals = &default_bias_max[0];

    config.init_random_weight_min.count = 1;
    config.init_random_weight_min.vals = &default_weight_min[0];
    config.init_random_weight_max.count = 1;
    config.init_random_weight_max.vals = &default_weight_max[0];

    config.init_random_seed = 0;
    config.init_weight_file = "";
    config.log_weight_file = "log%p.weights";
    config.out_weight_file = "out.weights";
    config.learnrate_schedule = "newbob";
    config.learnrate_vals.count = 1;
    config.learnrate_vals.vals = &default_learnrate[0];
    config.learnrate_epochs = 9999;
    config.learnrate_scale = 0.5;
    config.unary_size = 0;
    config.mlp3_input_size = 153;
    config.mlp3_hidden_size = 200;
    config.mlp3_output_size = 56;
    config.mlp3_output_type = "softmax";
    config.mlp3_fx = 0;
    config.mlp3_weight_bits = 32;
    config.mlp3_in2hid_exp = 2;
    config.mlp3_hid2out_exp = 2;
    config.mlp3_bunch_size = 16;
#ifdef QN_HAVE_LIBBLAS
    config.mlp3_blas = 1;
#else
    config.mlp3_blas = 0;
#endif
    config.mlp3_pp = 1;
    config.threads = 1;
    config.slaves = 0;
    config.cpu = "host";
    config.log_file = "-";
    config.verbose = 0;
    config.debug = 0;
}

QN_ArgEntry argtab[] =
{
{ NULL, "QuickNet MLP training program version " QN_VERSION, QN_ARG_DESC },
{ "ftr1_file", "Input feature file", QN_ARG_STR,
  &(config.ftr1_file), QN_ARG_REQ },
{ "ftr1_format", "Main feature file format 
[pfile,pre,lna,onlftr,srifile,srilist]", QN_ARG_STR,
  &(config.ftr1_format) },
{ "ftr1_width", "Main feature file feature columns", QN_ARG_INT,
  &(config.ftr1_width) },
{ "ftr1_conf_file", "Confidences for ftr1. Format and number of frames matches 
ftr1. If confidence dimension is 1, then the weight will be applied across all 
elements in a feature frame; otherwise, the dimension must match ft1.  ftr2 
confs not implemented", 
    QN_ARG_STR, &(config.ftr1_conf_file) },
{ "ftr2_file", "Second input feature file", QN_ARG_STR,
  &(config.ftr2_file) },
{ "ftr2_format","Secondary feature file format 
[pfile,pre,lna,onlftr,srifile,srilist]", QN_ARG_STR,
  &(config.ftr2_format) },
{ "ftr2_width", "Secondary feature file feature columns", QN_ARG_INT,
  &(config.ftr2_width) },
{ "unary_file", "Auxilliary unary file", QN_ARG_STR,
  &(config.unary_file) },
{ "hardtarget_file", "Target label file", QN_ARG_STR,
  &(config.hardtarget_file) },
{ "hardtarget_format", "Target label file format [pfile,pre,ilab]", QN_ARG_STR,
  &(config.hardtarget_format) },
{ "softtarget_file", "Target feature file", QN_ARG_STR,
  &(config.softtarget_file) },
{ "softtarget_format", "Target feature file format [pfile,pre,lna,onlftr]", 
QN_ARG_STR,
  &(config.softtarget_format) },
{ "softtarget_width", "Target feature file feature columns", QN_ARG_INT,
  &(config.softtarget_width) },
{ "ftr1_norm_file", "Normalization parameters for ftr1_file", QN_ARG_STR,
  &(config.ftr1_norm_file) },
{ "ftr2_norm_file", "Normalization parameters for ftr2_file", QN_ARG_STR,
  &(config.ftr2_norm_file) },
{ "ftr1_ftr_start", "First feature used from ftr1_file",
  QN_ARG_INT, &(config.ftr1_ftr_start) },
{ "ftr2_ftr_start", "First feature used from ftr2_file",
  QN_ARG_INT, &(config.ftr2_ftr_start) },
{ "ftr1_ftr_count", "Number of features used from ftr1_file",
  QN_ARG_INT, &(config.ftr1_ftr_count) },
{ "ftr2_ftr_count", "Number of features used from ftr2_file",
  QN_ARG_INT, &(config.ftr2_ftr_count) },
{ "hardtarget_lastlab_reject", "Last label value indicates no-train frames",
  QN_ARG_BOOL, &(config.hardtarget_lastlab_reject) },
{ "window_extent", "Extent of all windows (frames)", QN_ARG_INT,
  &(config.window_extent) },
{ "ftr1_window_offset", "Offset of window on ftr1_file (frames)",
  QN_ARG_INT, &(config.ftr1_window_offset) },
{ "ftr2_window_offset", "Offset of window on ftr2_file (frames)",
  QN_ARG_INT, &(config.ftr2_window_offset) },
{ "unary_window_offset", "Offset of window on unary_file (frames)",
  QN_ARG_INT, &(config.unary_window_offset) },
{ "hardtarget_window_offset", "Offset of window on target label file (frames)",
  QN_ARG_INT, &(config.hardtarget_window_offset) },
{ "softtarget_window_offset", "Offset of window on target feature file 
(frames)",
  QN_ARG_INT, &(config.softtarget_window_offset) },
{ "ftr1_window_len", "Length of window on ftr1_file (frames)", QN_ARG_INT,
  &(config.ftr1_window_len) },
{ "ftr2_window_len", "Length of window on ftr2_file (frames)", QN_ARG_INT,
  &(config.ftr2_window_len) },
{ "ftr1_delta_order", "Order of derivatives added to ftr1_file", QN_ARG_INT,
  &(config.ftr1_delta_order) },
{ "ftr1_delta_win", "Window size for ftr1_file delta-calculation", QN_ARG_INT,
  &(config.ftr1_delta_win) },
{ "ftr1_norm_mode", "Normalization mode (file/utts/online)", QN_ARG_STR,
  &(config.ftr1_norm_mode_str) },
{ "ftr1_norm_alpha_m", "Update constant for online norm means", QN_ARG_DOUBLE,
  &(config.ftr1_norm_am) },
{ "ftr1_norm_alpha_v", "Update constant for online norm vars", QN_ARG_DOUBLE,
  &(config.ftr1_norm_av) },
{ "ftr2_delta_order", "Order of derivatives added to ftr2_file", QN_ARG_INT,
  &(config.ftr2_delta_order) },
{ "ftr2_delta_win", "Window size for ftr2_file delta-calculation", QN_ARG_INT,
  &(config.ftr2_delta_win) },
{ "ftr2_norm_mode", "Normalization mode (file/utts/online)", QN_ARG_STR,
  &(config.ftr2_norm_mode_str) },
{ "ftr2_norm_alpha_m", "Update constant for online norm means", QN_ARG_DOUBLE,
  &(config.ftr2_norm_am) },
{ "ftr2_norm_alpha_v", "Update constant for online norm vars", QN_ARG_DOUBLE,
  &(config.ftr2_norm_av) },
{ "train_cache_frames", "Number of training frames in cache",
  QN_ARG_LONG, &(config.train_cache_frames) },
{ "train_cache_seed", "Training presentation randomization seed",
  QN_ARG_INT, &(config.train_cache_seed) },
{ "train_sent_start", "Number of first training sentence",
  QN_ARG_LONG, &(config.train_sent_start) },
{ "train_sent_count", "Number of training sentences",
  QN_ARG_LONG, &(config.train_sent_count) },
{ "train_sent_range", "Training sentence indices in QN_Range(3) format",
  QN_ARG_STR, &(config.train_sent_range) },
{ "cv_sent_start", "Number of first cross validation sentence",
  QN_ARG_LONG, &(config.cv_sent_start) },
{ "cv_sent_count", "Number of cross validation sentences",
  QN_ARG_LONG, &(config.cv_sent_count) },
{ "cv_sent_range", "Cross validation sentence indices in QN_Range(3) format",
  QN_ARG_STR, &(config.cv_sent_range) },
{ "init_random_bias_min", "Minimum random bias (per layer)", QN_ARG_LIST_FLOAT,
  &(config.init_random_bias_min) },
{ "init_random_bias_max", "Maximum random bias (per layer)", QN_ARG_LIST_FLOAT,
  &(config.init_random_bias_max) },
{ "init_random_weight_min", "Minimum random weight (per layer)", 
QN_ARG_LIST_FLOAT,
  &(config.init_random_weight_min) },
{ "init_random_weight_max", "Maximum random weight (per layer)", 
QN_ARG_LIST_FLOAT,
  &(config.init_random_weight_max) },
{ "init_random_seed", "Net initialization random number seed",
  QN_ARG_INT, &(config.init_random_seed) },
{ "init_weight_file", "Input weight file", QN_ARG_STR,
  &(config.init_weight_file) },
{ "log_weight_file", "Log weight file", QN_ARG_STR,
  &(config.log_weight_file) },
{ "out_weight_file", "Output weight file", QN_ARG_STR,
  &(config.out_weight_file) },
{ "learnrate_schedule", "LR schedule type [newbob,list,smoothdecay]",
      QN_ARG_STR, &(config.learnrate_schedule) },
{ "learnrate_vals", "Learning rates",
      QN_ARG_LIST_FLOAT, &(config.learnrate_vals) },
{ "learnrate_epochs", "Maximum number of epochs", QN_ARG_LONG,
  &(config.learnrate_epochs) },
{ "learnrate_scale", "Scale factor of successive learning rates", QN_ARG_FLOAT,
  &(config.learnrate_scale) },
{ "unary_size", "Number of unary inputs to net",
  QN_ARG_INT, &(config.unary_size)},
{ "mlp3_input_size", "Number of units in input layer",
  QN_ARG_INT, &(config.mlp3_input_size)},
{ "mlp3_hidden_size","Number of units in hidden layer",
  QN_ARG_INT, &(config.mlp3_hidden_size) },
{ "mlp3_output_size","Number of units in output layer",
  QN_ARG_INT, &(config.mlp3_output_size) },
{ "mlp3_output_type","Type of non-linearity in MLP output layer 
[sigmoid,sigmoidx,softmax]",
  QN_ARG_STR, &(config.mlp3_output_type) },
{ "mlp3_fx","NO LONGER USED",
  QN_ARG_BOOL, &(config.mlp3_fx) },
{ "mlp3_weight_bits","NO LONGER USED",
  QN_ARG_INT, &(config.mlp3_weight_bits) },
{ "mlp3_in2hid_exp","NO LONGER USED",
  QN_ARG_INT, &(config.mlp3_in2hid_exp) },
{ "mlp3_hid2out_exp","NO LONGER USED",
  QN_ARG_INT, &(config.mlp3_hid2out_exp) },
{ "mlp3_bunch_size","Size of bunches used in MLP training",
  QN_ARG_INT, &(config.mlp3_bunch_size) },
{ "mlp3_blas","Use BLAS libraries",
  QN_ARG_BOOL, &(config.mlp3_blas) },
{ "mlp3_pp","Use internal high-performance libraries",
  QN_ARG_BOOL, &(config.mlp3_pp) },
{ "mlp3_threads","Number of threads in MLP object",
  QN_ARG_INT, &(config.threads) },
{ "slaves","NO LONGER USED",
  QN_ARG_INT, &(config.slaves) },
{ "cpu","NO LONGER USED",
  QN_ARG_STR, &(config.cpu) },
{ "log_file", "File for status messages", QN_ARG_STR, &(config.log_file) },
{ "verbose", "Output extra status messages",
  QN_ARG_BOOL, &(config.verbose) },
{ "debug", "Level of internal diagnostic output",
  QN_ARG_INT, &(config.debug) },
{ NULL, NULL, QN_ARG_NOMOREARGS }
};

// QN_open_ftrstream, QN_open_ftrfile and QN_close_ftrfiles all moved to 
QN_utils.cc

// A function to create a train and cross validation stream for a given
// feature file.  Also handles opening multiple files if 
// stream comes from a sequence of files.

void
create_ftrstreams(int debug, const char* dbgname, char* filename,
                  const char* format, size_t width,
                  FILE* normfile, size_t first_ftr, size_t num_ftrs,
                  size_t train_sent_start, size_t train_sent_count,
                  char* train_sent_range, 
                  size_t cv_sent_start, size_t cv_sent_count,
                  char* cv_sent_range, 
                  size_t window_extent, size_t window_offset,
                  size_t window_len, 
                  int delta_order, int delta_win,  
                  int norm_mode, double norm_am, double norm_av, 
                  size_t train_cache_frames, int train_cache_seed,
                  QN_InFtrStream** train_str_ptr, QN_InFtrStream** cv_str_ptr)
{
    QN_InFtrStream* ftr_str = NULL;     // Temporary stream holder.
    int index = 1;                      // training always requires indexed
    int buffer_frames = 500;

    ftr_str = QN_build_ftrstream(debug, dbgname, filename, format, 
                              width, index, normfile, 
                              first_ftr, num_ftrs, 
                              0, QN_ALL, // do utt selection ourselves
                              buffer_frames, 
                              delta_order, delta_win, 
                              norm_mode, norm_am, norm_av);

    // Create training and cross-validation streams.
    QN_InFtrStream_Cut* train_ftr_str = NULL;
    QN_InFtrStream_Cut2* cv_ftr_str = NULL;

    if (train_sent_range != 0) {
        if ( !(train_sent_start == 0 && train_sent_count == QN_ALL) ) {
            QN_ERROR("create_ftrstreams",
                     "You cannot specify train_sents by both range "
                     "and start/count.");
        }
    }

    if (cv_sent_range != 0) {
        if ( !(cv_sent_start == 0 && cv_sent_count == QN_ALL) ) {
            QN_ERROR("create_ftrstreams",
                     "You cannot specify cv_sents by both range "
                     "and start/count.");
        }
    }

    if ( (train_sent_range == 0 && cv_sent_range != 0) \
         || (train_sent_range != 0 && cv_sent_range == 0) ) {
        QN_ERROR("create_ftrstreams",
                 "If you use ranges for one of train_sents or cv_sents, "
                 "you must use it for both.");
    }

    if (train_sent_range == 0) {
        // Using old-style start & count, not range strings
        QN_InFtrStream_Cut* fwd_ftr_str 
            = new QN_InFtrStream_Cut(debug, dbgname, *ftr_str,
                                               train_sent_start, 
                                               train_sent_count,
                                               cv_sent_start, 
                                               cv_sent_count);
        train_ftr_str = (QN_InFtrStream_Cut*)fwd_ftr_str;
    } else {
        // Using range strings
        QN_InFtrStream_CutRange* fwd_ftr_str 
            = new QN_InFtrStream_CutRange(debug, dbgname, *ftr_str, 
                                          train_sent_range, 
                                          cv_sent_range);
        train_ftr_str = (QN_InFtrStream_Cut*)fwd_ftr_str;
    }
    cv_ftr_str = new QN_InFtrStream_Cut2(*train_ftr_str);

    // Create training and CV windows.
    size_t bot_margin = window_extent - window_offset - window_len;
    QN_InFtrStream_RandWindow* train_winftr_str =
        new QN_InFtrStream_RandWindow(debug, dbgname,
                                      *train_ftr_str, window_len,
                                      window_offset, bot_margin,
                                      train_cache_frames, train_cache_seed
            );
    QN_InFtrStream_SeqWindow* cv_winftr_str =
        new QN_InFtrStream_SeqWindow(debug, dbgname,
                                      *cv_ftr_str, window_len,
                                      window_offset, bot_margin
                                      );
    *train_str_ptr = train_winftr_str;
    *cv_str_ptr = cv_winftr_str;
}

// A function to create a train and cross validation stream for a given
// label file.

void
create_labstreams(int debug, const char* dbgname, FILE* hardtarget_file,
                  const char* format, size_t width,
                  size_t train_sent_start, size_t train_sent_count,
                  char* train_sent_range, 
                  size_t cv_sent_start, size_t cv_sent_count,
                  char* cv_sent_range, 
                  size_t window_extent, size_t window_offset,
                  size_t train_cache_frames, int train_cache_seed,
                  QN_InLabStream** train_str_ptr, QN_InLabStream** cv_str_ptr)
{
    QN_InLabStream* lab_str;    // Temporary stream holder.

    // Convert the file descriptor into a stream.
    if (strcmp(format, "pfile")==0)
    {
        QN_InFtrLabStream_PFile* pfile_str =
            new QN_InFtrLabStream_PFile(debug, // Select debugging.
                                        dbgname, // Debugging tag.
                                        hardtarget_file, // Label file.
                                        1 // Indexed flag.
                );
        if (pfile_str->num_labs()!=1)
        {
            QN_ERROR("create_labstreams",
                     "Label file has %lu features, should only be 1.",
                     (unsigned long) pfile_str->num_labs() );
        }
        lab_str = pfile_str;
    }
    else if (strcmp(format, "pre")==0)
    {
        QN_InFtrLabStream_PreFile* prefile_str =
            new QN_InFtrLabStream_PreFile(debug, // Select debugging.
                                          dbgname, // Debugging tag.
                                          hardtarget_file, // Label file.
                                          width, // No of ftrs.
                                          1 // Indexed flag.
                );
        lab_str = prefile_str;
    }
    else if (strcmp(format, "ilab")==0)
    {
        QN_InLabStream_ILab* ilab_str =
            new QN_InLabStream_ILab(debug, // Select debugging.
                                    dbgname, // Debugging tag.
                                    hardtarget_file, // Label file.
                                    1 // Indexed flag.
                                    );
        lab_str = ilab_str;
    }
    else
    {
        QN_ERROR(dbgname, "unknown label file format '%s'.", format);
        lab_str = NULL;
    }
        

    // Create training and cross-validation streams.
    QN_InLabStream_Cut* train_lab_str = NULL;
    QN_InLabStream_Cut2* cv_lab_str = NULL;
    if (train_sent_range != 0) {
        if ( !(train_sent_start == 0 && train_sent_count == QN_ALL) ) {
            QN_ERROR("create_labstreams",
                     "You cannot specify train_sents by both range "
                     "and start/count.");
        }
    }

    if (cv_sent_range != 0) {
        if ( !(cv_sent_start == 0 && cv_sent_count == QN_ALL) ) {
            QN_ERROR("create_labstreams",
                     "You cannot specify cv_sents by both range "
                     "and start/count.");
        }
    }

    if ( (train_sent_range == 0 && cv_sent_range != 0) \
         || (train_sent_range != 0 && cv_sent_range == 0) ) {
        QN_ERROR("create_labstreams",
                 "If you use ranges for one of train_sents or cv_sents, "
                 "you must use it for both.");
    }

    if (train_sent_range == 0) {
        // Using old-style start & count, not range strings
        QN_InLabStream_Cut* fwd_lab_str 
            = new QN_InLabStream_Cut(debug, dbgname, *lab_str,
                                               train_sent_start, 
                                               train_sent_count,
                                               cv_sent_start, 
                                               cv_sent_count);
        train_lab_str = (QN_InLabStream_Cut*)fwd_lab_str;
    } else {
        // Using range strings
        QN_InLabStream_CutRange* fwd_lab_str 
            = new QN_InLabStream_CutRange(debug, dbgname, *lab_str, 
                                          train_sent_range, 
                                          cv_sent_range);
        train_lab_str = (QN_InLabStream_Cut*)fwd_lab_str;
    }
    cv_lab_str = new QN_InLabStream_Cut2(*train_lab_str);

    // Create training and CV windows.

    const size_t window_len = 1;
    size_t bot_margin = window_extent - window_offset - window_len;
    QN_InLabStream_RandWindow* train_winlab_str =
        new QN_InLabStream_RandWindow(debug, dbgname,
                                      *train_lab_str, window_len,
                                      window_offset, bot_margin,
                                      train_cache_frames, train_cache_seed
            );
    QN_InLabStream_SeqWindow* cv_winlab_str =
        new QN_InLabStream_SeqWindow(debug, dbgname,
                                      *cv_lab_str, window_len,
                                      window_offset, bot_margin
                                      );
    *train_str_ptr = train_winlab_str;
    *cv_str_ptr = cv_winlab_str;
}

void
create_mlp(int debug, const char*,
           size_t n_input, size_t n_hidden, size_t n_output, 
           const char* mlp3_output_type, int mlp3_bunch_size,
           int threads, bool hasConf, QN_MLP** mlp_ptr)
{
    // Create MLP and load weights.
    QN_MLP* mlp3 = NULL;

    QN_OutputLayerType outlayer_type;
    if (strcmp(mlp3_output_type, "sigmoid")==0) {
        outlayer_type = QN_OUTPUT_SIGMOID;
    } else if (strcmp(mlp3_output_type, "sigmoidx")==0) {
        outlayer_type = QN_OUTPUT_SIGMOID_XENTROPY;
    } else if (strcmp(mlp3_output_type, "softmax")==0) {
        outlayer_type = QN_OUTPUT_SOFTMAX;
    } else {
        QN_ERROR("create_mlp", "unknown output unit type '%s'.",
                 mlp3_output_type);
        outlayer_type = QN_OUTPUT_SIGMOID;
    }


    if (mlp3_bunch_size == 0) {
      assert(!hasConf); // confidences not implemented
      // NOT bunch
            if (config.threads==1)
            {
                    mlp3 = new QN_MLP_OnlineFl3(debug, "train",
                                                n_input, n_hidden, n_output,
                                                outlayer_type);
            }
            else
            {
                    QN_ERROR("create_mlp", "threads must be 1 for online "
                             "training.");
            }
    } else {
            // Bunch
            if (threads>1)
            {
#ifdef QN_HAVE_LIBPTHREAD
                    if (threads>mlp3_bunch_size)
                    {
                            QN_ERROR("create_mlp", "number of threads must "
                                     "be less than the bunch size.");
                    }
                    else
                    {
                      // Bunch threaded
                      assert(!hasConf); // confidences not implemented

                      mlp3 = new QN_MLP_ThreadFl3(debug, "train",
                                                  n_input, n_hidden,
                                                  n_output,
                                                  outlayer_type,
                                                  mlp3_bunch_size,
                                                  threads);
                    }
#else
                    QN_ERROR("create_mlp",
                             "cannot use multiple threads as libpthread "
                             "was not linked with this executable.");
#endif
            }
            else if (threads==1)
            {
                    // Bunch unthreaded
                    mlp3 = new QN_MLP_BunchFl3(debug, "train",
                                               n_input, n_hidden, 
                                               n_output, outlayer_type, 
                                               mlp3_bunch_size);
            }
            else
            {
                    QN_ERROR("create_mlp","threads must be >= 1.");
            }
    }
    *mlp_ptr = mlp3;
}

void
create_learnrate_schedule(int, const char*,
                          const char* learnrate_schedule,
                          float* learnrate_vals,
                          size_t learnrate_count,
                          float learnrate_scale,
                          size_t learnrate_epochs,
                          QN_RateSchedule** lr_schedule)
{
    QN_RateSchedule* rate_sched;
    if (learnrate_scale>1.0)
    {
        QN_ERROR("create_learnrate_schedule", "Learning rate scale is %g, but "
                 "it should be less that 1.0.");
    } 
    if (strcmp(learnrate_schedule, "newbob")==0)
    {
        rate_sched = new QN_RateSchedule_NewBoB(*learnrate_vals,
                                                learnrate_scale,
                                                0.5f, 0.5f,
                                                100.0f,learnrate_epochs);
    }
    else if (strcmp(learnrate_schedule, "list")==0)
    {
        long count;

        if (learnrate_epochs < learnrate_count)
            count = learnrate_epochs;
        else
            count = learnrate_count;
        rate_sched = new QN_RateSchedule_List(learnrate_vals, count);
    }
    else if (strcmp(learnrate_schedule, "smoothdecay")==0)
      {
        size_t search_epochs;

        if (learnrate_count<3 || learnrate_count>4) {
          QN_ERROR(NULL,"learnrate_vals should have 3 or 4 values if 
learnrate_schedule is smoothdecay");
        }
        
        if (learnrate_count==4) {
          search_epochs=(size_t)learnrate_vals[3];
        } else {
          search_epochs=1;
        }

        QN_OUTPUT("Setting up smooth decay learning rate 
(lr=%.6f,decay=%.6f,stopcriterion=%.6f",learnrate_vals[0],learnrate_vals[1],learnrate_vals[2]);
        rate_sched = new QN_RateSchedule_SmoothDecay(learnrate_vals[0],
                                                     learnrate_vals[1],
                                                     learnrate_vals[2],
                                                     search_epochs,
                                                     100.0f, 0,
                                                     learnrate_epochs);
      }
    else
    {
        QN_ERROR("create_learnrate_schedule",
                 "Unknown learning rate schedule '%s'.",
                 learnrate_schedule);
        rate_sched = NULL;
    }
    *lr_schedule = rate_sched;
}

void
qnstrn()
{
    int verbose = config.verbose;
    time_t now;

    time(&now);

// A note for the logfile, including some system info.
    QN_output_sysinfo("qnstrn");
    QN_OUTPUT("Program start: %.24s.", ctime(&now));

// Open files and provisionally check arguments.
    if (verbose>0)
    {
        QN_OUTPUT("Opening feature file...");
    }

    // ftr files are now opened inside create_ftrstreams in order to 
    // accommodate multiple pasted-together files

    // ftr1_file.
    //    enum { FTRFILE1_BUF_SIZE = 0x8000 };
    //    const char* ftr1_file = config.ftr1_file;
    //    FILE* ftr1_fp = QN_open(ftr1_file, "r");

    // ftr2_file.
    //    enum { FTRFILE2_BUF_SIZE = 0x8000 };
    //    const char* ftr2_file = config.ftr2_file;
    //    FILE* ftr2_fp = NULL;
    //    char* ftr2_buf = NULL;
    //    if (strcmp(ftr2_file, "")!=0)
    //    {
    //  ftr2_fp = QN_open(ftr2_file, "r");
    //    }

    bool hasConf=strlen(config.ftr1_conf_file)>0;
    if(hasConf)
      assert(strcmp(config.ftr1_format, "pfile")==0); // only implemented for 
pfiles

    // unary_file.
    enum { UNARYFILE_BUF_SIZE = 0x8000 };
    const char* unary_file = config.unary_file;
    FILE* unary_fp = NULL;
    char* unary_buf = NULL;
    if (strcmp(unary_file, "")!=0)
    {
        assert(!hasConf);
        unary_fp = QN_open(unary_file, "r");
        unary_buf = new char[UNARYFILE_BUF_SIZE];
        assert(setvbuf(unary_fp, unary_buf, _IOFBF,
                       UNARYFILE_BUF_SIZE)==0);
    }

    const char* hardtarget_file = config.hardtarget_file;
    const char* softtarget_file = config.softtarget_file;
    FILE* hardtarget_fp = NULL;
    //    FILE* softtarget_fp = NULL;
    char* hardtarget_buf = NULL;
    //    char* softtarget_buf = NULL;
    int lastlab_reject = config.hardtarget_lastlab_reject;
    if (strcmp(hardtarget_file, "")!=0 && strcmp(softtarget_file, "")==0)
    {
        // hardtarget_file.
        enum { LABFILE_BUF_SIZE = 0x8000 };
        hardtarget_fp = QN_open(hardtarget_file, "r");
        hardtarget_buf = new char[LABFILE_BUF_SIZE];
        assert(setvbuf(hardtarget_fp, hardtarget_buf, _IOFBF,
                       LABFILE_BUF_SIZE)==0);
    }
    else if (strcmp(hardtarget_file, "")==0 && strcmp(softtarget_file, "")!=0)
    {
        // opened within create_ftrstream

        // softtarget_file.
        //      enum { LABFILE_BUF_SIZE = 0x8000 };
        //      softtarget_fp = QN_open(softtarget_file, "r");
        //      softtarget_buf = new char[LABFILE_BUF_SIZE];
        if (lastlab_reject)
        {
            QN_ERROR(NULL, "hardtarget_lastlab_reject cannot be true if no "
                     "hardtarget_file is specified");
        }
    }
    else
    {
        QN_ERROR(NULL, "must specify one and only one of hardtarget_file "
                 "and softtarget_file");
    }
        

    // ftr1_norm_file.
    FILE* ftr1_norm_fp = NULL;
    const char* ftr1_norm_file = config.ftr1_norm_file;
    if (strcmp(ftr1_norm_file, "")!=0)
    {
        ftr1_norm_fp = QN_open(ftr1_norm_file, "r");
    }
    
    // ftr2_norm_file.
    FILE* ftr2_norm_fp = NULL;
    const char* ftr2_norm_file = config.ftr2_norm_file;
    if (strcmp(ftr2_norm_file, "")!=0)
    {
        if (strcmp(config.ftr2_file, "")==0)
            QN_ERROR(NULL, "ftr2_norm_file is specified but ftr2_file "
                     "is not.");
        else if (config.ftr2_ftr_count==0)
            QN_ERROR(NULL, "ftr2_norm_file is specified but ftr2_ftr_count "
                     "is 0.");
        else
            ftr2_norm_fp = QN_open(ftr2_norm_file, "r");
    }

    // Weight files.
    FILE* init_weight_fp = NULL;
    const char* init_weight_file = config.init_weight_file;
    if (strcmp(init_weight_file, "")!=0)
    {
        init_weight_fp = QN_open(init_weight_file, "r");
    }
    FILE* out_weight_fp = NULL;
    const char* out_weight_file = config.out_weight_file;
    out_weight_fp = QN_open(out_weight_file, "w");

    // Windowing.
    int window_extent = config.window_extent;
    if (window_extent<0 || window_extent>1000)
    {
        QN_ERROR(NULL, "window_extent must be in range 0-1000.");
    }
    int ftr1_window_offset = config.ftr1_window_offset;
    if (ftr1_window_offset<0 || ftr1_window_offset>=window_extent)
    {
        QN_ERROR(NULL, "ftr1_window_offset must be less than "
                 " window_extent.");
    }
    int ftr1_window_len = config.ftr1_window_len;
    if (ftr1_window_len<=0)
    {
        QN_ERROR(NULL, "ftr1_window_len must be greater than 0.");
    }
    if ((ftr1_window_offset + ftr1_window_len) > window_extent)
    {
        QN_ERROR(NULL, "ftr1_window_offset+ftr1_window_len must be "
                 "less than window_extent.");
    }
    int ftr2_window_offset = config.ftr2_window_offset;
    int ftr2_window_len = config.ftr2_window_len;
    // don't test ftr2_window_offset unless we have a file
    if (strcmp(config.ftr2_file, "")!= 0 && config.ftr2_ftr_count > 0) {
      if (ftr2_window_offset<0 || ftr2_window_offset>=window_extent)
        {
          QN_ERROR(NULL, "ftr2_window_offset must be less than "
                   " window_extent.");
        }
      if (ftr2_window_len<0)
        {
          QN_ERROR(NULL, "ftr2_window_len must be positive.");
        }
      if ((ftr2_window_offset + ftr2_window_len) > window_extent)
        {
          QN_ERROR(NULL, "ftr2_window_offset+ftr2_window_len must be "
                   "less than window_extent.");
        }
    }
    // Don't worry about the unary_window_offset unless there is actually
    // a unary_file (default value of 3 causes error for window_extent=1)
    int unary_window_offset = config.unary_window_offset;
    if ( (strcmp(unary_file, "")!=0) \
         && (unary_window_offset<0 || unary_window_offset>=window_extent))
    {
        QN_ERROR(NULL, "unary_window_offset must be less than "
                 " window_extent.");
    }
    int hardtarget_window_offset = config.hardtarget_window_offset;
    if (hardtarget_window_offset<0 || hardtarget_window_offset>=window_extent)
    {
        QN_ERROR(NULL, "hardtarget_window_offset must be less than "
                 " window_extent.");
    }
    int softtarget_window_offset = config.softtarget_window_offset;
    if (softtarget_window_offset<0 || softtarget_window_offset>=window_extent)
    {
        QN_ERROR(NULL, "softtarget_window_offset must be less than "
                 " window_extent.");
    }

    // Check for overlapping training and CV ranges.
    size_t train_sent_start = config.train_sent_start;
    size_t train_sent_count = (config.train_sent_count==INT_MAX) ?
        (size_t) QN_ALL : config.train_sent_count;
    size_t last_train_sent = (train_sent_count==QN_ALL) ? 
        INT_MAX : train_sent_start + train_sent_count - 1;
    char* train_sent_range = config.train_sent_range;
    size_t cv_sent_start = config.cv_sent_start;
    size_t cv_sent_count = (config.cv_sent_count==INT_MAX) ?
        (size_t) QN_ALL : config.cv_sent_count;
    char* cv_sent_range = config.cv_sent_range;
    size_t last_cv_sent = (cv_sent_count==QN_ALL) ? 
        INT_MAX : cv_sent_start + cv_sent_count - 1;
    if (train_sent_range == 0 && cv_sent_range == 0 &&
        ((cv_sent_start>=train_sent_start && cv_sent_start<=last_train_sent)
         || (last_cv_sent>=train_sent_start && last_cv_sent<=last_train_sent)))
    {
        QN_WARN(NULL, "training and cv sentence ranges overlap.");
    }

    // Check for mlp3_input_size consistency.
    size_t ftr1_ftr_start = config.ftr1_ftr_start;
    size_t ftr2_ftr_start = config.ftr2_ftr_start;
    size_t ftr1_ftr_count = config.ftr1_ftr_count;
    size_t ftr2_ftr_count = config.ftr2_ftr_count;
    size_t unary_size = config.unary_size;
    size_t ftrfile_num_input = ftr1_ftr_count  * ftr1_window_len
        + ftr2_ftr_count * ftr2_window_len + unary_size;
    size_t mlp3_input_size = config.mlp3_input_size;
    size_t mlp3_hidden_size = config.mlp3_hidden_size;
    size_t mlp3_output_size = config.mlp3_output_size;
    if (ftrfile_num_input!=mlp3_input_size)
    {
        QN_ERROR(NULL, "number of inputs to the net %d does not equal width"
                 " of data stream from feature files %d.", mlp3_input_size, 
                 ftrfile_num_input);
    }

    // Sentence and randomization details.
    long train_cache_frames = config.train_cache_frames;
    int train_cache_seed = config.train_cache_seed;
    if (train_cache_frames<1000)
    {
        QN_ERROR(NULL, "train_cache_frames must be greater than 1000.");
    }

    
    int init_random_seed = config.init_random_seed;
    int debug = config.debug;

    // Do ftr1_file stream creation.
    QN_InFtrStream* ftr1_train_str = NULL;
    QN_InFtrStream* ftr1_cv_str = NULL;
    create_ftrstreams(debug, "ftr1_file", config.ftr1_file,
                      config.ftr1_format, config.ftr1_width,
                      ftr1_norm_fp,
                      ftr1_ftr_start, ftr1_ftr_count,
                      train_sent_start, train_sent_count,
                      train_sent_range, 
                      cv_sent_start, cv_sent_count,
                      cv_sent_range, 
                      window_extent,
                      ftr1_window_offset, ftr1_window_len,
                      config.ftr1_delta_order, config.ftr1_delta_win, 
                      config.ftr1_norm_mode, 
                      config.ftr1_norm_am, config.ftr1_norm_av,  
                      train_cache_frames, train_cache_seed,
                      &ftr1_train_str, &ftr1_cv_str);
                      
    // Confidences for ftr1_train (must be same format, size as ftr1)
    QN_InFtrStream* ftrfile_conf_train_str = NULL;
    QN_InFtrStream* ftrfile_conf_cv_str = NULL;
    if(hasConf) {
      create_ftrstreams(debug, "ftr1_conf_file", config.ftr1_conf_file,
                        config.ftr1_format, 0, // width=0 allows conf_dim==1
                        NULL, // prevent normalization
                        ftr1_ftr_start, 0, // count==0 allows conf_dim==1
                        train_sent_start, train_sent_count,
                        train_sent_range, 
                        cv_sent_start, cv_sent_count,
                        cv_sent_range, 
                        window_extent,
                        ftr1_window_offset, ftr1_window_len,
                        config.ftr1_delta_order, config.ftr1_delta_win, 
                        config.ftr1_norm_mode, 
                        config.ftr1_norm_am, config.ftr1_norm_av,  
                        train_cache_frames, train_cache_seed,
                        &ftrfile_conf_train_str, &ftrfile_conf_cv_str);
    }
                      
    // Do ftr2_file stream creation.
    QN_InFtrStream* ftr2_train_str = NULL;
    QN_InFtrStream* ftr2_cv_str = NULL;
    if (strcmp(config.ftr2_file, "")!=0)
    {
        assert(!hasConf); // confs not implemented for ftr2

        if (config.ftr2_ftr_count==0)
            QN_WARN(NULL, "ftr2_file is set but ftr2_ftr_count is 0.");
        create_ftrstreams(debug, "ftr2_file", config.ftr2_file,
                          config.ftr2_format, config.ftr2_width,
                          ftr2_norm_fp,
                          ftr2_ftr_start, ftr2_ftr_count,
                          train_sent_start, train_sent_count,
                          train_sent_range, 
                          cv_sent_start, cv_sent_count,
                          cv_sent_range, 
                          window_extent,
                          ftr2_window_offset, ftr2_window_len,
                          config.ftr2_delta_order, config.ftr2_delta_win, 
                          config.ftr2_norm_mode, 
                          config.ftr2_norm_am, config.ftr2_norm_av,  
                          train_cache_frames, train_cache_seed,
                          &ftr2_train_str, &ftr2_cv_str);
    }

    // Merge the two training feature streams.
    QN_InFtrStream* ftrfile_train_str;
    QN_InFtrStream* ftrfile_cv_str;
    if (ftr2_train_str!=NULL)
    {
      assert(ftr2_cv_str!=NULL);
      ftrfile_train_str = new QN_InFtrStream_JoinFtrs(debug, "train_ftrfile",
                                                      *ftr1_train_str,
                                                      *ftr2_train_str);
      ftrfile_cv_str = new QN_InFtrStream_JoinFtrs(debug, "cv_ftrfile",
                                                   *ftr1_cv_str,
                                                   *ftr2_cv_str);
    }
    else
    {
        assert(ftr2_cv_str==NULL);
        assert(ftr2_train_str==NULL);
        ftrfile_train_str = ftr1_train_str;
        ftrfile_cv_str = ftr1_cv_str;
    }

    // If necessary, add the unary input feature.
    if (unary_fp!=NULL)
    {
        assert(!hasConf); // confs not implemented for this
        QN_InLabStream* unary_train_str = NULL;
        QN_InLabStream* unary_cv_str = NULL;
        
        create_labstreams(debug, "unary", unary_fp,
                          "pfile", 0,
                          train_sent_start, train_sent_count,
                          train_sent_range, 
                          cv_sent_start, cv_sent_count,
                          cv_sent_range, 
                          window_extent,
                          unary_window_offset,
                          train_cache_frames, train_cache_seed,
                          &unary_train_str, &unary_cv_str);

        // Convert the unary input label into a feature stream.
        QN_InFtrStream* unaryftr_train_str = NULL;
        QN_InFtrStream* unaryftr_cv_str = NULL;
        
        unaryftr_train_str = new QN_InFtrStream_OneHot(debug,
                                                       "train_unaryfile",
                                                       *unary_train_str,
                                                       unary_size);
        unaryftr_cv_str = new QN_InFtrStream_OneHot(debug,
                                                    "cv_unaryfile",
                                                    *unary_cv_str,
                                                    unary_size);
                                                   
        // Merge in the feature streams.
        ftrfile_train_str = new QN_InFtrStream_JoinFtrs(debug,
                                                        "train_unaryfile",
                                                        *ftrfile_train_str,
                                                        *unaryftr_train_str);
        ftrfile_cv_str = new QN_InFtrStream_JoinFtrs(debug, "cv_unaryfile",
                                                     *ftrfile_cv_str,
                                                     *unaryftr_cv_str);
        
    }
    

    QN_InLabStream* hardtarget_train_str = NULL;
    QN_InLabStream* hardtarget_cv_str = NULL;
    QN_InFtrStream* softtarget_train_str = NULL;
    QN_InFtrStream* softtarget_cv_str = NULL;

    // Does config.ftr1_file refer to just a single file?
    int ftr1_onefile = 1;
    if (strchr(config.ftr1_file, ',') != NULL) {
        // filename looks like a comma-separated list
        ftr1_onefile = 0;
        // won't try to run pathcmp on it.
    }

    if (hardtarget_fp!=NULL)
    {
        // Do hardtarget stream creation.

        // Handle formats where we need to know the number of ftrs to
        // extract the labels.
        // A bit of a hack!!
        size_t hardtarget_width;
        if (ftr1_onefile && QN_pathcmp(config.ftr1_file, hardtarget_file)==0)
            hardtarget_width = config.ftr1_width;
        else
            hardtarget_width = 0;
        char* hardtarget_format = config.hardtarget_format;
        if (strcmp(hardtarget_format, "")==0)
            hardtarget_format = config.ftr1_format;
        
        create_labstreams(debug, "hardtarget", hardtarget_fp,
                          hardtarget_format, hardtarget_width,
                          train_sent_start, train_sent_count,
                          train_sent_range, 
                          cv_sent_start, cv_sent_count,
                          cv_sent_range, 
                          window_extent,
                          hardtarget_window_offset,
                          train_cache_frames, train_cache_seed,
                          &hardtarget_train_str, &hardtarget_cv_str);
    }
    else if (strcmp(softtarget_file,"")!=0)
    {
        assert(!hasConf); // confs not implemented for this
        size_t softtarget_width = config.softtarget_width;
        char* softtarget_format = config.softtarget_format;
        if (strcmp(softtarget_format, "")==0)
            softtarget_format = config.ftr1_format;
        
        create_ftrstreams(debug, "softtarget", (char *)softtarget_file,
                          softtarget_format, softtarget_width,
                          NULL,
                          0, 0,
                          train_sent_start, train_sent_count,
                          train_sent_range, 
                          cv_sent_start, cv_sent_count,
                          cv_sent_range, 
                          window_extent,
                          softtarget_window_offset, 1,
                          0, 0, 0,  /* no deltas or per-utt normalization */
                          0.0, 0.0, 
                          train_cache_frames, train_cache_seed,
                          &softtarget_train_str, &softtarget_cv_str);
        
    }
    else
        assert(0);
   

    // Create the MLP.
    QN_MLP* mlp;
    create_mlp(debug, "mlp",
               mlp3_input_size,mlp3_hidden_size, 
               mlp3_output_size,config.mlp3_output_type,
               config.mlp3_bunch_size, config.threads,hasConf,
               &mlp);

    // Create the leaning rate schedule.
    QN_RateSchedule* lr_schedule;
    create_learnrate_schedule(debug, "learnrate",
                              config.learnrate_schedule,
                              config.learnrate_vals.vals,
                              config.learnrate_vals.count,
                              config.learnrate_scale,
                              config.learnrate_epochs,
                              &lr_schedule);

    
    // A weight file of "" means randomize.
    if (init_weight_fp==NULL)
    {
        if (verbose>0)
        {
            QN_OUTPUT("Randomizing weights...");
        }
        if (config.init_random_weight_min.count<1 ||
            config.init_random_weight_min.count>2 ||
            config.init_random_weight_max.count<1 ||
            config.init_random_weight_max.count>2 ||
            config.init_random_bias_min.count<1 ||
            config.init_random_bias_min.count>2 ||
            config.init_random_bias_max.count<1 ||
            config.init_random_bias_max.count>2) {
          QN_ERROR(NULL,"weight/bias list initializations must either have 1 or 
2 elements");
        }
        float in2hid_min = config.init_random_weight_min.vals[0];
        float in2hid_max = config.init_random_weight_max.vals[0];
        float hidbias_min = config.init_random_bias_min.vals[0];
        float hidbias_max = config.init_random_bias_max.vals[0];
        /* if initialization lists have 1 member, use for both layer 1 and 2
           if 2 members, use separate initializations */
        float hid2out_min = 
config.init_random_weight_min.vals[(config.init_random_weight_min.count==1)?0:1];
        float hid2out_max = 
config.init_random_weight_max.vals[(config.init_random_weight_max.count==1)?0:1];
        float outbias_min = 
config.init_random_bias_min.vals[(config.init_random_bias_min.count==1)?0:1];
        float outbias_max = 
config.init_random_bias_max.vals[(config.init_random_bias_max.count==1)?0:1];
        
        QN_randomize_weights(debug, init_random_seed, *mlp,
                             in2hid_min, in2hid_max,
                             hidbias_min, hidbias_max,
                             hid2out_min, hid2out_max,
                             outbias_min, outbias_max);
        if (verbose>0)
        {
            QN_OUTPUT("Randomized weights.");
        }
    }
    else
    {
        float min, max;
        if (verbose>0)
        {
            QN_OUTPUT("Loading weights...");
        }
        QN_MLPWeightFile_RAP3 inwfile(debug, init_weight_fp,
                                      QN_READ,
                                      init_weight_file,
                                      mlp3_input_size, mlp3_hidden_size,
                                      mlp3_output_size);
        QN_read_weights(inwfile, *mlp, &min, &max, debug);
        QN_OUTPUT("Weights loaded from file, min=%g max=%g.",
                  min, max);
    }

    const char* log_weight_file = config.log_weight_file;
    size_t train_chunk_size;    // The number of presentations read
                                // at one time.
    size_t mlp3_bunch_size = config.mlp3_bunch_size;
    if (mlp3_bunch_size>1)
    {
        train_chunk_size = mlp3_bunch_size;
    }
    else
        train_chunk_size = 16;  // By default, use a size of 16.
    if (hardtarget_train_str!=NULL)
    {
        assert(hardtarget_cv_str!=NULL);
        QN_HardSentTrainer* trainer =
            new QN_HardSentTrainer(debug,               // Debugging level.
                                   "trainer",           // Debugging tag.
                                   verbose,                 // Verbosity level.
                                   mlp,                 // MLP.
                                   ftrfile_train_str,   // Training ftr strm.
                                   hardtarget_train_str, // Training label str.
                                   ftrfile_cv_str,      // CV feature stream.
                                   hardtarget_cv_str,   // CV label stream.    
                                   ftrfile_conf_train_str, // Train conf ftr 
strm.
                                   ftrfile_conf_cv_str,    // CV conf ftr 
stream.
                                   lr_schedule,     // Learning rate scheduler.
                                   0.0,             // Low target.
                                   1.0,             // High target.
                                   log_weight_file, // Where we log weights.
                                   train_chunk_size, // Batch size.
                                   lastlab_reject   // Allow untrainable frames
                               );
        trainer->train();
        delete trainer;
    }
    else
    {
        assert(softtarget_train_str!=NULL);
        assert(softtarget_cv_str!=NULL);
        assert(!hasConf); // confs not implemented for this

        QN_SoftSentTrainer* trainer =
            new QN_SoftSentTrainer(debug,               // Debugging level.
                                   "trainer",           // Debugging tag.
                                   verbose,                 // Verbosity level.
                                   mlp,                 // MLP.
                                   ftrfile_train_str,   // Training ftr strm.
                                   softtarget_train_str, // Training label str.
                                   ftrfile_cv_str,      // CV feature stream.
                                   softtarget_cv_str,   // CV label stream.
                                   lr_schedule,     // Learning rate scheduler.
                                   0.0,             // Low target.
                                   1.0,             // High target.
                                   log_weight_file, // Where we log weights.
                                   train_chunk_size // Batch size.
                               );
        trainer->train();
        delete trainer;
    }

    if (verbose>0)
    {
        QN_OUTPUT("Starting to write weights...");
    }
    float min, max;
    QN_MLPWeightFile_RAP3 outwfile(debug, out_weight_fp, QN_WRITE,
                                   out_weight_file,
                                   mlp3_input_size, mlp3_hidden_size,
                                   mlp3_output_size);
    QN_write_weights(outwfile, *mlp, &min, &max, debug);
    QN_OUTPUT("Weights written to '%s'.", out_weight_file);

// A note for the logfile.
    time(&now);
    QN_OUTPUT("Program stop: %.24s", ctime(&now));
    delete mlp;

    if (out_weight_fp!=NULL)
        QN_close(out_weight_fp);
    if (init_weight_fp!=NULL)
        QN_close(init_weight_fp);
    if (ftr2_norm_fp!=NULL)
        QN_close(ftr2_norm_fp);
    if (ftr1_norm_fp!=NULL)
        QN_close(ftr1_norm_fp);
    //    if (softtarget_fp!=NULL)
    //  {
    //  QN_close(softtarget_fp);
    //  delete softtarget_buf;
    //    }
    if (hardtarget_fp!=NULL)
    {
        QN_close(hardtarget_fp);
        delete [] hardtarget_buf;
    }
    if (unary_fp!=NULL)
    {
        QN_close(unary_fp);
        delete unary_buf;
    }
    //    if (ftr2_fp!=NULL)
    //    {
    //  QN_close(ftr2_fp);
    //  delete ftr2_buf;
    //    }
    //    QN_close(ftr1_fp);
    //    delete ftr1_buf;
    QN_close_ftrfiles();
}

int
main(int argc, const char* argv[])
{
    char* progname;             // The name of the prog - set by QN_initargs.

    FILE* log_fp;
    char log_buf[160];


    set_defaults();
    QN_initargs(&argtab[0], &argc, &argv, &progname);

    // map norm_mode_str to val
    config.ftr1_norm_mode = QN_string_to_norm_const(config.ftr1_norm_mode_str);
    config.ftr2_norm_mode = QN_string_to_norm_const(config.ftr2_norm_mode_str);

    // Seed the random number generator.
    srand48(config.init_random_seed);

    log_fp = QN_open(config.log_file, "w");
    assert(setvbuf(log_fp, log_buf, _IOLBF, sizeof(log_buf))==0);

    QN_printargs(log_fp, progname, &argtab[0]);
    QN_logger = new QN_Logger_Simple(log_fp, stderr, progname);
    
    // Install our own out-of-memory handler if possible.
#ifdef QN_HAVE_SET_NEW_HANDLER
    set_new_handler(QN_new_handler);
#endif

    // Set the math mode
    qn_math = config.mlp3_pp ? QN_MATH_PP : QN_MATH_NV;
#ifdef QN_HAVE_LIBBLAS
    qn_math |= config.mlp3_blas ? QN_MATH_BL : 0;
#else 
    if (config.mlp3_blas)
    {
        QN_ERROR(NULL, "cannot enable BLAS library as none is linked with the "
                 "executable."); 
    }
#endif // #ifdef QN_HAVE_LIBBLAS

    qnstrn();

    exit(EXIT_SUCCESS);
}

reply via email to

[Prev in Thread] Current Thread [Next in Thread]