eluka 0.1.0

data/ext/libsvm/java/libsvm/svm_model.java

@@ -0,0 +1,21 @@
+//
+// svm_model
+//
+package libsvm;
+public class svm_model implements java.io.Serializable
+{
+	public svm_parameter param;	// parameter
+	public int nr_class;		// number of classes, = 2 in regression/one class svm
+	public int l;			// total #SV
+	public svm_node[][] SV;	// SVs (SV[l])
+	public double[][] sv_coef;	// coefficients for SVs in decision functions (sv_coef[k-1][l])
+	public double[] rho;		// constants in decision functions (rho[k*(k-1)/2])
+	public double[] probA;         // pariwise probability information
+	public double[] probB;
+
+	// for classification only
+
+	public int[] label;		// label of each class (label[k])
+	public int[] nSV;		// number of SVs for each class (nSV[k])
+				// nSV[0] + nSV[1] + ... + nSV[k-1] = l
+};

data/ext/libsvm/java/libsvm/svm_node.java

@@ -0,0 +1,6 @@
+package libsvm;
+public class svm_node implements java.io.Serializable
+{
+	public int index;
+	public double value;
+}

data/ext/libsvm/java/libsvm/svm_parameter.java

@@ -0,0 +1,47 @@
+package libsvm;
+public class svm_parameter implements Cloneable,java.io.Serializable
+{
+	/* svm_type */
+	public static final int C_SVC = 0;
+	public static final int NU_SVC = 1;
+	public static final int ONE_CLASS = 2;
+	public static final int EPSILON_SVR = 3;
+	public static final int NU_SVR = 4;
+
+	/* kernel_type */
+	public static final int LINEAR = 0;
+	public static final int POLY = 1;
+	public static final int RBF = 2;
+	public static final int SIGMOID = 3;
+	public static final int PRECOMPUTED = 4;
+
+	public int svm_type;
+	public int kernel_type;
+	public int degree;	// for poly
+	public double gamma;	// for poly/rbf/sigmoid
+	public double coef0;	// for poly/sigmoid
+
+	// these are for training only
+	public double cache_size; // in MB
+	public double eps;	// stopping criteria
+	public double C;	// for C_SVC, EPSILON_SVR and NU_SVR
+	public int nr_weight;		// for C_SVC
+	public int[] weight_label;	// for C_SVC
+	public double[] weight;		// for C_SVC
+	public double nu;	// for NU_SVC, ONE_CLASS, and NU_SVR
+	public double p;	// for EPSILON_SVR
+	public int shrinking;	// use the shrinking heuristics
+	public int probability; // do probability estimates
+
+	public Object clone() 
+	{
+		try 
+		{
+			return super.clone();
+		} catch (CloneNotSupportedException e) 
+		{
+			return null;
+		}
+	}
+
+}

data/ext/libsvm/java/libsvm/svm_print_interface.java

@@ -0,0 +1,5 @@
+package libsvm;
+public interface svm_print_interface
+{
+	public void print(String s);
+}

data/ext/libsvm/java/libsvm/svm_problem.java

@@ -0,0 +1,7 @@
+package libsvm;
+public class svm_problem implements java.io.Serializable
+{
+	public int l;
+	public double[] y;
+	public svm_node[][] x;
+}

data/ext/libsvm/java/svm_predict.java

@@ -0,0 +1,163 @@
+import libsvm.*;
+import java.io.*;
+import java.util.*;
+
+class svm_predict {
+	private static double atof(String s)
+	{
+		return Double.valueOf(s).doubleValue();
+	}
+
+	private static int atoi(String s)
+	{
+		return Integer.parseInt(s);
+	}
+
+	private static void predict(BufferedReader input, DataOutputStream output, svm_model model, int predict_probability) throws IOException
+	{
+		int correct = 0;
+		int total = 0;
+		double error = 0;
+		double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
+
+		int svm_type=svm.svm_get_svm_type(model);
+		int nr_class=svm.svm_get_nr_class(model);
+		double[] prob_estimates=null;
+
+		if(predict_probability == 1)
+		{
+			if(svm_type == svm_parameter.EPSILON_SVR ||
+			   svm_type == svm_parameter.NU_SVR)
+			{
+				System.out.print("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma="+svm.svm_get_svr_probability(model)+"\n");
+			}
+			else
+			{
+				int[] labels=new int[nr_class];
+				svm.svm_get_labels(model,labels);
+				prob_estimates = new double[nr_class];
+				output.writeBytes("labels");
+				for(int j=0;j<nr_class;j++)
+					output.writeBytes(" "+labels[j]);
+				output.writeBytes("\n");
+			}
+		}
+		while(true)
+		{
+			String line = input.readLine();
+			if(line == null) break;
+
+			StringTokenizer st = new StringTokenizer(line," \t\n\r\f:");
+
+			double target = atof(st.nextToken());
+			int m = st.countTokens()/2;
+			svm_node[] x = new svm_node[m];
+			for(int j=0;j<m;j++)
+			{
+				x[j] = new svm_node();
+				x[j].index = atoi(st.nextToken());
+				x[j].value = atof(st.nextToken());
+			}
+
+			double v;
+			if (predict_probability==1 && (svm_type==svm_parameter.C_SVC || svm_type==svm_parameter.NU_SVC))
+			{
+				v = svm.svm_predict_probability(model,x,prob_estimates);
+				output.writeBytes(v+" ");
+				for(int j=0;j<nr_class;j++)
+					output.writeBytes(prob_estimates[j]+" ");
+				output.writeBytes("\n");
+			}
+			else
+			{
+				v = svm.svm_predict(model,x);
+				output.writeBytes(v+"\n");
+			}
+
+			if(v == target)
+				++correct;
+			error += (v-target)*(v-target);
+			sumv += v;
+			sumy += target;
+			sumvv += v*v;
+			sumyy += target*target;
+			sumvy += v*target;
+			++total;
+		}
+		if(svm_type == svm_parameter.EPSILON_SVR ||
+		   svm_type == svm_parameter.NU_SVR)
+		{
+			System.out.print("Mean squared error = "+error/total+" (regression)\n");
+			System.out.print("Squared correlation coefficient = "+
+				 ((total*sumvy-sumv*sumy)*(total*sumvy-sumv*sumy))/
+				 ((total*sumvv-sumv*sumv)*(total*sumyy-sumy*sumy))+
+				 " (regression)\n");
+		}
+		else
+			System.out.print("Accuracy = "+(double)correct/total*100+
+				 "% ("+correct+"/"+total+") (classification)\n");
+	}
+
+	private static void exit_with_help()
+	{
+		System.err.print("usage: svm_predict [options] test_file model_file output_file\n"
+		+"options:\n"
+		+"-b probability_estimates: whether to predict probability estimates, 0 or 1 (default 0); one-class SVM not supported yet\n");
+		System.exit(1);
+	}
+
+	public static void main(String argv[]) throws IOException
+	{
+		int i, predict_probability=0;
+
+		// parse options
+		for(i=0;i<argv.length;i++)
+		{
+			if(argv[i].charAt(0) != '-') break;
+			++i;
+			switch(argv[i-1].charAt(1))
+			{
+				case 'b':
+					predict_probability = atoi(argv[i]);
+					break;
+				default:
+					System.err.print("Unknown option: " + argv[i-1] + "\n");
+					exit_with_help();
+			}
+		}
+		if(i>=argv.length-2)
+			exit_with_help();
+		try 
+		{
+			BufferedReader input = new BufferedReader(new FileReader(argv[i]));
+			DataOutputStream output = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(argv[i+2])));
+			svm_model model = svm.svm_load_model(argv[i+1]);
+			if(predict_probability == 1)
+			{
+				if(svm.svm_check_probability_model(model)==0)
+				{
+					System.err.print("Model does not support probabiliy estimates\n");
+					System.exit(1);
+				}
+			}
+			else
+			{
+				if(svm.svm_check_probability_model(model)!=0)
+				{
+					System.out.print("Model supports probability estimates, but disabled in prediction.\n");
+				}
+			}
+			predict(input,output,model,predict_probability);
+			input.close();
+			output.close();
+		} 
+		catch(FileNotFoundException e) 
+		{
+			exit_with_help();
+		}
+		catch(ArrayIndexOutOfBoundsException e) 
+		{
+			exit_with_help();
+		}
+	}
+}

