samer@0: /*
samer@0:  *	Copyright (c) 2002, Samer Abdallah, King's College London.
samer@0:  *	All rights reserved.
samer@0:  *
samer@0:  *	This software is provided AS iS and WITHOUT ANY WARRANTY;
samer@0:  *	without even the implied warranty of MERCHANTABILITY or
samer@0:  *	FITNESS FOR A PARTICULAR PURPOSE.
samer@0:  */
samer@0: 
samer@0: package samer.models;
samer@0: 
samer@0: import samer.core.*;
samer@0: import samer.core.types.*;
samer@0: import samer.maths.*;
samer@0: import samer.maths.opt.*;
samer@0: import samer.tools.*;
samer@0: 
samer@0: /**
samer@0: 	Automatic gain control for a given input vector.
samer@0: 	Ouput appears in out. Also generates a trace of
samer@0: 	'loudness' of input signal.
samer@0:   */
samer@0: 
samer@0: public class Scaler extends NullTask implements Model
samer@0: {
samer@0: 	private Model 		M;
samer@0: 	private int			n;
samer@0: 	private Vec			x;
samer@0: 	private VVector	s;
samer@0: 	private VDouble	multiplier;
samer@0: 	private VDouble	offset;
samer@0: 	private double	logK;
samer@0: 
samer@0: 	double []		_x, _s, _g, phi;
samer@0: 
samer@0: 	public Scaler( Vec input, Model M) { this(input); setOutputModel(M); M.setInput(s); }
samer@0: 	public Scaler( Vec input) { this(input.size()); setInput(input); }
samer@0: 	public Scaler( int N)
samer@0: 	{
samer@0: 		n = N;
samer@0: 
samer@0: 		x = null;
samer@0: 		s = new VVector("output",n);
samer@0: 		multiplier = new VDouble("scale",1.0,VDouble.SIGNAL);
samer@0: 		offset = new VDouble("offset",0.0,VDouble.SIGNAL);
samer@0: 		
samer@0: 		_s = s.array();
samer@0: 		_g = new double[n];
samer@0: 		phi = null;
samer@0: 		reset();
samer@0: 		logK=Math.log(multiplier.value);
samer@0: 	}
samer@0: 
samer@0: 	public int getSize() { return n; }
samer@0: 	public VVector output() { return s; }
samer@0: 	public VDouble getScale() { return multiplier; }
samer@0: 	public VDouble getOffset() { return offset; }
samer@0: 	public Model getOutputModel() { return M;	}
samer@0: 	public void setOutputModel(Model m) { M=m;	}
samer@0: 	public void setInput(Vec in) { x=in; _x=x.array(); }
samer@0: 	public void reset() {
samer@0: 		// multiplier.load(Shell.env());
samer@0: 		// offset.load(Shell.env());
samer@0: 	}
samer@0: 
samer@0: 	public String toString() { return "Scaler:"+x; } // +"->"+s; }
samer@0: 	public void dispose()
samer@0: 	{
samer@0: 		offset.dispose();
samer@0: 		multiplier.dispose();
samer@0: 		s.dispose();
samer@0: 		super.dispose();
samer@0: 	}
samer@0: 
samer@0: 	public void infer() {
samer@0: 		double a=offset.value, k=1/multiplier.value;
samer@0: 		for (int i=0; i<n; i++) _s[i] = k*(_x[i]-a);
samer@0: 		s.changed();
samer@0: 	}
samer@0: 
samer@0: 	public void compute() {
samer@0: 		Mathx.mul(_g,M.getGradient(),1/multiplier.value);
samer@0: 	}
samer@0: 
samer@0: 	public double	getEnergy() { return M.getEnergy() + n*logK; }
samer@0: 	public double [] getGradient() { return _g; }
samer@0: 
samer@0: 	public Functionx functionx() {
samer@0: 		return new Functionx() {
samer@0: 			Functionx fM=M.functionx();
samer@0: 			double [] s=new double[n];
samer@0: 
samer@0: 			public void dispose() { fM.dispose(); }
samer@0: 			public void evaluate(Datum P) { P.f=evaluate(P.x,P.g); }
samer@0: 			public double evaluate(double [] x, double [] g) {
samer@0: 				double a=offset.value, k=1/multiplier.value;
samer@0: 				for (int i=0; i<n; i++) s[i] = k*(x[i]-a);
samer@0: 				double E=fM.evaluate(s,g);
samer@0: 				Mathx.mul(g,k);
samer@0: 				return E+n*logK;
samer@0: 			}
samer@0: 		};
samer@0: 	}
samer@0: 
samer@0: 	public void starting() { logK=Math.log(multiplier.value); }
samer@0: 	public void stopping() {}
samer@0: 	public void run() { infer(); }
samer@0: 
samer@0: 	public Trainer getTrainer() { return new Trainer(); }
samer@0: 	public OffsetTrainer getOffsetTrainer()	{ return new OffsetTrainer(); }
samer@0: 	public ScaleTrainer getScaleTrainer()	{ return new ScaleTrainer(); }
samer@0: 
samer@0: 	public class Trainer extends AnonymousTask implements Model.Trainer
samer@0: 	{
samer@0: 		VDouble		rate1=new VDouble("scaleRate",0.001);
samer@0: 		VDouble		rate2=new VDouble("offsetRate",0.000001);
samer@0: 		double		G,H,count;
samer@0: 		double []	_s;
samer@0: 		int				n;
samer@0: 
samer@0: 
samer@0: 		public Trainer() { _s = s.array(); n=Scaler.this.n; }
samer@0: 
samer@0: 		public void reset() { count=0; G=0; H=0; }
samer@0: 		public String toString() { return "Trainer:"+Scaler.this; }
samer@0: 
samer@0: 		public VDouble getScaleRate() { return rate1; }
samer@0: 		public VDouble getOffsetRate() { return rate2; }
samer@0: 
samer@0: 		public void accumulate() { accumulate(1); }
samer@0: 		public void accumulate(double w) {
samer@0: //			if (M.getEnergy() > 8000) return;
samer@0: 			double [] phi=M.getGradient();
samer@0: 			double	g=0;
samer@0: 			for (int i=0; i<n; i++) g += phi[i]*_s[i] - 1;
samer@0: 			G += w*g;
samer@0: 			H += w*Mathx.sum(phi);
samer@0: 			count+=w;
samer@0: 		}
samer@0: 
samer@0: 		public void flush() {
samer@0: 			if (count==0) return; // nothing to do
samer@0: 
samer@0: 			double k=multiplier.value;
samer@0: 			double mu=offset.value;
samer@0: 
samer@0: 			mu += (rate2.value/count)*k*H/n;
samer@0: 			G *= rate1.value/(n*count);
samer@0: 			k *= Math.exp(G);
samer@0: 			multiplier.set(k);
samer@0: 			offset.set(mu);
samer@0: 			logK+=G;
samer@0: 			reset();
samer@0: 		}
samer@0: 
samer@0: 		public void oneshot() {
samer@0: 			double [] phi=M.getGradient();
samer@0: 			G=0; H = Mathx.sum(phi);
samer@0: 			for (int i=0; i<n; i++) G += phi[i]*_s[i] - 1;
samer@0: 
samer@0: 			double k=multiplier.value;
samer@0: 			double mu=offset.value;
samer@0: 
samer@0: 			mu += rate2.value*k*H/n;
samer@0: 			G *= rate1.value/n;
samer@0: 			k *= Math.exp(G);
samer@0: 			multiplier.set(k);
samer@0: 			offset.set(mu);
samer@0: 			logK+=G;
samer@0: 		}
samer@0: 
samer@0: 
samer@0: 		public void dispose() { rate1.dispose(); rate2.dispose(); }
samer@0: 		public void starting() { reset(); logK=Math.log(multiplier.value); }
samer@0: 		public void run() { oneshot(); }
samer@0: 	}
samer@0: 
samer@0: 	public class ScaleTrainer extends AnonymousTask implements Model.Trainer
samer@0: 	{
samer@0: 		VDouble	rate1=new VDouble("scaleRate",0.001);
samer@0: 		double		G,count;
samer@0: 		double []	_s;
samer@0: 		int				n;
samer@0: 
samer@0: 
samer@0: 		public ScaleTrainer() { _s = s.array(); n=Scaler.this.n; }
samer@0: 		public String toString() { return "ScaleTrainer:"+Scaler.this; }
samer@0: 
samer@0: 		public void reset() { count=0; G=0; }
samer@0: 
samer@0: 		public void accumulate() { accumulate(1); }
samer@0: 		public void accumulate(double w) {
samer@0: 			double [] phi=M.getGradient();
samer@0: 			double	g=0;
samer@0: 			for (int i=0; i<n; i++) g += phi[i]*_s[i] - 1;
samer@0: 			G += w*g;
samer@0: 			count+=w;
samer@0: 		}
samer@0: 
samer@0: 		public void flush() {
samer@0: 			if (count==0) return; // nothing to do
samer@0: 
samer@0: 			double k=multiplier.value;
samer@0: 
samer@0: 			G *= rate1.value/(n*count);
samer@0: 			k *= Math.exp(G);
samer@0: 			multiplier.set(k);
samer@0: 			logK+=G;
samer@0: 			reset();
samer@0: 		}
samer@0: 
samer@0: 		public void oneshot() {
samer@0: 			double [] phi=M.getGradient();
samer@0: 			G=0;
samer@0: 			for (int i=0; i<n; i++) G += phi[i]*_s[i] - 1;
samer@0: 
samer@0: 			double k=multiplier.value;
samer@0: 
samer@0: 			G *= rate1.value/n;
samer@0: 			k *= Math.exp(G);
samer@0: 			multiplier.set(k);
samer@0: 			logK+=G;
samer@0: 		}
samer@0: 
samer@0: 
samer@0: 		public void dispose() { rate1.dispose(); }
samer@0: 		public void starting() { reset(); logK=Math.log(multiplier.value); }
samer@0: 		public void run() { oneshot(); }
samer@0: 	}
samer@0: 
samer@0: 	/** This trains only the offset, not the scale */
samer@0: 	public class OffsetTrainer extends AnonymousTask implements Model.Trainer
samer@0: 	{
samer@0: 		VDouble		rate2=new VDouble("offsetRate",0.000001);
samer@0: 		double		H, count;
samer@0: 		int				n;
samer@0: 
samer@0: 		public OffsetTrainer() { n=Scaler.this.n; }
samer@0: 		public String toString() { return "OffsetTrainer:"+Scaler.this; }
samer@0: 
samer@0: 		public void reset() { count=0; H=0; }
samer@0: 
samer@0: 		public void accumulate() { accumulate(1); }
samer@0: 		public void accumulate(double w) {
samer@0: 			double [] phi=M.getGradient();
samer@0: 			H += w*Mathx.sum(phi);
samer@0: 			count+=w;
samer@0: 		}
samer@0: 
samer@0: 		public void flush() {
samer@0: 			if (count==0) return; // nothing to do
samer@0: 			offset.value += (rate2.value/count)*multiplier.value*H/n;
samer@0: 			offset.changed();
samer@0: 			reset();
samer@0: 		}
samer@0: 
samer@0: 		public void oneshot() {
samer@0: 			double [] phi=M.getGradient();
samer@0: 			H = Mathx.sum(phi);
samer@0: 			offset.value += rate2.value*multiplier.value*H/n;
samer@0: 			offset.changed();
samer@0: 		}
samer@0: 
samer@0: 		public void dispose() { rate2.dispose(); }
samer@0: 		public void starting() { reset(); }
samer@0: 		public void run() { oneshot(); }
samer@0: 	}
samer@0: 	// could have alternative trainers if prior is Gaussian or Laplacian,
samer@0: 	// in which case, parameters can be estimated in closed form
samer@0: }
samer@0: