wapiti 0.0.1

data/ext/wapiti/model.h

@@ -0,0 +1,100 @@
+/*
+ *      Wapiti - A linear-chain CRF tool
+ *
+ * Copyright (c) 2009-2011  CNRS
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef model_h
+#define model_h
+
+#include <stddef.h>
+#include <sys/times.h>
+
+#include "wapiti.h"
+#include "options.h"
+#include "sequence.h"
+#include "reader.h"
+
+typedef struct tms tms_t;
+
+/* mdl_t:
+ *   Represent a linear-chain CRF model. The model contain both unigram and
+ *   bigram features. It is caracterized by <nlbl> the number of labels, <nobs>
+ *   the number of observations, and <nftr> the number of features.
+ *
+ *   Each observations have a corresponding entry in <kind> whose first bit is
+ *   set if the observation is unigram and second one if it is bigram. Note that
+ *   an observation can be both. An unigram observation produce Y features and a
+ *   bigram one produce Y * Y features.
+ *   The <theta> array keep all features weights. The <*off> array give for each
+ *   observations the offset in the <theta> array where the features of the
+ *   observation are stored.
+ *
+ *   The <*off> and <theta> array are initialized only when the model is
+ *   synchronized. As you can add new labels and observations after a sync, we
+ *   keep track of the old counts in <olbl> and <oblk> to detect inconsistency
+ *   and resynchronize the model if needed. In this case, if the number of
+ *   labels have not changed, the previously trained weights are kept, else they
+ *   are now meaningless so discarded.
+ */
+typedef struct mdl_s mdl_t;
+struct mdl_s {
+	opt_t   *opt;     //       options for training
+
+	// Size of various model parameters
+	size_t   nlbl;    //   Y   number of labels
+	size_t   nobs;    //   O   number of observations
+	size_t   nftr;    //   F   number of features
+
+	// Informations about observations
+	char    *kind;    //  [O]  observations type
+	size_t  *uoff;    //  [O]  unigram weights offset
+	size_t  *boff;    //  [O]  bigram weights offset
+
+	// The model itself
+	double  *theta;   //  [F]  features weights
+
+	// Datasets
+	dat_t   *train;   //       training dataset
+	dat_t   *devel;   //       development dataset
+	rdr_t   *reader;
+
+	// Stoping criterion
+	double  *werr;    //       Window of error rate of last iters
+	int      wcnt;    //       Number of iters in the window
+	int      wpos;    //       Position for the next iter
+
+	// Timing
+	tms_t    timer;   //       start time of last iter
+	double   total;   //       total training time
+};
+
+mdl_t *mdl_new(rdr_t *rdr);
+void mdl_free(mdl_t *mdl);
+void mdl_sync(mdl_t *mdl);
+void mdl_compact(mdl_t *mdl);
+void mdl_save(mdl_t *mdl, FILE *file);
+void mdl_load(mdl_t *mdl, FILE *file);
+
+#endif

data/ext/wapiti/native.c