data/ext/libsvm/java/svm_scale.java

@@ -0,0 +1,350 @@
+import libsvm.*;
+import java.io.*;
+import java.util.*;
+import java.text.DecimalFormat;
+
+class svm_scale
+{
+	private String line = null;
+	private double lower = -1.0;
+	private double upper = 1.0;
+	private double y_lower;
+	private double y_upper;
+	private boolean y_scaling = false;
+	private double[] feature_max;
+	private double[] feature_min;
+	private double y_max = -Double.MAX_VALUE;
+	private double y_min = Double.MAX_VALUE;
+	private int max_index;
+	private long num_nonzeros = 0;
+	private long new_num_nonzeros = 0;
+
+	private static void exit_with_help()
+	{
+		System.out.print(
+		 "Usage: svm-scale [options] data_filename\n"
+		+"options:\n"
+		+"-l lower : x scaling lower limit (default -1)\n"
+		+"-u upper : x scaling upper limit (default +1)\n"
+		+"-y y_lower y_upper : y scaling limits (default: no y scaling)\n"
+		+"-s save_filename : save scaling parameters to save_filename\n"
+		+"-r restore_filename : restore scaling parameters from restore_filename\n"
+		);
+		System.exit(1);
+	}
+
+	private BufferedReader rewind(BufferedReader fp, String filename) throws IOException
+	{
+		fp.close();
+		return new BufferedReader(new FileReader(filename));
+	}
+
+	private void output_target(double value)
+	{
+		if(y_scaling)
+		{
+			if(value == y_min)
+				value = y_lower;
+			else if(value == y_max)
+				value = y_upper;
+			else
+				value = y_lower + (y_upper-y_lower) *
+				(value-y_min) / (y_max-y_min);
+		}
+
+		System.out.print(value + " ");
+	}
+
+	private void output(int index, double value)
+	{
+		/* skip single-valued attribute */
+		if(feature_max[index] == feature_min[index])
+			return;
+
+		if(value == feature_min[index])
+			value = lower;
+		else if(value == feature_max[index])
+			value = upper;
+		else
+			value = lower + (upper-lower) * 
+				(value-feature_min[index])/
+				(feature_max[index]-feature_min[index]);
+
+		if(value != 0)
+		{
+			System.out.print(index + ":" + value + " ");
+			new_num_nonzeros++;
+		}
+	}
+
+	private String readline(BufferedReader fp) throws IOException
+	{
+		line = fp.readLine();
+		return line;
+	}
+
+	private void run(String []argv) throws IOException
+	{
+		int i,index;
+		BufferedReader fp = null, fp_restore = null;
+		String save_filename = null;
+		String restore_filename = null;
+		String data_filename = null;
+
+
+		for(i=0;i<argv.length;i++)
+		{
+			if (argv[i].charAt(0) != '-')	break;
+			++i;
+			switch(argv[i-1].charAt(1))
+			{
+				case 'l': lower = Double.parseDouble(argv[i]);	break;
+				case 'u': upper = Double.parseDouble(argv[i]);	break;
+				case 'y':
+					  y_lower = Double.parseDouble(argv[i]);
+					  ++i;
+					  y_upper = Double.parseDouble(argv[i]);
+					  y_scaling = true;
+					  break;
+				case 's': save_filename = argv[i];	break;
+				case 'r': restore_filename = argv[i];	break;
+				default:
+					  System.err.println("unknown option");
+					  exit_with_help();
+			}
+		}
+
+		if(!(upper > lower) || (y_scaling && !(y_upper > y_lower)))
+		{
+			System.err.println("inconsistent lower/upper specification");
+			System.exit(1);
+		}
+		if(restore_filename != null && save_filename != null)
+		{
+			System.err.println("cannot use -r and -s simultaneously");
+			System.exit(1);
+		}
+
+		if(argv.length != i+1)
+			exit_with_help();
+
+		data_filename = argv[i];
+		try {
+			fp = new BufferedReader(new FileReader(data_filename));
+		} catch (Exception e) {
+			System.err.println("can't open file " + data_filename);
+			System.exit(1);
+		}
+
+		/* assumption: min index of attributes is 1 */
+		/* pass 1: find out max index of attributes */
+		max_index = 0;
+
+		if(restore_filename != null)
+		{
+			int idx, c;
+
+			try {
+				fp_restore = new BufferedReader(new FileReader(restore_filename));
+			}
+			catch (Exception e) {
+				System.err.println("can't open file " + restore_filename);
+				System.exit(1);
+			}
+			if((c = fp_restore.read()) == 'y')
+			{
+				fp_restore.readLine();
+				fp_restore.readLine();		
+				fp_restore.readLine();		
+			}
+			fp_restore.readLine();
+			fp_restore.readLine();
+
+			String restore_line = null;
+			while((restore_line = fp_restore.readLine())!=null)
+			{
+				StringTokenizer st2 = new StringTokenizer(restore_line);
+				idx = Integer.parseInt(st2.nextToken());
+				max_index = Math.max(max_index, idx);
+			}
+			fp_restore = rewind(fp_restore, restore_filename);
+		}
+
+		while (readline(fp) != null)
+		{
+			StringTokenizer st = new StringTokenizer(line," \t\n\r\f:");
+			st.nextToken();
+			while(st.hasMoreTokens())
+			{
+				index = Integer.parseInt(st.nextToken());
+				max_index = Math.max(max_index, index);
+				st.nextToken();
+				num_nonzeros++;
+			}
+		}
+
+		try {
+			feature_max = new double[(max_index+1)];
+			feature_min = new double[(max_index+1)];
+		} catch(OutOfMemoryError e) {
+			System.err.println("can't allocate enough memory");
+			System.exit(1);
+		}
+
+		for(i=0;i<=max_index;i++)
+		{
+			feature_max[i] = -Double.MAX_VALUE;
+			feature_min[i] = Double.MAX_VALUE;
+		}
+
+		fp = rewind(fp, data_filename);
+
+		/* pass 2: find out min/max value */
+		while(readline(fp) != null)
+		{
+			int next_index = 1;
+			double target;
+			double value;
+
+			StringTokenizer st = new StringTokenizer(line," \t\n\r\f:");
+			target = Double.parseDouble(st.nextToken());
+			y_max = Math.max(y_max, target);
+			y_min = Math.min(y_min, target);
+
+			while (st.hasMoreTokens())
+			{
+				index = Integer.parseInt(st.nextToken());
+				value = Double.parseDouble(st.nextToken());
+
+				for (i = next_index; i<index; i++)
+				{
+					feature_max[i] = Math.max(feature_max[i], 0);
+					feature_min[i] = Math.min(feature_min[i], 0);
+				}
+
+				feature_max[index] = Math.max(feature_max[index], value);
+				feature_min[index] = Math.min(feature_min[index], value);
+				next_index = index + 1;
+			}
+
+			for(i=next_index;i<=max_index;i++)
+			{
+				feature_max[i] = Math.max(feature_max[i], 0);
+				feature_min[i] = Math.min(feature_min[i], 0);
+			}
+		}
+
+		fp = rewind(fp, data_filename);
+
+		/* pass 2.5: save/restore feature_min/feature_max */
+		if(restore_filename != null)
+		{
+			// fp_restore rewinded in finding max_index 
+			int idx, c;
+			double fmin, fmax;
+
+			fp_restore.mark(2);				// for reset
+			if((c = fp_restore.read()) == 'y')
+			{
+				fp_restore.readLine();		// pass the '\n' after 'y'
+				StringTokenizer st = new StringTokenizer(fp_restore.readLine());
+				y_lower = Double.parseDouble(st.nextToken());
+				y_upper = Double.parseDouble(st.nextToken());
+				st = new StringTokenizer(fp_restore.readLine());
+				y_min = Double.parseDouble(st.nextToken());
+				y_max = Double.parseDouble(st.nextToken());
+				y_scaling = true;
+			}
+			else
+				fp_restore.reset();
+
+			if(fp_restore.read() == 'x') {
+				fp_restore.readLine();		// pass the '\n' after 'x'
+				StringTokenizer st = new StringTokenizer(fp_restore.readLine());
+				lower = Double.parseDouble(st.nextToken());
+				upper = Double.parseDouble(st.nextToken());
+				String restore_line = null;
+				while((restore_line = fp_restore.readLine())!=null)
+				{
+					StringTokenizer st2 = new StringTokenizer(restore_line);
+					idx = Integer.parseInt(st2.nextToken());
+					fmin = Double.parseDouble(st2.nextToken());
+					fmax = Double.parseDouble(st2.nextToken());
+					if (idx <= max_index)
+					{
+						feature_min[idx] = fmin;
+						feature_max[idx] = fmax;
+					}
+				}
+			}
+			fp_restore.close();
+		}
+
+		if(save_filename != null)
+		{
+			Formatter formatter = new Formatter(new StringBuilder());
+			BufferedWriter fp_save = null;
+
+			try {
+				fp_save = new BufferedWriter(new FileWriter(save_filename));
+			} catch(IOException e) {
+				System.err.println("can't open file " + save_filename);
+				System.exit(1);
+			}
+
+			if(y_scaling)
+			{
+				formatter.format("y\n");
+				formatter.format("%.16g %.16g\n", y_lower, y_upper);
+				formatter.format("%.16g %.16g\n", y_min, y_max);
+			}
+			formatter.format("x\n");
+			formatter.format("%.16g %.16g\n", lower, upper);
+			for(i=1;i<=max_index;i++)
+			{
+				if(feature_min[i] != feature_max[i]) 
+					formatter.format("%d %.16g %.16g\n", i, feature_min[i], feature_max[i]);
+			}
+			fp_save.write(formatter.toString());
+			fp_save.close();
+		}
+
+		/* pass 3: scale */
+		while(readline(fp) != null)
+		{
+			int next_index = 1;
+			double target;
+			double value;
+
+			StringTokenizer st = new StringTokenizer(line," \t\n\r\f:");
+			target = Double.parseDouble(st.nextToken());
+			output_target(target);
+			while(st.hasMoreElements())
+			{
+				index = Integer.parseInt(st.nextToken());
+				value = Double.parseDouble(st.nextToken());
+				for (i = next_index; i<index; i++)
+					output(i, 0);
+				output(index, value);
+				next_index = index + 1;
+			}
+
+			for(i=next_index;i<= max_index;i++)
+				output(i, 0);
+			System.out.print("\n");
+		}
+		if (new_num_nonzeros > num_nonzeros)
+			System.err.print(
+			 "Warning: original #nonzeros " + num_nonzeros+"\n"
+			+"         new      #nonzeros " + new_num_nonzeros+"\n"
+			+"Use -l 0 if many original feature values are zeros\n");
+
+		fp.close();
+	}
+
+	public static void main(String argv[]) throws IOException
+	{
+		svm_scale s = new svm_scale();
+		s.run(argv);
+	}
+}