wapiti 0.0.5 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b556f6c375171e82550f04adffc293154d90e370
+  data.tar.gz: 1a40a18e7e4f6afbbfc8a51d1aaef6a469375574
+SHA512:
+  metadata.gz: f904c8d7ce3b0c48a74f4f2e678b120626eb89ae9d22a3cc4b75d3b8c081d8dc0cffbe030a9a2b3132927a80c696e5df7eb6673a66420600ebcf7e09eb497282
+  data.tar.gz: 58be17b5b87d9ee0ee7fa6037492e1bb0b6070ae1611c640799ab318fcf8abfc074ef89bcb944297b428996f8b2b13fc9dfed6081d6fbf02c0d4bfd8e54e1ea3

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_filter 'spec/'
+end

data/Gemfile

@@ -1,6 +1,29 @@
-source :rubygems
+source 'https://rubygems.org'
 gemspec
 
-group :osx_test do
+group :debug do
+  gem 'debugger', '~>1.6', :require => false, :platform => :mri
+  gem 'rubinius-compiler', '~>2.0', :require => false, :platform => :rbx
+  gem 'rubinius-debugger', '~>2.0', :require => false, :platform => :rbx
+end
+
+group :development do
+  gem 'simplecov', '~>0.8', :require => false
+  gem 'rubinius-coverage', :platform => :rbx
+  gem 'coveralls', :require => false
+end
+
+group :extra do
+  gem 'ZenTest'
+  gem 'pry'
+end
+
+group :osx do
  gem 'autotest-fsevent', :require => false
 end
+
+platform :rbx do
+  gem 'rubysl', '~>2.0'
+  gem 'racc'
+  gem 'json'
+end

data/HISTORY.md

@@ -1,3 +1,7 @@
+0.1.0 / 2014-02-25
+==================
+* Updated to wapiti 1.5.0
+
 0.0.5 / 2011-09-06
 ==================
 * Added UTF-8 encoding to native result strings for Ruby 1.9
@@ -10,4 +14,4 @@
 
 0.0.2 / 2011-09-01
 ==================
-* Initial release
+* Initial release

data/LICENSE

@@ -1,8 +1,8 @@
 Wapiti-Ruby
-Copyright 2011 Sylvester Keil. All rights reserved.
+Copyright 2011-2014 Sylvester Keil. All rights reserved.
 
 Wapiti - A linear-chain CRF tool
-Copyright 2009-2011 CNRS. All rights reserved.
+Copyright 2009-2013  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:
@@ -14,17 +14,18 @@ modification, are permitted provided that the following conditions are met:
     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 HOLDER ``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 HOLDER 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.
+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.
 
 The views and conclusions contained in the software and documentation are
 those of the authors and should not be interpreted as representing official
-policies, either expressed or implied, of the copyright holder.
+policies, either expressed or implied, of the copyright holders.

data/README.md

@@ -1,24 +1,20 @@
 Wapiti-Ruby
 ===========