@@ -0,0 +1,1238 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "wapiti.h"
+#include "options.h"
+#include "reader.h"
+#include "model.h"
+#include "trainers.h"
+#include "quark.h"
+#include "tools.h"
+
+#include "native.h"
+
+VALUE mWapiti;
+VALUE mNative;
+
+VALUE cOptions;
+VALUE cModel;
+
+VALUE cNativeError;
+VALUE cConfigurationError;
+VALUE cLogger;
+
+
+/* --- Utilities --- */
+
+static void trn_auto(mdl_t *mdl) {
+	const int maxiter = mdl->opt->maxiter;
+	mdl->opt->maxiter = 3;
+	trn_sgdl1(mdl);
+	mdl->opt->maxiter = maxiter;
+	trn_lbfgs(mdl);
+}
+
+static const struct {
+	char *name;
+	void (* train)(mdl_t *mdl);
+} trn_lst[] = {
+	{"l-bfgs", trn_lbfgs},
+	{"sgd-l1", trn_sgdl1},
+	{"bcd",    trn_bcd  },
+	{"rprop",  trn_rprop},
+	{"rprop+", trn_rprop},
+	{"rprop-", trn_rprop},
+	{"auto",   trn_auto }
+};
+static const int trn_cnt = sizeof(trn_lst) / sizeof(trn_lst[0]);
+
+
+/* --- Options Class --- */
+
+// Auxiliary Methods
+
+static opt_t *get_options(VALUE self) {
+	opt_t *options;	
+	Data_Get_Struct(self, opt_t, options);
+	return options;
+}
+
+// Copies a Ruby string to the heap and stores it in a pointer.
+// Frees the pointer before assigning the new value.
+static void copy_string(char **dst, VALUE rb_string) {
+	Check_Type(rb_string, T_STRING);
+
+	if (*dst) { free(*dst); *dst = (char*)0; }
+	*dst = calloc(RSTRING_LEN(rb_string) + 1, sizeof(char));
+
+	memcpy(*dst, StringValuePtr(rb_string), RSTRING_LEN(rb_string) + 1);
+}
+
+
+// Constructor / Desctructor
+
+static void mark_options(opt_t* options __attribute__((__unused__))) {
+	// nothing
+}
+
+static void deallocate_options(opt_t* options) {
+	
+	// free string options
+	if (options->input) { free(options->input); }
+	if (options->output) { free(options->output); }
+	if (options->algo) { free(options->algo); }
+	if (options->devel) { free(options->devel); }
+	if (options->pattern) { free(options->pattern); }
+	
+	free(options);
+	options = (opt_t*)0;
+}
+
+static VALUE allocate_options(VALUE self) {
+	opt_t* options = malloc(sizeof(opt_t));
+	return Data_Wrap_Struct(self, mark_options, deallocate_options, options);
+}
+
+static VALUE initialize_options(int argc, VALUE *argv, VALUE self) {	
+	opt_t* options = get_options(self);
+	*options = opt_defaults;
+	
+	if (options->maxiter == 0) {
+		options->maxiter = INT_MAX;
+	}
+	
+	// copy the default algorithm name to the heap so that all options strings
+	// are on the heap
+	char* tmp = calloc(strlen(options->algo), sizeof(char));
+	memcpy(tmp, options->algo, strlen(options->algo));
+	options->algo = tmp;
+
+	if (argc > 1) {
+		rb_raise(rb_const_get(rb_mKernel, rb_intern("ArgumentError")),
+			"wrong number of arguments (%d for 0..1)", argc);
+	}
+
+	// set defaults
+	if (argc) {
+		Check_Type(argv[0], T_HASH);
+		(void)rb_funcall(self, rb_intern("update"), 1, argv[0]);
+	}
+	
+	// yield self if block_given?
+	if (rb_block_given_p()) {
+		rb_yield(self);
+	}
+	
+	return self;
+}
+
+
+// Instance Methods
+
+
+// Fixnum Accessors
+
+static VALUE options_nbest(VALUE self) {
+	return INT2FIX(get_options(self)->nbest);
+}
+
+static VALUE options_set_nbest(VALUE self, VALUE rb_fixnum) {
+	Check_Type(rb_fixnum, T_FIXNUM);	
+	get_options(self)->nbest = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+
+static VALUE options_stopwin(VALUE self) {
+	return INT2FIX(get_options(self)->stopwin);
+}
+
+static VALUE options_set_stopwin(VALUE self, VALUE rb_fixnum) {
+	Check_Type(rb_fixnum, T_FIXNUM);
+	get_options(self)->stopwin = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+static VALUE options_objwin(VALUE self) {
+	return INT2FIX(get_options(self)->objwin);
+}
+
+static VALUE options_set_objwin(VALUE self, VALUE rb_fixnum) {
+	Check_Type(rb_fixnum, T_FIXNUM);
+	get_options(self)->objwin = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+
+static VALUE options_maxiter(VALUE self) {
+	return INT2FIX(get_options(self)->maxiter);
+}
+
+static VALUE options_set_maxiter(VALUE self, VALUE rb_fixnum) {
+	opt_t *options = get_options(self);
+
+	Check_Type(rb_fixnum, T_FIXNUM);
+	options->maxiter = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+static VALUE options_jobsize(VALUE self) {
+	return INT2FIX(get_options(self)->jobsize);
+}
+
+static VALUE options_set_jobsize(VALUE self, VALUE rb_fixnum) {
+	opt_t *options = get_options(self);
+
+	Check_Type(rb_fixnum, T_FIXNUM);
+	options->jobsize = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+static VALUE options_nthread(VALUE self) {
+	return INT2FIX(get_options(self)->nthread);
+}
+
+static VALUE options_set_nthread(VALUE self, VALUE rb_fixnum) {
+	opt_t *options = get_options(self);
+
+	Check_Type(rb_fixnum, T_FIXNUM);
+	options->nthread = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+static VALUE options_histsz(VALUE self) {
+	return INT2FIX(get_options(self)->lbfgs.histsz);
+}
+
+static VALUE options_set_histsz(VALUE self, VALUE rb_fixnum) {
+	Check_Type(rb_fixnum, T_FIXNUM);	
+	get_options(self)->lbfgs.histsz = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+static VALUE options_maxls(VALUE self) {
+	return INT2FIX(get_options(self)->lbfgs.maxls);
+}
+
+static VALUE options_set_maxls(VALUE self, VALUE rb_fixnum) {
+	Check_Type(rb_fixnum, T_FIXNUM);	
+	get_options(self)->lbfgs.maxls = FIX2INT(rb_fixnum);
+	
+	return rb_fixnum;
+}
+
+
+// Float Accessors
+
+static VALUE options_rho1(VALUE self) {
+	return rb_float_new(get_options(self)->rho1);
+}
+
+static VALUE options_set_rho1(VALUE self, VALUE rb_numeric) {
+	get_options(self)->rho1 = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_rho2(VALUE self) {
+	return rb_float_new(get_options(self)->rho2);
+}
+
+static VALUE options_set_rho2(VALUE self, VALUE rb_numeric) {
+	get_options(self)->rho2 = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_stopeps(VALUE self) {
+	return rb_float_new(get_options(self)->stopeps);
+}
+
+static VALUE options_set_stopeps(VALUE self, VALUE rb_numeric) {
+	get_options(self)->stopeps = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_eta0(VALUE self) {
+	return rb_float_new(get_options(self)->sgdl1.eta0);
+}
+
+static VALUE options_set_eta0(VALUE self, VALUE rb_numeric) {
+	get_options(self)->sgdl1.eta0 = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_alpha(VALUE self) {
+	return rb_float_new(get_options(self)->sgdl1.alpha);
+}
+
+static VALUE options_set_alpha(VALUE self, VALUE rb_numeric) {
+	get_options(self)->sgdl1.alpha = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_kappa(VALUE self) {
+	return rb_float_new(get_options(self)->bcd.kappa);
+}
+
+static VALUE options_set_kappa(VALUE self, VALUE rb_numeric) {
+	get_options(self)->bcd.kappa = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_stpmin(VALUE self) {
+	return rb_float_new(get_options(self)->rprop.stpmin);
+}
+
+static VALUE options_set_stpmin(VALUE self, VALUE rb_numeric) {
+	get_options(self)->rprop.stpmin = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_stpmax(VALUE self) {
+	return rb_float_new(get_options(self)->rprop.stpmax);
+}
+
+static VALUE options_set_stpmax(VALUE self, VALUE rb_numeric) {
+	get_options(self)->rprop.stpmax = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_stpinc(VALUE self) {
+	return rb_float_new(get_options(self)->rprop.stpinc);
+}
+
+static VALUE options_set_stpinc(VALUE self, VALUE rb_numeric) {
+	get_options(self)->rprop.stpinc = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+static VALUE options_stpdec(VALUE self) {
+	return rb_float_new(get_options(self)->rprop.stpdec);
+}
+
+static VALUE options_set_stpdec(VALUE self, VALUE rb_numeric) {
+	get_options(self)->rprop.stpdec = NUM2DBL(rb_numeric);
+	return rb_numeric;
+}
+
+
+
+// Boolean Accessors
+
+static VALUE options_maxent(VALUE self) {
+	return get_options(self)->maxent ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_maxent(VALUE self, VALUE rb_boolean) {
+	get_options(self)->maxent = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);	
+	return rb_boolean;
+}
+
+static VALUE options_compact(VALUE self) {
+	return get_options(self)->compact ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_compact(VALUE self, VALUE rb_boolean) {
+	get_options(self)->compact = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);
+	return rb_boolean;
+}
+
+static VALUE options_sparse(VALUE self) {
+	return get_options(self)->sparse ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_sparse(VALUE self, VALUE rb_boolean) {
+	get_options(self)->sparse = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);
+	return rb_boolean;
+}
+
+static VALUE options_check(VALUE self) {
+	return get_options(self)->check ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_check(VALUE self, VALUE rb_boolean) {
+	get_options(self)->check = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);	
+	return rb_boolean;
+}
+
+static VALUE options_label(VALUE self) {
+	return get_options(self)->label ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_label(VALUE self, VALUE rb_boolean) {
+	get_options(self)->label = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);	
+	return rb_boolean;
+}
+
+static VALUE options_outsc(VALUE self) {
+	return get_options(self)->outsc ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_outsc(VALUE self, VALUE rb_boolean) {
+	get_options(self)->outsc = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);	
+	return rb_boolean;
+}
+
+static VALUE options_lblpost(VALUE self) {
+	return get_options(self)->lblpost ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_lblpost(VALUE self, VALUE rb_boolean) {
+	get_options(self)->lblpost = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);	
+	return rb_boolean;
+}
+
+static VALUE options_clip(VALUE self) {
+	return get_options(self)->lbfgs.clip ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_clip(VALUE self, VALUE rb_boolean) {
+	get_options(self)->lbfgs.clip = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);	
+	return rb_boolean;
+}
+
+static VALUE options_cutoff(VALUE self) {
+	return get_options(self)->rprop.cutoff ? Qtrue : Qfalse;	
+}
+
+static VALUE options_set_cutoff(VALUE self, VALUE rb_boolean) {
+	get_options(self)->rprop.cutoff = !(TYPE(rb_boolean) == T_NIL || !rb_boolean);	
+	return rb_boolean;
+}
+
+
+
+
+// String Accessors
+
+static VALUE options_pattern(VALUE self) {
+	char *pattern = get_options(self)->pattern;
+	return rb_str_new2(pattern ? pattern : "");
+}
+
+static VALUE options_set_pattern(VALUE self, VALUE rb_string) {
+	opt_t *options = get_options(self);
+	copy_string(&(options->pattern), rb_string);
+	
+	return rb_string;
+}
+
+static VALUE options_model(VALUE self) {
+	char *model = get_options(self)->model;
+	return rb_str_new2(model ? model : "");
+}
+
+static VALUE options_set_model(VALUE self, VALUE rb_string) {
+	opt_t *options = get_options(self);
+	copy_string(&(options->model), rb_string);
+	
+	return rb_string;
+}
+
+static VALUE options_algorithm(VALUE self) {
+	char *algorithm = get_options(self)->algo;
+	return rb_str_new2(algorithm ? algorithm : "");
+}
+
+static VALUE options_set_algorithm(VALUE self, VALUE rb_string) {
+	opt_t *options = get_options(self);
+	copy_string(&(options->algo), rb_string);
+	
+	return rb_string;
+}
+
+static VALUE options_development_data(VALUE self) {
+	char *development_data = get_options(self)->devel;
+	return rb_str_new2(development_data ? development_data : "");
+}
+
+static VALUE options_set_development_data(VALUE self, VALUE rb_string) {
+	opt_t *options = get_options(self);
+	copy_string(&(options->devel), rb_string);
+	
+	return rb_string;
+}
+
+
+void Init_options() {
+	cOptions = rb_define_class_under(mWapiti, "Options", rb_cObject);
+	rb_define_alloc_func(cOptions, allocate_options);
+	
+	rb_define_method(cOptions, "initialize", initialize_options, -1);
+
+	// Option Accessors
+
+	rb_define_method(cOptions, "stopwin", options_stopwin, 0);
+	rb_define_method(cOptions, "stopwin=", options_set_stopwin, 1);
+
+	rb_define_alias(cOptions, "stop_window", "stopwin");
+	rb_define_alias(cOptions, "stop_window=", "stopwin=");
+
+	rb_define_method(cOptions, "objwin", options_objwin, 0);
+	rb_define_method(cOptions, "objwin=", options_set_objwin, 1);
+
+	rb_define_alias(cOptions, "convergence_window", "objwin");
+	rb_define_alias(cOptions, "convergence_window=", "objwin=");
+	
+	rb_define_method(cOptions, "maxiter", options_maxiter, 0);
+	rb_define_method(cOptions, "maxiter=", options_set_maxiter, 1);
+
+	rb_define_alias(cOptions, "max_iterations", "maxiter");
+	rb_define_alias(cOptions, "max_iterations=", "maxiter=");
+	
+	rb_define_method(cOptions, "jobsize", options_jobsize, 0);
+	rb_define_method(cOptions, "jobsize=", options_set_jobsize, 1);
+
+	rb_define_method(cOptions, "nthread", options_nthread, 0);
+	rb_define_method(cOptions, "nthread=", options_set_nthread, 1);
+
+	rb_define_alias(cOptions, "threads", "nthread");
+	rb_define_alias(cOptions, "threads=", "nthread=");
+
+	rb_define_method(cOptions, "rho1", options_rho1, 0);
+	rb_define_method(cOptions, "rho1=", options_set_rho1, 1);
+
+	rb_define_method(cOptions, "rho2", options_rho2, 0);
+	rb_define_method(cOptions, "rho2=", options_set_rho2, 1);
+
+	rb_define_method(cOptions, "stopeps", options_stopeps, 0);
+	rb_define_method(cOptions, "stopeps=", options_set_stopeps, 1);
+
+	rb_define_alias(cOptions, "stop_epsilon", "stopeps");
+	rb_define_alias(cOptions, "stop_epsilon=", "stopeps=");
+
+	rb_define_method(cOptions, "maxent", options_maxent, 0);
+	rb_define_method(cOptions, "maxent=", options_set_maxent, 1);
+
+	rb_define_alias(cOptions, "maxent?", "maxent");
+
+	rb_define_method(cOptions, "compact", options_compact, 0);
+	rb_define_method(cOptions, "compact=", options_set_compact, 1);
+
+	rb_define_alias(cOptions, "compact?", "compact");
+
+	rb_define_method(cOptions, "sparse", options_sparse, 0);
+	rb_define_method(cOptions, "sparse=", options_set_sparse, 1);
+
+	rb_define_alias(cOptions, "sparse?", "sparse");
+
+	rb_define_method(cOptions, "label", options_label, 0);
+	rb_define_method(cOptions, "label=", options_set_label, 1);
+
+	rb_define_alias(cOptions, "label?", "label");
+
+	rb_define_method(cOptions, "check", options_check, 0);
+	rb_define_method(cOptions, "check=", options_set_check, 1);
+
+	rb_define_alias(cOptions, "check?", "check");
+
+	rb_define_method(cOptions, "lblpost", options_lblpost, 0);
+	rb_define_method(cOptions, "lblpost=", options_set_lblpost, 1);
+
+	rb_define_alias(cOptions, "lblpost?", "lblpost");
+
+	rb_define_alias(cOptions, "posterior", "lblpost");
+	rb_define_alias(cOptions, "posterior?", "lblpost");
+	rb_define_alias(cOptions, "posterior=", "lblpost=");
+
+	rb_define_method(cOptions, "outsc", options_outsc, 0);
+	rb_define_method(cOptions, "outsc=", options_set_outsc, 1);
+
+	rb_define_alias(cOptions, "outsc?", "outsc");
+
+	rb_define_alias(cOptions, "score", "outsc");
+	rb_define_alias(cOptions, "score?", "outsc");
+	rb_define_alias(cOptions, "score=", "outsc=");
+
+	rb_define_method(cOptions, "pattern", options_pattern, 0);
+	rb_define_method(cOptions, "pattern=", options_set_pattern, 1);
+
+	rb_define_alias(cOptions, "template", "pattern");
+	rb_define_alias(cOptions, "template=", "pattern=");
+
+	rb_define_method(cOptions, "model", options_model, 0);
+	rb_define_method(cOptions, "model=", options_set_model, 1);
+
+	rb_define_method(cOptions, "algorithm", options_algorithm, 0);
+	rb_define_method(cOptions, "algorithm=", options_set_algorithm, 1);
+
+	rb_define_alias(cOptions, "algo", "algorithm");
+	rb_define_alias(cOptions, "algo=", "algorithm=");
+
+	rb_define_method(cOptions, "development_data", options_development_data, 0);
+	rb_define_method(cOptions, "development_data=", options_set_development_data, 1);
+
+	rb_define_alias(cOptions, "devel", "development_data");
+	rb_define_alias(cOptions, "devel=", "development_data=");
+
+	rb_define_method(cOptions, "clip", options_clip, 0);
+	rb_define_method(cOptions, "clip=", options_set_clip, 1);
+
+	rb_define_method(cOptions, "histsz", options_histsz, 0);
+	rb_define_method(cOptions, "histsz=", options_set_histsz, 1);
+
+	rb_define_method(cOptions, "maxls", options_maxls, 0);
+	rb_define_method(cOptions, "maxls=", options_set_maxls, 1);
+
+	rb_define_method(cOptions, "eta0", options_eta0, 0);
+	rb_define_method(cOptions, "eta0=", options_set_eta0, 1);
+
+	rb_define_method(cOptions, "alpha", options_alpha, 0);
+	rb_define_method(cOptions, "alpha=", options_set_alpha, 1);
+
+	rb_define_method(cOptions, "kappa", options_kappa, 0);
+	rb_define_method(cOptions, "kappa=", options_set_kappa, 1);
+
+	rb_define_method(cOptions, "stpmin", options_stpmin, 0);
+	rb_define_method(cOptions, "stpmin=", options_set_stpmin, 1);
+
+	rb_define_method(cOptions, "stpmax", options_stpmax, 0);
+	rb_define_method(cOptions, "stpmax=", options_set_stpmax, 1);
+
+	rb_define_method(cOptions, "stpinc", options_stpinc, 0);
+	rb_define_method(cOptions, "stpinc=", options_set_stpinc, 1);
+
+	rb_define_method(cOptions, "stpdec", options_stpdec, 0);
+	rb_define_method(cOptions, "stpdec=", options_set_stpdec, 1);
+
+	rb_define_method(cOptions, "cutoff", options_cutoff, 0);
+	rb_define_method(cOptions, "cutoff=", options_set_cutoff, 1);
+	
+	rb_define_method(cOptions, "nbest", options_nbest, 0);
+	rb_define_method(cOptions, "nbest=", options_set_nbest, 1);
+	
+}
+
+
+/* --- Model Class --- */
+
+// Auxiliary Methods
+
+static mdl_t *get_model(VALUE self) {
+	mdl_t *model;	
+	Data_Get_Struct(self, mdl_t, model);
+	return model;
+}
+
+// Constructor / Desctructor
+
+static void mark_model(mdl_t *model __attribute__((__unused__))) {
+	// nothing
+}
+
+static void deallocate_model(mdl_t *model) {
+	if (model) {
+		mdl_free(model);
+		model = (mdl_t*)0;
+	}
+}
+
+static VALUE allocate_model(VALUE self) {
+	mdl_t *model = mdl_new(rdr_new(false));
+	return Data_Wrap_Struct(self, mark_model, deallocate_model, model);
+}
+
+static VALUE model_set_options(VALUE self, VALUE rb_options) {	
+	if (strncmp("Wapiti::Options", rb_obj_classname(rb_options), 15) != 0) {
+		rb_raise(cNativeError, "argument must be a Wapiti::Options instance");
+	}
+	
+	mdl_t *model = get_model(self);
+	
+	// Store reference to options in model struct
+	model->opt = get_options(rb_options);
+	
+	// Update reader
+	model->reader->maxent = model->opt->maxent;
+	
+	// Save instance variable
+	rb_ivar_set(self, rb_intern("@options"), rb_options);
+
+	return rb_options;
+}
+
+static VALUE initialize_model(int argc, VALUE *argv, VALUE self) {
+	VALUE options;
+	
+	if (argc > 1) {
+		rb_raise(rb_const_get(rb_mKernel, rb_intern("ArgumentError")),
+			"wrong number of arguments (%d for 0..1)", argc);
+	}
+
+	if (argc) {
+		if (TYPE(argv[0]) == T_HASH) {
+			options = rb_funcall(cOptions, rb_intern("new"), 1, argv[0]);			
+		}
+		else {
+			if (strncmp("Wapiti::Options", rb_obj_classname(argv[0]), 15) != 0) {
+				rb_raise(cNativeError, "argument must be a hash or an options instance");
+			}
+			options = argv[0];
+		}
+	}
+	else {
+		options = rb_funcall(cOptions, rb_intern("new"), 0);
+	}
+	
+	// yield self if block_given?
+	if (rb_block_given_p()) {
+	 	rb_yield(options);
+	}
+
+	model_set_options(self, options);
+
+	// Load a previous model if specified by options
+	if (get_options(options)->model) {
+		rb_funcall(self, rb_intern("load"), 0);
+	}
+
+	return self;
+}
+
+
+// Native accessors
+
+static VALUE model_nlbl(VALUE self) {
+	return INT2FIX(get_model(self)->nlbl);
+}
+
+static VALUE model_nobs(VALUE self) {
+	return INT2FIX(get_model(self)->nobs);
+}
+
+static VALUE model_nftr(VALUE self) {
+	return INT2FIX(get_model(self)->nftr);
+}
+
+static VALUE model_total(VALUE self) {
+	return rb_float_new(get_model(self)->total);
+}
+
+
+// Instance methods
+
+static VALUE model_sync(VALUE self) {
+	mdl_sync(get_model(self));
+	return self;
+}
+
+static VALUE model_compact(VALUE self) {
+	mdl_compact(get_model(self));
+	return self;
+}
+
+// call-seq:
+//   m.save       # => saves the model to the file defined in m.path
+//   m.save(path) # => sets m.path and saves the model to the file <path>
+//
+// Saves the model to a file. Uses the Model's path if no argument given,
+// otherwise uses the passed-in argument as the Model's path.
+static VALUE model_save(int argc, VALUE *argv, VALUE self) {
+	if (argc > 1) {
+		rb_raise(rb_const_get(rb_mKernel, rb_intern("ArgumentError")),
+			"wrong number of arguments (%d for 0..1)", argc);
+	}
+	
+	mdl_t *model = get_model(self);
+	
+	// save passed-in path in options
+	if (argc) {
+		Check_Type(argv[0], T_STRING);
+		rb_ivar_set(self, rb_intern("@path"), argv[0]);
+	}
+
+	// open the output file
+	FILE *file = 0;
+	VALUE path = rb_ivar_get(self, rb_intern("@path"));
+	
+	if (NIL_P(path)) {
+		rb_raise(cNativeError, "failed to save model: no path given");
+	}
+	
+	if (!(file = fopen(StringValueCStr(path), "w"))) {
+		rb_raise(cNativeError, "failed to save model: failed to open model file");
+	}
+	
+	mdl_save(model, file);
+	fclose(file);
+
+	return self;
+}
+
+static VALUE model_load(int argc, VALUE *argv, VALUE self) {
+	if (argc > 1) {
+		rb_raise(rb_const_get(rb_mKernel, rb_intern("ArgumentError")),
+			"wrong number of arguments (%d for 0..1)", argc);
+	}
+	
+	mdl_t *model = get_model(self);
+	
+	// save passed-in argument in options
+	if (argc) {
+		Check_Type(argv[0], T_STRING);
+		rb_ivar_set(self, rb_intern("@path"), argv[0]);
+	}
+	
+	// open the model file
+	FILE *file = 0;
+	VALUE path = rb_ivar_get(self, rb_intern("@path"));
+	
+	if (NIL_P(path)) {
+		rb_raise(cNativeError, "failed to load model: no path given");
+	}
+	
+	if (!(file = fopen(StringValueCStr(path), "r"))) {
+		rb_raise(cNativeError, "failed to load model: failed to open model file");
+	}
+	
+	mdl_load(model, file);
+	fclose(file);
+	
+	return self;
+}
+
+static dat_t *to_dat(rdr_t *reader, VALUE data, bool labelled) {
+	Check_Type(data, T_ARRAY);
+	
+	const unsigned int n = RARRAY_LEN(data);
+	unsigned int i, j, k;
+	
+	dat_t *dat = xmalloc(sizeof(dat_t));
+	dat->nseq = 0;
+	dat->mlen = 0;
+	dat->lbl = labelled;
+	dat->seq = xmalloc(sizeof(seq_t*) * n);
+
+	for (i = 0; i < n; ++i) {
+		VALUE sequence = rb_ary_entry(data, i);
+		Check_Type(sequence, T_ARRAY);
+		
+		k = RARRAY_LEN(sequence);
+		raw_t *raw = xmalloc(sizeof(raw_t) + sizeof(char*) * k);
+		
+		for (j = 0; j < k; ++j) {	
+			VALUE line = rb_ary_entry(sequence, j);
+			Check_Type(line, T_STRING);
+			raw->lines[j] = StringValueCStr(line);
+		}
+		
+		raw->len = k;
+	
+		seq_t *seq = rdr_raw2seq(reader, raw, labelled);
+		xfree(raw);
+
+		if (seq == 0) { break; }
+		
+		// and store the sequence
+		dat->seq[dat->nseq++] = seq;
+		dat->mlen = max(dat->mlen, seq->len);
+		
+	}
+	
+	// if no sequence was read, free memory
+	if (dat->nseq == 0) {
+		xfree(dat->seq);
+		xfree(dat);
+		
+		return 0;
+	}
+
+	return dat;
+}
+
+
+static VALUE model_train(VALUE self, VALUE data) {
+	
+	mdl_t* model = get_model(self);
+	
+	int trn;
+	for (trn = 0; trn < trn_cnt; trn++) {
+		if (!strcmp(model->opt->algo, trn_lst[trn].name)) break;
+	}
+	
+	if (trn == trn_cnt) {
+		rb_raise(cNativeError, "failed to train model: unknown algorithm '%s'", model->opt->algo);
+	}
+	
+	FILE *file;
+	
+	// Load the pattern file. This will unlock the database if previously
+	// locked by loading a model.
+	if (model->opt->pattern) {
+		file = fopen(model->opt->pattern, "r");
+		
+		if (!file) {
+			rb_raise(cNativeError, "failed to train model: failed to load pattern file '%s'", model->opt->pattern);
+		}
+
+		rdr_loadpat(model->reader, file);
+		fclose(file);
+		qrk_lock(model->reader->obs, false);
+	}
+	else {
+		rb_raise(cNativeError, "failed to train model: no pattern given");
+	}
+	
+	
+	// Load the training data. When this is done we lock the quarks as we
+	// don't want to put in the model, informations present only in the
+	// devlopment set.
+	
+	switch (TYPE(data)) {
+		case T_STRING:
+			if (!(file = fopen(StringValuePtr(data), "r"))) {
+				rb_raise(cNativeError, "failed to train model: failed to open training data '%s", StringValuePtr(data));
+			}
+
+			model->train = rdr_readdat(model->reader, file, true);
+			fclose(file);
+			
+			break;
+		case T_ARRAY:
+			model->train = to_dat(model->reader, data, true);
+
+			break;
+		default:
+			rb_raise(cNativeError, "failed to train model: invalid training data type (expected instance of String or Array)");
+	}
+
+	qrk_lock(model->reader->lbl, true);
+	qrk_lock(model->reader->obs, true);
+	
+	if (!model->train || model->train->nseq == 0) {
+		rb_raise(cNativeError, "failed to train model: no training data loaded");
+	}
+
+	// If present, load the development set in the model. If not specified,
+	// the training dataset will be used instead.
+	if (model->opt->devel) {
+		if (!(file = fopen(model->opt->devel, "r"))) {
+			rb_raise(cNativeError, "failed to train model: cannot open development file '%s'", model->opt->devel);
+		}
+		
+		model->devel = rdr_readdat(model->reader, file, true);
+		fclose(file);
+	}
+	
+	// Initialize the model. If a previous model was loaded, this will be
+	// just a resync, else the model structure will be created.
+	rb_funcall(self, rb_intern("sync"), 0);
+
+	// Train the model.
+	uit_setup(model);
+	trn_lst[trn].train(model);
+	uit_cleanup(model);
+	
+	// If requested compact the model.
+	if (model->opt->compact) {
+		const size_t O = model->nobs;
+		const size_t F = model->nftr;
+		rb_funcall(self, rb_intern("compact"), 0);
+	}	
+	
+	return self;
+}
+
+// Returns a sorted list of all labels in the Model's label database.
+static VALUE model_labels(VALUE self) {
+	mdl_t *model = get_model(self);
+	const size_t Y = model->nlbl;
+	
+	qrk_t *lp = model->reader->lbl;
+	
+	VALUE labels = rb_ary_new2(Y);
+
+	for (unsigned int i = 0; i < Y; ++i) {
+		rb_ary_push(labels, rb_str_new2(qrk_id2str(lp, i)));
+	}
+	
+	rb_funcall(labels, rb_intern("sort!"), 0);
+	
+	return labels;
+}
+
+static VALUE decode_sequence(mdl_t *model, raw_t *raw) {
+	qrk_t *lbls = model->reader->lbl;
+	
+	const size_t Y = model->nlbl;
+	const size_t N = model->opt->nbest;
+	
+	seq_t *seq = rdr_raw2seq(model->reader, raw, model->opt->check);
+	
+	const int T = seq->len;
+	
+	size_t *out = xmalloc(sizeof(size_t) * T * N);
+	double *psc = xmalloc(sizeof(double) * T * N);
+	double *scs = xmalloc(sizeof(double) * N);
+
+	VALUE result = rb_ary_new2(N), sequence, tokens;
+
+	if (N == 1) {
+		tag_viterbi(model, seq, (size_t*)out, scs, (double*)psc);
+	}
+	else {
+		tag_nbviterbi(model, seq, N, (void*)out, scs, (void*)psc);
+	}
+	
+	// Next we output the raw sequence with an aditional column for
+	// the predicted labels
+	for (size_t n = 0; n < N; n++) {
+
+		sequence = rb_ary_new();
+					
+		// if (model->opt->outsc)
+			// fprintf(fout, "# %d %f\n", (int)n, scs[n]);
+			
+		for (int t = 0; t < T; t++) {
+			tokens = rb_ary_new();
+			
+			if (!model->opt->label) {
+				rb_ary_push(tokens, rb_str_new2(raw->lines[t]));
+			}
+			
+			size_t lbl = out[t * N + n];
+			rb_ary_push(tokens, rb_str_new2(qrk_id2str(lbls, lbl)));
+
+			// if (model->opt->outsc) {
+			// 	fprintf(fout, "\t%s", lblstr);
+			// 	fprintf(fout, "/%f", psc[t * N + n]);
+			// }
+			
+			// yield token/label pair to block if given
+			if (rb_block_given_p()) {
+				tokens = rb_yield(tokens);
+			}
+			
+			rb_ary_push(sequence, tokens);
+		}
+		
+		rb_ary_push(result, sequence);
+	}
+
+	// Cleanup memory used for this sequence
+	xfree(scs);
+	xfree(psc);
+	xfree(out);
+	
+	rdr_freeseq(seq);
+	
+	return result;
+}
+
+static VALUE decode_sequence_array(VALUE self, VALUE array) {
+	Check_Type(array, T_ARRAY);
+	const unsigned int n = RARRAY_LEN(array);
+
+	mdl_t *model = get_model(self);
+	raw_t *raw;
+	
+	const unsigned int N = model->opt->nbest;
+	unsigned int i, j;
+	
+	VALUE result = rb_ary_new2(n * N), sequence;
+
+	for (i = 0; i < n; ++i) {
+		sequence = rb_ary_entry(array, i);
+		Check_Type(sequence, T_ARRAY);
+		
+		const unsigned int k = RARRAY_LEN(sequence);
+		raw = xmalloc(sizeof(raw_t) + sizeof(char*) * k);
+		raw->len = k;
+		
+		for (j = 0; j < k; ++j) {
+			VALUE line = rb_ary_entry(sequence, j);
+			Check_Type(line, T_STRING);
+		
+			raw->lines[j] = StringValueCStr(line);
+		}
+
+		rb_funcall(result, rb_intern("concat"), 1, decode_sequence(model, raw));
+
+		xfree(raw);
+	}
+			
+	return result;
+}
+
+static VALUE decode_sequence_file(VALUE self, VALUE path) {
+	Check_Type(path, T_STRING);
+	FILE *file;
+	
+	if (!(file = fopen(StringValueCStr(path), "r"))) {
+		rb_raise(cNativeError, "failed to label data: could not open file '%s'", StringValueCStr(path));
+	}
+	
+	mdl_t *model = get_model(self);
+	raw_t *raw;
+	
+	VALUE result = rb_ary_new();
+	
+	// Next read the input file sequence by sequence and label them, we have
+	// to take care of not discarding the raw input as we want to send it
+	// back to the output with the additional predicted labels.
+	while (!feof(file)) {
+		
+		// So, first read an input sequence keeping the raw_t object
+		// available, and label it with Viterbi.
+		if ((raw = rdr_readraw(model->reader, file)) == 0) {
+			break;
+		}
+		
+		rb_funcall(result, rb_intern("concat"), 1, decode_sequence(model, raw));
+		rdr_freeraw(raw);
+	}
+	
+	return result;
+}
+
+// cal-seq:
+//   m.label(tokens)  # => array of labelled tokens
+//   m.label(filename) # => array of labelled tokens
+//
+static VALUE model_label(VALUE self, VALUE data) {
+	VALUE result;
+	
+	switch (TYPE(data)) {
+		case T_STRING:
+			result = decode_sequence_file(self, data);
+			break;			
+		case T_ARRAY:
+			result = decode_sequence_array(self, data);
+			break;
+		default:
+			rb_raise(cNativeError, "failed to label data: invalid data (expected type String or Array)");
+	}
+	
+	return result;
+}
+
+static void Init_model() {
+	cModel = rb_define_class_under(mWapiti, "Model", rb_cObject);
+	rb_define_alloc_func(cModel, allocate_model);
+	
+	rb_define_method(cModel, "initialize", initialize_model, -1);
+
+	rb_define_attr(cModel, "options", 1, 0);
+	
+	rb_define_method(cModel, "nlbl", model_nlbl, 0);
+	rb_define_method(cModel, "labels", model_labels, 0);
+	
+	rb_define_method(cModel, "nobs", model_nobs, 0);
+	rb_define_alias(cModel, "observations", "nobs");
+
+	rb_define_method(cModel, "nftr", model_nftr, 0);
+	rb_define_alias(cModel, "features", "nftr");
+
+	rb_define_method(cModel, "total", model_total, 0);
+
+	rb_define_method(cModel, "sync", model_sync, 0);
+	rb_define_method(cModel, "compact", model_compact, 0);
+	rb_define_method(cModel, "save", model_save, -1);
+	rb_define_method(cModel, "load", model_load, -1);
+
+	rb_define_method(cModel, "train", model_train, 1);
+	rb_define_method(cModel, "label", model_label, 1);
+}
+
+/* --- Top-Level Utility Methods --- */
+
+
+static VALUE label(VALUE self __attribute__((__unused__)), VALUE rb_options) {
+	if (strncmp("Wapiti::Options", rb_obj_classname(rb_options), 15) != 0) {
+		rb_raise(cNativeError, "argument must be a native options instance");
+	} 
+
+	opt_t *options = get_options(rb_options);
+
+	if (options->mode != 1) {
+		rb_raise(cNativeError, "invalid options argument: mode should be set to 1 for labelling");
+	}
+
+	mdl_t *model = mdl_new(rdr_new(options->maxent));
+	model->opt = options;
+
+	dolabel(model);
+	
+	mdl_free(model);
+
+	return Qnil;
+}
+
+static VALUE dump(VALUE self __attribute__((__unused__)), VALUE rb_options) {
+	if (strncmp("Wapiti::Options", rb_obj_classname(rb_options), 15) != 0) {
+		rb_raise(cNativeError, "argument must be a native options instance");
+	} 
+
+	opt_t *options = get_options(rb_options);
+
+	if (options->mode != 2) {
+		rb_raise(cNativeError, "invalid options argument: mode should be set to 2 for training");
+	}
+
+	mdl_t *model = mdl_new(rdr_new(options->maxent));
+	model->opt = options;
+
+	dodump(model);
+	
+	mdl_free(model);
+
+	return Qnil;	
+}
+
+// This function is a proxy for Wapiti's main entry point.
+static VALUE wapiti(VALUE self __attribute__((__unused__)), VALUE arguments) {
+	int result = -1, argc = 0;
+	char **ap, *argv[18], *input, *tmp;
+	
+	Check_Type(arguments, T_STRING);
+	tmp = StringValueCStr(arguments);
+	
+	// allocate space for argument vector
+	input = (char*)malloc(strlen(tmp) + 8);
+	
+	// prepend command name
+	strncpy(input, "wapiti ", 8);
+	strncat(input, tmp, strlen(input) - 8);
+	
+	// remember allocation pointer
+	tmp = input;
+	
+	// turn input string into argument vector (using
+	// only the first seventeen tokens from input)
+	for (ap = argv; (*ap = strsep(&input, " \t")) != (char*)0; ++argc) {
+		if ((**ap != '\0') && (++ap >= &argv[18])) break;
+	}
+	
+	// call main entry point
+	result = wapiti_main(argc, argv);
+	
+	// free allocated memory
+	free(tmp);
+	
+	return INT2FIX(result);
+}
+
+/* --- Wapiti Extension Entry Point --- */
+
+void Init_native() {
+	mWapiti = rb_const_get(rb_mKernel, rb_intern("Wapiti"));
+	mNative = rb_define_module_under(mWapiti, "Native");
+
+	cNativeError = rb_const_get(mWapiti, rb_intern("NativeError"));
+	cConfigurationError = rb_const_get(mWapiti, rb_intern("ConfigurationError"));
+	cLogger = rb_funcall(mWapiti, rb_intern("log"), 0);
+
+	rb_define_singleton_method(mNative, "label", label, 1);		
+	rb_define_singleton_method(mNative, "wapiti", wapiti, 1);
+	
+	rb_define_const(mNative, "VERSION", rb_str_new2(VERSION));
+	
+	Init_options();
+	Init_model();
+}