wapiti 0.0.5 → 0.1.0

data/ext/wapiti/gradient.h

@@ -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
@@ -32,50 +32,68 @@
 #include "model.h"
 #include "sequence.h"
 
-/* grd_t:
+/* grd_st_t:
  *   State tracker for the gradient computation. To compute the gradient we need
  *   to perform several steps and communicate between them a lot of intermediate
- *   values, all these temporary are store in this object.
+ *   values, all these temporary are stored in this object.
  *   A tracker can be used to compute sequence of length <len> at most, before
- *   using it you must call grd_check to ensure that the tracker is big enough
+ *   using it you must call grd_stcheck to ensure that the tracker is big enough
  *   for your sequence.
+ *   This tracker is used to perform single sample gradient computations or
+ *   partial gradient computation in online algorithms and for decoding with
+ *   posteriors.
  */
-typedef struct grd_s grd_t;
-struct grd_s {
-	mdl_t  *mdl;
-	int     len;     // =T        max length of sequence
-	double *g;       // [F]       vector where to put gradient updates
-	double  lloss;   //           loss value for the sequence
-	double *psi;     // [T][Y][Y] the transitions scores
-	double *psiuni;  // [T][Y]    | Same as psi in sparse format
-	size_t *psiyp;   // [T][Y][Y] |
-	size_t *psiidx;  // [T][Y]    |
-	size_t *psioff;  // [T]
-	double *alpha;   // [T][Y]    forward scores
-	double *beta;    // [T][Y]    backward scores
-	double *scale;   // [T]       scaling factors of forward scores
-	double *unorm;   // [T]       normalization factors for unigrams
-	double *bnorm;   // [T]       normalization factors for bigrams
-	int     first;   //           first position where gradient is needed
-	int     last;    //           last position where gradient is needed
+typedef struct grd_st_s grd_st_t;
+struct grd_st_s {
+	mdl_t    *mdl;
+	uint32_t len;     // =T        max length of sequence
+	double   *g;       // [F]       vector where to put gradient updates
+	double    lloss;   //           loss value for the sequence
+	double   *psi;     // [T][Y][Y] the transitions scores
+	double   *psiuni;  // [T][Y]    | Same as psi in sparse format
+	uint32_t *psiyp;   // [T][Y][Y] |
+	uint32_t *psiidx;  // [T][Y]    |
+	uint32_t *psioff;  // [T]
+	double   *alpha;   // [T][Y]    forward scores
+	double   *beta;    // [T][Y]    backward scores
+	double   *scale;   // [T]       scaling factors of forward scores
+	double   *unorm;   // [T]       normalization factors for unigrams
+	double   *bnorm;   // [T]       normalization factors for bigrams
+	uint32_t  first;   //           first position where gradient is needed
+	uint32_t  last;    //           last position where gradient is needed
 };
 
-grd_t *grd_new(mdl_t *mdl, double *g);
-void grd_free(grd_t *grd);
-void grd_check(grd_t *grd, int len);
+grd_st_t *grd_stnew(mdl_t *mdl, double *g);
+void grd_stfree(grd_st_t *grd_st);
+void grd_stcheck(grd_st_t *grd_st, uint32_t len);
+
+void grd_fldopsi(grd_st_t *grd_st, const seq_t *seq);
+void grd_flfwdbwd(grd_st_t *grd_st, const seq_t *seq);
+void grd_flupgrad(grd_st_t *grd_st, const seq_t *seq);
+
+void grd_spdopsi(grd_st_t *grd_st, const seq_t *seq);
+void grd_spfwdbwd(grd_st_t *grd_st, const seq_t *seq);
+void grd_spupgrad(grd_st_t *grd_st, const seq_t *seq);
 
-void grd_fldopsi(grd_t *grd, const seq_t *seq);
-void grd_flfwdbwd(grd_t *grd, const seq_t *seq);
-void grd_flupgrad(grd_t *grd, const seq_t *seq);
+void grd_logloss(grd_st_t *grd_st, const seq_t *seq);
 
-void grd_spdopsi(grd_t *grd, const seq_t *seq);
-void grd_spfwdbwd(grd_t *grd, const seq_t *seq);
-void grd_spupgrad(grd_t *grd, const seq_t *seq);
+void grd_dospl(grd_st_t *grd_st, const seq_t *seq);
 
-void grd_logloss(grd_t *grd, const seq_t *seq);
+/* grd_t:
+ *   Multi-threaded full dataset gradient computer. This is used to compute the
+ *   gradient by algorithm working on the full dataset at each iterations. It
+ *   efficiently compute it using the fact it is additive to use as many threads
+ *   as allowed.
+ */
+typedef struct grd_s grd_t;
+struct grd_s {
+	mdl_t     *mdl;
+	grd_st_t **grd_st;
+};
 
-void grd_dospl(grd_t *grd, const seq_t *seq);
-double grd_gradient(mdl_t *mdl, double *g, grd_t *grds[]);
+grd_t *grd_new(mdl_t *mdl, double *g);
+void   grd_free(grd_t *grd);
+double grd_gradient(grd_t *grd);
 
 #endif
 

data/ext/wapiti/lbfgs.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
@@ -24,9 +24,12 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
+#include <inttypes.h>
 #include <math.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -58,12 +61,11 @@
  ******************************************************************************/
 
 void trn_lbfgs(mdl_t *mdl) {
-	const size_t F  = mdl->nftr;
-	const int    K  = mdl->opt->maxiter;
-	const int    C  = mdl->opt->objwin;
-	const int    M  = mdl->opt->lbfgs.histsz;
-	const size_t W  = mdl->opt->nthread;
-	const bool   l1 = mdl->opt->rho1 != 0.0;
+	const uint64_t F  = mdl->nftr;
+	const uint32_t K  = mdl->opt->maxiter;
+	const uint32_t C  = mdl->opt->objwin;
+	const uint32_t M  = mdl->opt->lbfgs.histsz;
+	const bool     l1 = mdl->opt->rho1 != 0.0;
 	double *x, *xp; // Current and previous value of the variables
 	double *g, *gp; // Current and previous value of the gradient
 	double *pg;     // The pseudo-gradient (only for owl-qn)
@@ -72,7 +74,6 @@ void trn_lbfgs(mdl_t *mdl) {
 	double *y[M];   // History value y_k = Δ(g,pg)
 	double  p[M];   // ρ_k
 	double  fh[C];  // f(x) history
-	grd_t  *grds[W];
 	// Initialization: Here, we have to allocate memory on the heap as we
 	// cannot request so much memory on the stack as this will have a too
 	// big impact on performance and will be refused by the system on non-
@@ -80,22 +81,50 @@ void trn_lbfgs(mdl_t *mdl) {
 	x  = mdl->theta;
 	xp = xvm_new(F); g = xvm_new(F);
 	gp = xvm_new(F); d = xvm_new(F);
-	for (int m = 0; m < M; m++) {
+	for (uint32_t m = 0; m < M; m++) {
 		s[m] = xvm_new(F);
 		y[m] = xvm_new(F);
 	}
 	pg = l1 ? xvm_new(F) : NULL;
-	grds[0] = grd_new(mdl, g);
-	for (size_t w = 1; w < W; w++)
-		grds[w] = grd_new(mdl, xvm_new(F));
+	grd_t *grd = grd_new(mdl, g);
+	// Restore a saved state if user specified one.
+	if (mdl->opt->rstate != NULL) {
+		const char *err = "invalid state file";
+		FILE *file = fopen(mdl->opt->rstate, "r");
+		if (file == NULL)
+			fatal("failed to open input state file");
+		int type, histsz;
+		uint64_t nftr;
+		if (fscanf(file, "#state#%d#%d#%"SCNu64"\n", &type, &histsz,
+				&nftr) != 3)
+			fatal("0 %s", err);
+		if (type != 0 || histsz != (int)M)
+			fatal("state is not compatible");
+		for (uint64_t i = 0; i < nftr; i++) {
+			uint64_t f;
+			if (fscanf(file, "%"PRIu64, &f) != 1)
+				fatal("1 %s", err);
+			if (fscanf(file, "%la %la", &xp[f], &gp[f]) != 2)
+				fatal("2 %s", err);
+			for (uint32_t m = 0; m < M; m++) {
+				if (fscanf(file, "%la", &s[m][f]) != 1)
+					fatal("3 %s", err);
+				if (fscanf(file, "%la", &y[m][f]) != 1)
+					fatal("4 %s", err);
+			}
+		}
+		for (uint32_t m = 0; m < M; m++)
+			p[m] = 1.0 / xvm_dot(y[m], s[m], F);
+		fclose(file);
+	}
 	// Minimization: This is the heart of the function. (a big heart...) We
 	// will perform iterations until one these conditions is reached
 	//   - the maximum iteration count is reached
 	//   - we have converged (upto numerical precision)
 	//   - the report function return false
 	//   - an error happen somewhere
-	double fx = grd_gradient(mdl, g, grds);
-	for (int k = 0; !uit_stop && k < K; k++) {
+	double fx = grd_gradient(grd);
+	for (uint32_t k = 0; !uit_stop && k < K; k++) {
 		// We first compute the pseudo-gradient of f for owl-qn. It is
 		// defined in [3, pp 335(4)]
 		//              | ∂_i^- f(x)   if ∂_i^- f(x) > 0
@@ -106,7 +135,7 @@ void trn_lbfgs(mdl_t *mdl) {
 		//                              | ±C      if x_i = 0
 		if (l1) {
 			const double rho1 = mdl->opt->rho1;
-			for (unsigned f = 0; f < F; f++) {
+			for (uint64_t f = 0; f < F; f++) {
 				if (x[f] < 0.0)
 					pg[f] = g[f] - rho1;
 				else if (x[f] > 0.0)
@@ -130,13 +159,13 @@ void trn_lbfgs(mdl_t *mdl) {
 		// gradient instead of the true one.
 		xvm_neg(d, l1 ? pg : g, F);
 		if (k != 0) {
-			const int km = k % M;
-			const int bnd = (k <= M) ? k : M;
+			const uint32_t km = k % M;
+			const uint32_t bnd = (k <= M) ? k : M;
 			double alpha[M], beta;
 			// α_i = ρ_j s_j^T q_{i+1}
 			// q_i = q_{i+1} - α_i y_i
-			for (int i = bnd; i > 0; i--) {
-				const int j = (k - i + M + 1) % M;
+			for (uint32_t i = bnd; i > 0; i--) {
+				const uint32_t j = (M + 1 + k - i) % M;
 				alpha[i - 1] = p[j] * xvm_dot(s[j], d, F);
 				xvm_axpy(d, -alpha[i - 1], y[j], d, F);
 			}
@@ -147,12 +176,12 @@ void trn_lbfgs(mdl_t *mdl) {
 			//                    = I * 1 / ρ_k ||y_k||²
 			const double y2 = xvm_dot(y[km], y[km], F);
 			const double v = 1.0 / (p[km] * y2);
-			for (size_t f = 0; f < F; f++)
+			for (uint64_t f = 0; f < F; f++)
 				d[f] *= v;
 			// β_j     = ρ_j y_j^T r_i
 			// r_{i+1} = r_i + s_j (α_i - β_i)
-			for (int i = 0; i < bnd; i++) {
-				const int j = (k - i + M) % M;
+			for (uint32_t i = 0; i < bnd; i++) {
+				const uint32_t j = (M + k - i) % M;
 				beta = p[j] * xvm_dot(y[j], d, F);
 				xvm_axpy(d, alpha[i] - beta, s[j], d, F);
 			}
@@ -163,7 +192,7 @@ void trn_lbfgs(mdl_t *mdl) {
 		//   d^k = π(d^k ; v^k)
 		//       = π(d^k ; -◇f(x^k))
 		if (l1)
-			for (size_t f = 0; f < F; f++)
+			for (uint64_t f = 0; f < F; f++)
 				if (d[f] * pg[f] >= 0.0)
 					d[f] = 0.0;
 		// 2nd step: we perform a linesearch in the computed direction,
@@ -184,7 +213,7 @@ void trn_lbfgs(mdl_t *mdl) {
 		double gd  = l1 ? 0.0 : xvm_dot(g, d, F); // gd = g_k^T d_k
 		double fi  = fx;
 		bool err = false;
-		for (int ls = 1; !uit_stop; ls++, stp *= sc) {
+		for (uint32_t ls = 1; !uit_stop; ls++, stp *= sc) {
 			// We compute the new point using the current step and
 			// search direction
 			xvm_axpy(x, stp, d, xp, F);
@@ -192,7 +221,7 @@ void trn_lbfgs(mdl_t *mdl) {
 			// current orthant [3, pp 35]
 			//   x^{k+1} = π(x^k + αp^k ; ξ)
 			if (l1) {
-				for (size_t f = 0; f < F; f++) {
+				for (uint64_t f = 0; f < F; f++) {
 					double or = xp[f];
 					if (or == 0.0)
 						or = -pg[f];
@@ -202,7 +231,7 @@ void trn_lbfgs(mdl_t *mdl) {
 			}
 			// And we ask for the value of the objective function
 			// and its gradient.
-			fx = grd_gradient(mdl, g, grds);
+			fx = grd_gradient(grd);
 			// Now we check if the step satisfy the conditions. For
 			// l-bfgs, we check the classical decrease and curvature
 			// known as the Wolfe conditions [2, pp 506]
@@ -221,7 +250,7 @@ void trn_lbfgs(mdl_t *mdl) {
 					break;
 			} else {
 				double vp = 0.0;
-				for (size_t f = 0; f < F; f++)
+				for (uint64_t f = 0; f < F; f++)
 					vp += (x[f] - xp[f]) * d[f];
 				if (fx < fi + vp * 1e-4)
 					break;
@@ -249,7 +278,7 @@ void trn_lbfgs(mdl_t *mdl) {
 		//   s_k = x_{k+1} - x_k
 		//   y_k = g_{k+1} - g_k
 		//   ρ_k = 1 / y_k^T s_k
-		const int kn = (k + 1) % M;
+		const uint32_t kn = (k + 1) % M;
 		xvm_sub(s[kn], x, xp, F);
 		xvm_sub(y[kn], g, gp, F);
 		p[kn] = 1.0 / xvm_dot(y[kn], s[kn], F);
@@ -277,18 +306,30 @@ void trn_lbfgs(mdl_t *mdl) {
 				break;
 		}
 	}
+	// Save the optimizer state if requested by the user
+	if (mdl->opt->sstate != NULL) {
+		FILE *file = fopen(mdl->opt->sstate, "w");
+		if (file == NULL)
+			fatal("failed to open output state file");
+		fprintf(file, "#state#0#%"PRIu32"#%"PRIu64"\n", M, F);
+		for (uint64_t f = 0; f < F; f++) {
+			fprintf(file, "%"PRIu64, f);
+			fprintf(file, " %la %la", xp[f], gp[f]);
+			for (uint32_t m = 0; m < M; m++)
+				fprintf(file, " %la %la", s[m][f], y[m][f]);
+			fprintf(file, "\n");
+		}
+		fclose(file);
+	}
 	// Cleanup: We free all the vectors we have allocated.
 	xvm_free(xp); xvm_free(g);
 	xvm_free(gp); xvm_free(d);
-	for (int m = 0; m < M; m++) {
+	for (uint32_t m = 0; m < M; m++) {
 		xvm_free(s[m]);
 		xvm_free(y[m]);
 	}
 	if (l1)
 		xvm_free(pg);
-	for (size_t w = 1; w < W; w++)
-		xvm_free(grds[w]->g);
-	for (size_t w = 0; w < W; w++)
-		grd_free(grds[w]);
+	grd_free(grd);
 }
 

data/ext/wapiti/model.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
@@ -24,8 +24,10 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -120,8 +122,8 @@ void mdl_free(mdl_t *mdl) {
  *   This reduce the risk of mistakes.
  */
 void mdl_sync(mdl_t *mdl) {
-	const size_t Y = qrk_count(mdl->reader->lbl);
-	const size_t O = qrk_count(mdl->reader->obs);
+	const uint32_t Y = qrk_count(mdl->reader->lbl);
+	const uint64_t O = qrk_count(mdl->reader->obs);
 	// If model is already synchronized, do nothing and just return
 	if (mdl->nlbl == Y && mdl->nobs == O)
 		return;
@@ -131,8 +133,8 @@ void mdl_sync(mdl_t *mdl) {
 	// case we also display a warning as this is probably not expected by
 	// the user. If only new observations was added, we will try to expand
 	// the model.
-	size_t oldF = mdl->nftr;
-	size_t oldO = mdl->nobs;
+	uint64_t oldF = mdl->nftr;
+	uint64_t oldO = mdl->nobs;
 	if (mdl->nlbl != Y && mdl->nlbl != 0) {
 		warning("labels count changed, discarding the model");
 		free(mdl->kind);  mdl->kind  = NULL;
@@ -148,16 +150,16 @@ void mdl_sync(mdl_t *mdl) {
 	mdl->nobs = O;
 	// Allocate the observations datastructure. If the model is empty or
 	// discarded, a new one iscreated, else the old one is expanded.
-	char   *kind = wapiti_xrealloc(mdl->kind, sizeof(char  ) * O);
-	size_t *uoff = wapiti_xrealloc(mdl->uoff, sizeof(size_t) * O);
-	size_t *boff = wapiti_xrealloc(mdl->boff, sizeof(size_t) * O);
+	char     *kind = wapiti_xrealloc(mdl->kind, sizeof(char    ) * O);
+	uint64_t *uoff = wapiti_xrealloc(mdl->uoff, sizeof(uint64_t) * O);
+	uint64_t *boff = wapiti_xrealloc(mdl->boff, sizeof(uint64_t) * O);
 	mdl->kind = kind;
 	mdl->uoff = uoff;
 	mdl->boff = boff;
 	// Now, we can setup the features. For each new observations we fill the
 	// kind and offsets arrays and count total number of features as well.
-	size_t F = oldF;
-	for (size_t o = oldO; o < O; o++) {
+	uint64_t F = oldF;
+	for (uint64_t o = oldO; o < O; o++) {
 		const char *obs = qrk_id2str(mdl->reader->obs, o);
 		switch (obs[0]) {
 			case 'u': kind[o] = 1; break;
@@ -176,14 +178,14 @@ void mdl_sync(mdl_t *mdl) {
 	// have to allocate a new vector and copy old values ourself.
 	if (oldF != 0) {
 		double *new = xvm_new(F);
-		for (size_t f = 0; f < oldF; f++)
+		for (uint64_t f = 0; f < oldF; f++)
 			new[f] = mdl->theta[f];
 		xvm_free(mdl->theta);
 		mdl->theta = new;
 	} else {
 		mdl->theta = xvm_new(F);
 	}
-	for (size_t f = oldF; f < F; f++)
+	for (uint64_t f = oldF; f < F; f++)
 		mdl->theta[f] = 0.0;
 	// And lock the databases
 	qrk_lock(mdl->reader->lbl, true);
@@ -197,7 +199,7 @@ void mdl_sync(mdl_t *mdl) {
  *   and labeling.
  */
 void mdl_compact(mdl_t *mdl) {
-	const size_t Y = mdl->nlbl;
+	const uint32_t Y = mdl->nlbl;
 	// We first build the new observation list with only observations which
 	// lead to at least one active feature. At the same time we build the
 	// translation table which map the new observations index to the old
@@ -205,29 +207,29 @@ void mdl_compact(mdl_t *mdl) {
 	info("    - Scan the model\n");
 	qrk_t *old_obs = mdl->reader->obs;
 	qrk_t *new_obs = qrk_new();
-	size_t *trans = wapiti_xmalloc(sizeof(size_t) * mdl->nobs);
-	for (size_t oldo = 0; oldo < mdl->nobs; oldo++) {
+	uint64_t *trans = wapiti_xmalloc(sizeof(uint64_t) * mdl->nobs);
+	for (uint64_t oldo = 0; oldo < mdl->nobs; oldo++) {
 		bool active = false;
 		if (mdl->kind[oldo] & 1)
-			for (size_t y = 0; y < Y; y++)
+			for (uint32_t y = 0; y < Y; y++)
 				if (mdl->theta[mdl->uoff[oldo] + y] != 0.0)
 					active = true;
 		if (mdl->kind[oldo] & 2)
-			for (size_t d = 0; d < Y * Y; d++)
+			for (uint32_t d = 0; d < Y * Y; d++)
 				if (mdl->theta[mdl->boff[oldo] + d] != 0.0)
 					active = true;
 		if (!active)
 			continue;
-		const char   *str  = qrk_id2str(old_obs, oldo);
-		const size_t  newo = qrk_str2id(new_obs, str);
+		const char     *str  = qrk_id2str(old_obs, oldo);
+		const uint64_t  newo = qrk_str2id(new_obs, str);
 		trans[newo] = oldo;
 	}
 	mdl->reader->obs = new_obs;
 	// Now we save the old model features informations and build a new one
 	// corresponding to the compacted model.
-	size_t *old_uoff  = mdl->uoff;  mdl->uoff  = NULL;
-	size_t *old_boff  = mdl->boff;  mdl->boff  = NULL;
-	double *old_theta = mdl->theta; mdl->theta = NULL;
+	uint64_t *old_uoff  = mdl->uoff;  mdl->uoff  = NULL;
+	uint64_t *old_boff  = mdl->boff;  mdl->boff  = NULL;
+	double   *old_theta = mdl->theta; mdl->theta = NULL;
 	free(mdl->kind);
 	mdl->kind = NULL;
 	mdl->nlbl = mdl->nobs = mdl->nftr = 0;
@@ -235,18 +237,18 @@ void mdl_compact(mdl_t *mdl) {
 	// The model is now ready, so we copy in it the features weights from
 	// the old model for observations we have kept.
 	info("    - Compact it\n");
-	for (size_t newo = 0; newo < mdl->nobs; newo++) {
-		const size_t oldo = trans[newo];
+	for (uint64_t newo = 0; newo < mdl->nobs; newo++) {
+		const uint64_t oldo = trans[newo];
 		if (mdl->kind[newo] & 1) {
 			double *src = old_theta  + old_uoff[oldo];
 			double *dst = mdl->theta + mdl->uoff[newo];
-			for (size_t y = 0; y < Y; y++)
+			for (uint32_t y = 0; y < Y; y++)
 				dst[y] = src[y];
 		}
 		if (mdl->kind[newo] & 2) {
 			double *src = old_theta  + old_boff[oldo];
 			double *dst = mdl->theta + mdl->boff[newo];
-			for (size_t d = 0; d < Y * Y; d++)
+			for (uint32_t d = 0; d < Y * Y; d++)
 				dst[d] = src[d];
 		}
 	}
@@ -262,15 +264,15 @@ void mdl_compact(mdl_t *mdl) {
  *   Save a model to be restored later in a platform independant way.
  */
 void mdl_save(mdl_t *mdl, FILE *file) {
-	size_t nact = 0;
-	for (size_t f = 0; f < mdl->nftr; f++)
+	uint64_t nact = 0;
+	for (uint64_t f = 0; f < mdl->nftr; f++)
 		if (mdl->theta[f] != 0.0)
 			nact++;
-	fprintf(file, "#mdl#%zu\n", nact);
+	fprintf(file, "#mdl#%d#%"PRIu64"\n", mdl->type, nact);
 	rdr_save(mdl->reader, file);
-	for (size_t f = 0; f < mdl->nftr; f++)
+	for (uint64_t f = 0; f < mdl->nftr; f++)
 		if (mdl->theta[f] != 0.0)
-			fprintf(file, "%zu=%la\n", f, mdl->theta[f]);
+			fprintf(file, "%"PRIu64"=%la\n", f, mdl->theta[f]);
 }
 
 /* mdl_load:
@@ -280,15 +282,23 @@ void mdl_save(mdl_t *mdl, FILE *file) {
  */
 void mdl_load(mdl_t *mdl, FILE *file) {
 	const char *err = "invalid model format";
-	size_t nact = 0;
-	if (fscanf(file, "#mdl#%zu\n", &nact) != 1)
-		fatal(err);
+	uint64_t nact = 0;
+	int type;
+	if (fscanf(file, "#mdl#%d#%"SCNu64"\n", &type, &nact) == 2) {
+		mdl->type = type;
+	} else {
+		rewind(file);
+		if (fscanf(file, "#mdl#%"SCNu64"\n", &nact) == 1)
+			mdl->type = 0;
+		else
+			fatal(err);
+	}
 	rdr_load(mdl->reader, file);
 	mdl_sync(mdl);
-	for (size_t i = 0; i < nact; i++) {
-		size_t f;
+	for (uint64_t i = 0; i < nact; i++) {
+		uint64_t f;
 		double v;
-		if (fscanf(file, "%zu=%la\n", &f, &v) != 2)
+		if (fscanf(file, "%"SCNu64"=%la\n", &f, &v) != 2)
 			fatal(err);
 		mdl->theta[f] = v;
 	}