-
 The Wapiti-Ruby gem provides a wicked fast linear-chain CRF
 ([Conditional Random Fields](http://en.wikipedia.org/wiki/Conditional_random_field))
-API for sequence segmentation and labelling; it is based on the codebase of
-Thomas Lavergne's awesome [wapiti](http://wapiti.limsi.fr/).
+API for sequence segmentation and labelling; it is based on the
+codebase of [wapiti](http://wapiti.limsi.fr/).
 
+[![Build Status](https://secure.travis-ci.org/inukshuk/wapiti-ruby.png)](http://travis-ci.org/inukshuk/wapiti-ruby)
+[![Coverage Status](https://coveralls.io/repos/inukshuk/wapiti-ruby/badge.png?branch=master)](https://coveralls.io/r/inukshuk/wapiti-ruby?branch=master)
 
 Requirements
 ------------
-
 Wapiti is written in C and Ruby and requires a compiler with C99
 support (e.g., gcc); on GNU/Linux systems it will be fairly easy to install
-all necessary packages through your distribution; on Mac OS X you can either
-install Xcode or
-[osx-gcc-installer](https://github.com/kennethreitz/osx-gcc-installer);
-on Windows you may want to install RubyInstaller's
-[DevKit](https://github.com/oneclick/rubyinstaller/wiki/development-kit).
+all necessary packages through your distribution.
 
-The Wapiti Ruby gem has been confirmed to work with MRI 1.9, 1.8.7,
+The Wapiti Ruby gem has been confirmed to work with MRI 2.x, 1.9.x, 1.8.7,
 and Rubinius.
 
 
@@ -80,7 +76,7 @@ Before saving your model you can use `compact` to reduce the model's size:
 
 ### Loading existing Models
 
-    model = Wapiti::Model.load('m1.mod')
+    model = Wapiti.load('m1.mod')
 
 ### Labelling
 
@@ -150,7 +146,6 @@ are also available through the associated attribute readers).
 
 Citing
 ------
-
 If you're using Wapiti-Ruby for research purposes, please use the following
 citation of the original wapiti package:
 
@@ -174,7 +169,6 @@ welcome to also refer back to the
 
 Contributing
 ------------
-
 The Wapiti-Ruby source code is
 [hosted on GitHub](http://github.com/inukshuk/wapiti-ruby/).
 You can check out a copy of the latest code using Git:
@@ -189,9 +183,8 @@ example, fix the bug and submit a pull request.
 
 License
 -------
+Copyright 2011-2014 Sylvester Keil. All rights reserved.
 
-Copyright 2011 Sylvester Keil. All rights reserved.
-
-Copyright 2009-2011 CNRS. All rights reserved.
+Copyright 2009-2013 CNRS. All rights reserved.
 
 Wapiti-Ruby is distributed under a BSD-style license. See LICENSE for details.

data/Rakefile

@@ -1,25 +1,55 @@
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
+require 'bundler'
+begin
+  Bundler.setup
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
 
 require 'rake/clean'
-require 'rake/testtask'
 require 'rake/extensiontask'
 
+$:.unshift(File.join(File.dirname(__FILE__), './lib'))
 require 'wapiti/version'
 
-task :default => [:test]
 
 Rake::ExtensionTask.new do |ext|
   ext.name = 'native'
-  
+
   ext.ext_dir = 'ext/wapiti'
   ext.lib_dir = 'lib/wapiti'
-  
+
   CLEAN.include("#{ext.lib_dir}/native.*")
-  CLEAN.include("#{ext.tmp_dir}")  
-  
+  CLEAN.include("#{ext.tmp_dir}")
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Run an IRB session with Wapiti loaded'
+task :console do
+  require 'pry'
+  require 'wapiti'
+
+  Pry.start
+end
+
+task :check_warnings do
+  $VERBOSE = true
+  require 'wapiti'
+  puts Wapiti::VERSION
 end
 
+require 'coveralls/rake/task'
+Coveralls::RakeTask.new
+task :test_with_coveralls => [:compile, :spec, 'coveralls:push']
+
+task :default => [:compile, :spec]
+
 task :build => [:clean] do
   system 'gem build wapiti.gemspec'
 end

data/ext/wapiti/bcd.c

@@ -1,7 +1,7 @@
 /*
  *      Wapiti - A linear-chain CRF tool
  *
- * Copyright (c) 2009-2011  CNRS
+ * Copyright (c) 2009-2013  CNRS
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -29,6 +29,7 @@
 #include <math.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -58,13 +59,13 @@
  ******************************************************************************/
 typedef struct bcd_s bcd_t;
 struct bcd_s {
-	double *ugrd;    //  [Y]
-	double *uhes;    //  [Y]
-	double *bgrd;    //  [Y][Y]
-	double *bhes;    //  [Y][Y]
-	size_t *actpos;  //  [T]
-	size_t  actcnt;
-	grd_t  *grd;
+	double   *ugrd;    //  [Y]
+	double   *uhes;    //  [Y]
+	double   *bgrd;    //  [Y][Y]
+	double   *bhes;    //  [Y][Y]
+	uint32_t *actpos;  //  [T]
+	uint32_t  actcnt;
+	grd_st_t *grd_st;
 };
 
 /* bcd_soft:
@@ -80,19 +81,19 @@ static double bcd_soft(double z, double r) {
  *   List position where the given block is active in the sequence and setup the
  *   limits for the fwd/bwd.
  */
-static void bcd_actpos(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
-	const int T = seq->len;
-	size_t *actpos = bcd->actpos;
-	size_t  actcnt = 0;
-	for (int t = 0; t < T; t++) {
+static void bcd_actpos(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, uint64_t o) {
+	const uint32_t T = seq->len;
+	uint32_t *actpos = bcd->actpos;
+	uint32_t  actcnt = 0;
+	for (uint32_t t = 0; t < T; t++) {
 		const pos_t *pos = &(seq->pos[t]);
 		bool ok = false;
 		if (mdl->kind[o] & 1)
-			for (size_t n = 0; !ok && n < pos->ucnt; n++)
+			for (uint32_t n = 0; !ok && n < pos->ucnt; n++)
 				if (pos->uobs[n] == o)
 					ok = true;
 		if (mdl->kind[o] & 2)
-			for (size_t n = 0; !ok && n < pos->bcnt; n++)
+			for (uint32_t n = 0; !ok && n < pos->bcnt; n++)
 				if (pos->bobs[n] == o)
 					ok = true;
 		if (!ok)
@@ -101,8 +102,8 @@ static void bcd_actpos(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
 	}
 	assert(actcnt != 0);
 	bcd->actcnt = actcnt;
-	bcd->grd->first = actpos[0];
-	bcd->grd->last  = actpos[actcnt - 1];
+	bcd->grd_st->first = actpos[0];
+	bcd->grd_st->last  = actpos[actcnt - 1];
 }
 
 /* bct_flgradhes:
@@ -110,17 +111,17 @@ static void bcd_actpos(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
  *   very similar than the trn_spupgrad function but does the computation only
  *   at active pos and approximate also the hessian.
  */
-static void bcd_flgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
-	const grd_t *grd = bcd->grd;
-	const size_t Y = mdl->nlbl;
-	const size_t T = seq->len;
-	const double (*psi  )[T][Y][Y] = (void *)grd->psi;
-	const double (*alpha)[T][Y]    = (void *)grd->alpha;
-	const double (*beta )[T][Y]    = (void *)grd->beta;
-	const double  *unorm           =         grd->unorm;
-	const double  *bnorm           =         grd->bnorm;
-	const size_t  *actpos          =         bcd->actpos;
-	const size_t   actcnt          =         bcd->actcnt;
+static void bcd_flgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, uint64_t o) {
+	const grd_st_t *grd_st = bcd->grd_st;
+	const uint32_t Y = mdl->nlbl;
+	const uint32_t T = seq->len;
+	const double   (*psi  )[T][Y][Y] = (void *)grd_st->psi;
+	const double   (*alpha)[T][Y]    = (void *)grd_st->alpha;
+	const double   (*beta )[T][Y]    = (void *)grd_st->beta;
+	const double    *unorm           =         grd_st->unorm;
+	const double    *bnorm           =         grd_st->bnorm;
+	const uint32_t  *actpos          =         bcd->actpos;
+	const uint32_t   actcnt          =         bcd->actcnt;
 	double *ugrd = bcd->ugrd;
 	double *uhes = bcd->uhes;
 	double *bgrd = bcd->bgrd;
@@ -128,35 +129,35 @@ static void bcd_flgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
 	// Update the gradient and the hessian but here we sum only on the
 	// positions where the block is active for unigrams features
 	if (mdl->kind[o] & 1) {
-		for (size_t n = 0; n < actcnt; n++) {
-			const size_t t = actpos[n];
-			for (size_t y = 0; y < Y; y++) {
+		for (uint32_t n = 0; n < actcnt; n++) {
+			const uint32_t t = actpos[n];
+			for (uint32_t y = 0; y < Y; y++) {
 				const double e = (*alpha)[t][y] * (*beta)[t][y]
 				               * unorm[t];
 				ugrd[y] += e;
 				uhes[y] += e * (1.0 - e);
 			}
-			const size_t y = seq->pos[t].lbl;
+			const uint32_t y = seq->pos[t].lbl;
 			ugrd[y] -= 1.0;
 		}
 	}
 	if ((mdl->kind[o] & 2) == 0)
 		return;
 	// for bigrams features
-	for (size_t n = 0; n < actcnt; n++) {
-		const size_t t = actpos[n];
+	for (uint32_t n = 0; n < actcnt; n++) {
+		const uint32_t t = actpos[n];
 		if (t == 0)
 			continue;
-		for (size_t yp = 0, d = 0; yp < Y; yp++) {
-			for (size_t y = 0; y < Y; y++, d++) {
+		for (uint32_t yp = 0, d = 0; yp < Y; yp++) {
+			for (uint32_t y = 0; y < Y; y++, d++) {
 				double e = (*alpha)[t - 1][yp] * (*beta)[t][y]
 				         * (*psi)[t][yp][y] * bnorm[t];
 				bgrd[d] += e;
 				bhes[d] += e * (1.0 - e);
 			}
 		}
-		const size_t yp = seq->pos[t - 1].lbl;
-		const size_t y  = seq->pos[t    ].lbl;
+		const uint32_t yp = seq->pos[t - 1].lbl;
+		const uint32_t y  = seq->pos[t    ].lbl;
 		bgrd[yp * Y + y] -= 1.0;
 	}
 }
@@ -166,21 +167,21 @@ static void bcd_flgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
  *   very similar than the trn_spupgrad function but does the computation only
  *   at active pos and approximate also the hessian.
  */
-static void bcd_spgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
-	const grd_t *grd = bcd->grd;
-	const size_t Y = mdl->nlbl;
-	const size_t T = seq->len;
-	const double (*psiuni)[T][Y] = (void *)grd->psiuni;
-	const double  *psival        =         grd->psi;
-	const size_t  *psiyp         =         grd->psiyp;
-	const size_t (*psiidx)[T][Y] = (void *)grd->psiidx;
-	const size_t  *psioff        =         grd->psioff;
-	const double (*alpha)[T][Y]  = (void *)grd->alpha;
-	const double (*beta )[T][Y]  = (void *)grd->beta;
-	const double  *unorm         =         grd->unorm;
-	const double  *bnorm         =         grd->bnorm;
-	const size_t  *actpos        =         bcd->actpos;
-	const size_t   actcnt        =         bcd->actcnt;
+static void bcd_spgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, uint64_t o) {
+	const grd_st_t *grd_st = bcd->grd_st;
+	const uint32_t Y = mdl->nlbl;
+	const uint32_t T = seq->len;
+	const double   (*psiuni)[T][Y] = (void *)grd_st->psiuni;
+	const double    *psival        =         grd_st->psi;
+	const uint32_t  *psiyp         =         grd_st->psiyp;
+	const uint32_t (*psiidx)[T][Y] = (void *)grd_st->psiidx;
+	const uint32_t  *psioff        =         grd_st->psioff;
+	const double   (*alpha)[T][Y]  = (void *)grd_st->alpha;
+	const double   (*beta )[T][Y]  = (void *)grd_st->beta;
+	const double    *unorm         =         grd_st->unorm;
+	const double    *bnorm         =         grd_st->bnorm;
+	const uint32_t  *actpos        =         bcd->actpos;
+	const uint32_t   actcnt        =         bcd->actcnt;
 	double *ugrd = bcd->ugrd;
 	double *uhes = bcd->uhes;
 	double *bgrd = bcd->bgrd;
@@ -188,51 +189,51 @@ static void bcd_spgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
 	// Update the gradient and the hessian but here we sum only on the
 	// positions where the block is active for unigrams features
 	if (mdl->kind[o] & 1) {
-		for (size_t n = 0; n < actcnt; n++) {
-			const size_t t = actpos[n];
-			for (size_t y = 0; y < Y; y++) {
+		for (uint32_t n = 0; n < actcnt; n++) {
+			const uint32_t t = actpos[n];
+			for (uint32_t y = 0; y < Y; y++) {
 				const double e = (*alpha)[t][y] * (*beta)[t][y]
 				               * unorm[t];
 				ugrd[y] += e;
 				uhes[y] += e * (1.0 - e);
 			}
-			const size_t y = seq->pos[t].lbl;
+			const uint32_t y = seq->pos[t].lbl;
 			ugrd[y] -= 1.0;
 		}
 	}
 	if ((mdl->kind[o] & 2) == 0)
 		return;
 	// for bigrams features
-	for (size_t n = 0; n < actcnt; n++) {
-		const size_t t = actpos[n];
+	for (uint32_t n = 0; n < actcnt; n++) {
+		const uint32_t t = actpos[n];
 		if (t == 0)
 			continue;
 		// We build the expectation matrix
 		double e[Y][Y];
-		for (size_t yp = 0; yp < Y; yp++)
-			for (size_t y = 0; y < Y; y++)
+		for (uint32_t yp = 0; yp < Y; yp++)
+			for (uint32_t y = 0; y < Y; y++)
 				e[yp][y] = (*alpha)[t - 1][yp] * (*beta)[t][y]
 				         * (*psiuni)[t][y] * bnorm[t];
-		const size_t off = psioff[t];
-		for (size_t n = 0, y = 0; n < (*psiidx)[t][Y - 1]; ) {
+		const uint32_t off = psioff[t];
+		for (uint32_t n = 0, y = 0; n < (*psiidx)[t][Y - 1]; ) {
 			while (n >= (*psiidx)[t][y])
 				y++;
 			while (n < (*psiidx)[t][y]) {
-				const size_t yp = psiyp [off + n];
-				const double v  = psival[off + n];
+				const uint32_t yp = psiyp [off + n];
+				const double   v  = psival[off + n];
 				e[yp][y] += e[yp][y] * v;
 				n++;
 			}
 		}
 		// And use it
-		for (size_t yp = 0, d = 0; yp < Y; yp++) {
-			for (size_t y = 0; y < Y; y++, d++) {
+		for (uint32_t yp = 0, d = 0; yp < Y; yp++) {
+			for (uint32_t y = 0; y < Y; y++, d++) {
 				bgrd[d] += e[yp][y];
 				bhes[d] += e[yp][y] * (1.0 - e[yp][y]);
 			}
 		}
-		const size_t yp = seq->pos[t - 1].lbl;
-		const size_t y  = seq->pos[t    ].lbl;
+		const uint32_t yp = seq->pos[t - 1].lbl;
+		const uint32_t y  = seq->pos[t    ].lbl;
 		bgrd[yp * Y + y] -= 1.0;
 	}
 }
@@ -240,24 +241,24 @@ static void bcd_spgradhes(mdl_t *mdl, bcd_t *bcd, const seq_t *seq, size_t o) {
 /* bct_update:
  *   Update the model with the computed gradient and hessian.
  */
-static void bcd_update(mdl_t *mdl, bcd_t *bcd, size_t o) {
-	const double  rho1  = mdl->opt->rho1;
-	const double  rho2  = mdl->opt->rho2;
-	const double  kappa = mdl->opt->bcd.kappa;
-	const size_t  Y     = mdl->nlbl;
-	const double *ugrd  = bcd->ugrd;
-	const double *bgrd  = bcd->bgrd;
-	      double *uhes  = bcd->uhes;
-	      double *bhes  = bcd->bhes;
+static void bcd_update(mdl_t *mdl, bcd_t *bcd, uint64_t o) {
+	const double    rho1  = mdl->opt->rho1;
+	const double    rho2  = mdl->opt->rho2;
+	const double    kappa = mdl->opt->bcd.kappa;
+	const uint32_t  Y     = mdl->nlbl;
+	const double   *ugrd  = bcd->ugrd;
+	const double   *bgrd  = bcd->bgrd;
+	      double   *uhes  = bcd->uhes;
+	      double   *bhes  = bcd->bhes;
 	if (mdl->kind[o] & 1) {
 		// Adjust the hessian
 		double a = 1.0;
-		for (size_t y = 0; y < Y; y++)
+		for (uint32_t y = 0; y < Y; y++)
 			a = max(a, fabs(ugrd[y] / uhes[y]));
 		xvm_scale(uhes, uhes, a * kappa, Y);
 		// Update the model
 		double *w = mdl->theta + mdl->uoff[o];
-		for (size_t y = 0; y < Y; y++) {
+		for (uint32_t y = 0; y < Y; y++) {
 			double z = uhes[y] * w[y] - ugrd[y];
 			double d = uhes[y] + rho2;
 			w[y] = bcd_soft(z, rho1) / d;
@@ -266,12 +267,12 @@ static void bcd_update(mdl_t *mdl, bcd_t *bcd, size_t o) {
 	if (mdl->kind[o] & 2) {
 		// Adjust the hessian
 		double a = 1.0;
-		for (size_t i = 0; i < Y * Y; i++)
+		for (uint32_t i = 0; i < Y * Y; i++)
 			a = max(a, fabs(bgrd[i] / bhes[i]));
 		xvm_scale(bhes, bhes, a * kappa, Y * Y);
 		// Update the model
 		double *bw = mdl->theta + mdl->boff[o];
-		for (size_t i = 0; i < Y * Y; i++) {
+		for (uint32_t i = 0; i < Y * Y; i++) {
 			double z = bhes[i] * bw[i] - bgrd[i];
 			double d = bhes[i] + rho2;
 			bw[i] = bcd_soft(z, rho1) / d;
@@ -283,108 +284,109 @@ static void bcd_update(mdl_t *mdl, bcd_t *bcd, size_t o) {
  *   Train the model using the blockwise coordinates descend method.
  */
 void trn_bcd(mdl_t *mdl) {
-	const size_t Y = mdl->nlbl;
-	const size_t O = mdl->nobs;
-	const size_t T = mdl->train->mlen;
-	const size_t S = mdl->train->nseq;
-	const int    K = mdl->opt->maxiter;
+	const uint32_t Y = mdl->nlbl;
+	const uint64_t O = mdl->nobs;
+	const uint32_t S = mdl->train->nseq;
+	const uint32_t T = mdl->train->mlen;
+	const uint32_t K = mdl->opt->maxiter;
 	// Build the index:
 	//   Count active sequences per blocks
 	info("    - Build the index\n");
 	info("        1/2 -- scan the sequences\n");
-	size_t tot = 0, cnt[O], lcl[O];
-	for (size_t o = 0; o < O; o++)
-		cnt[o] = 0, lcl[o] = none;
-	for (size_t s = 0; s < S; s++) {
+	uint64_t tot = 0;
+	uint32_t cnt[O], lcl[O];
+	for (uint64_t o = 0; o < O; o++)
+		cnt[o] = 0, lcl[o] = (uint32_t)-1;
+	for (uint32_t s = 0; s < S; s++) {
 		// List actives blocks
 		const seq_t *seq = mdl->train->seq[s];
-		for (int t = 0; t < seq->len; t++) {
-			for (size_t b = 0; b < seq->pos[t].ucnt; b++)
+		for (uint32_t t = 0; t < seq->len; t++) {
+			for (uint32_t b = 0; b < seq->pos[t].ucnt; b++)
 				lcl[seq->pos[t].uobs[b]] = s;
-			for (size_t b = 0; b < seq->pos[t].bcnt; b++)
+			for (uint32_t b = 0; b < seq->pos[t].bcnt; b++)
 				lcl[seq->pos[t].bobs[b]] = s;
 		}
 		// Updates blocks count
-		for (size_t o = 0; o < O; o++)
+		for (uint64_t o = 0; o < O; o++)
 			cnt[o] += (lcl[o] == s);
 	}
-	for (size_t o = 0; o < O; o++)
+	for (uint64_t o = 0; o < O; o++)
 		tot += cnt[o];
 	// Allocate memory
-	size_t  *idx_cnt = xmalloc(sizeof(size_t  ) * O);
-	size_t **idx_lst = xmalloc(sizeof(size_t *) * O);
-	for (size_t o = 0; o < O; o++) {
+	uint32_t  *idx_cnt = wapiti_xmalloc(sizeof(uint32_t  ) * O);
+	uint32_t **idx_lst = wapiti_xmalloc(sizeof(uint32_t *) * O);
+	for (uint64_t o = 0; o < O; o++) {
 		idx_cnt[o] = cnt[o];
-		idx_lst[o] = xmalloc(sizeof(size_t) * cnt[o]);
+		idx_lst[o] = wapiti_xmalloc(sizeof(uint32_t) * cnt[o]);
 	}
 	// Populate the index
 	info("        2/2 -- Populate the index\n");
-	for (size_t o = 0; o < O; o++)
-		cnt[o] = 0, lcl[o] = none;
-	for (size_t s = 0; s < S; s++) {
+	for (uint64_t o = 0; o < O; o++)
+		cnt[o] = 0, lcl[o] = (uint32_t)-1;
+	for (uint32_t s = 0; s < S; s++) {
 		// List actives blocks
 		const seq_t *seq = mdl->train->seq[s];
-		for (int t = 0; t < seq->len; t++) {
-			for (size_t b = 0; b < seq->pos[t].ucnt; b++)
+		for (uint32_t t = 0; t < seq->len; t++) {
+			for (uint32_t b = 0; b < seq->pos[t].ucnt; b++)
 				lcl[seq->pos[t].uobs[b]] = s;
-			for (size_t b = 0; b < seq->pos[t].bcnt; b++)
+			for (uint32_t b = 0; b < seq->pos[t].bcnt; b++)
 				lcl[seq->pos[t].bobs[b]] = s;
 		}
 		// Build index
-		for (size_t o = 0; o < O; o++)
+		for (uint64_t o = 0; o < O; o++)
 			if (lcl[o] == s)
 				idx_lst[o][cnt[o]++] = s;
 	}
 	info("      Done\n");
 	// Allocate the specific trainer of BCD
-	bcd_t *bcd = xmalloc(sizeof(bcd_t));
+	bcd_t *bcd = wapiti_xmalloc(sizeof(bcd_t));
 	bcd->ugrd   = xvm_new(Y);
 	bcd->uhes   = xvm_new(Y);
 	bcd->bgrd   = xvm_new(Y * Y);
 	bcd->bhes   = xvm_new(Y * Y);
-	bcd->actpos = xmalloc(sizeof(size_t) * T);
-	bcd->grd    = grd_new(mdl, NULL);
+	bcd->actpos = wapiti_xmalloc(sizeof(int) * T);
+	bcd->grd_st = grd_stnew(mdl, NULL);
 	// And train the model
-	for (int i = 0; i < K; i++) {
-		for (size_t o = 0; o < O; o++) {
+	for (uint32_t i = 1; i <= K; i++) {
+		for (uint64_t o = 0; o < O; o++) {
 			// Clear the gradient and the hessian
-			for (size_t y = 0, d = 0; y < Y; y++) {
+			for (uint32_t y = 0, d = 0; y < Y; y++) {
 				bcd->ugrd[y] = 0.0;
 				bcd->uhes[y] = 0.0;
-				for (size_t yp = 0; yp < Y; yp++, d++) {
+				for (uint32_t yp = 0; yp < Y; yp++, d++) {
 					bcd->bgrd[d] = 0.0;
 					bcd->bhes[d] = 0.0;
 				}
 			}
 			// Process active sequences
-			for (size_t s = 0; s < idx_cnt[o]; s++) {
-				const size_t id = idx_lst[o][s];
+			for (uint32_t s = 0; s < idx_cnt[o]; s++) {
+				const uint32_t id = idx_lst[o][s];
 				const seq_t *seq = mdl->train->seq[id];
 				bcd_actpos(mdl, bcd, seq, o);
-				grd_check(bcd->grd, seq->len);
+				grd_stcheck(bcd->grd_st, seq->len);
 				if (mdl->opt->sparse) {
-					grd_spdopsi(bcd->grd, seq);
-					grd_spfwdbwd(bcd->grd, seq);
+					grd_spdopsi(bcd->grd_st, seq);
+					grd_spfwdbwd(bcd->grd_st, seq);
 					bcd_spgradhes(mdl, bcd, seq, o);
 				} else {
-					grd_fldopsi(bcd->grd, seq);
-					grd_flfwdbwd(bcd->grd, seq);
+					grd_fldopsi(bcd->grd_st, seq);
+					grd_flfwdbwd(bcd->grd_st, seq);
 					bcd_flgradhes(mdl, bcd, seq, o);
 				}
 			}
 			// And update the model
 			bcd_update(mdl, bcd, o);
 		}
-		if (!uit_progress(mdl, i + 1, -1.0))
+		if (!uit_progress(mdl, i, -1.0))
 			break;
 	}
 	// Cleanup memory
-	grd_free(bcd->grd);
+	grd_stfree(bcd->grd_st);
 	xvm_free(bcd->ugrd); xvm_free(bcd->uhes);
 	xvm_free(bcd->bgrd); xvm_free(bcd->bhes);
 	free(bcd->actpos);
 	free(bcd);
-	for (size_t o = 0; o < O; o++)
+	for (uint64_t o = 0; o < O; o++)
 		free(idx_lst[o]);
 	free(idx_lst);
 	free(idx_cnt);