Update and augment help for FluidNormalize, FluidStandardize and fix classes

release-packaging/Classes/FluidNormalize.sc

@@ -1,8 +1,8 @@
 FluidNormalize : FluidManipulationClient {
 
-  *new {|server|
+  *new {|server, min = 0, max = 1|
 		var uid = UniqueID.next;
-		^super.new(server,uid)!?{|inst|inst.init(uid);inst}
+		^super.new(server,uid,min,max)!?{|inst|inst.init(uid);inst}
 	}
 
 	init {|uid|
@@ -10,18 +10,23 @@ FluidNormalize : FluidManipulationClient {
 	}
 
     fit{|dataset, action|
-        this.prSendMsg(\fit,[dataset.asString],action);
+        this.prSendMsg(\fit,[dataset.asSymbol],action);
     }
 
-    normalize{|sourceDataset, destDataset, action|
+	fitTransform{|dataset, action|
-        this.prSendMsg(\normalize,[sourceDataset.asString, destDataset.asString],action);
+        this.prSendMsg(\fit,[dataset.asSymbol],action);
     }
 
-    normalizePoint{|sourceBuffer, destBuffer, action|
+    transform{|sourceDataset, destDataset, action|
-        this.prSendMsg(\normalizePoint,[sourceBuffer.asUGenInput, destBuffer.asUGenInput],action);
+        this.prSendMsg(\transform,[sourceDataset.asSymbol, destDataset.asSymbol],action);
+    }
+
+    transformPoint{|sourceBuffer, destBuffer, action|
+        this.prSendMsg(\transformPoint,[sourceBuffer.asUGenInput, destBuffer.asUGenInput],action);
     }
 
     cols {|action|
+		action ?? {action = postit};
         this.prSendMsg(\cols,[],action,[numbers(FluidMessageResponse,_,1,_)]);
     }
 

release-packaging/Classes/FluidStandardize.sc

@@ -10,18 +10,23 @@ FluidStandardize : FluidManipulationClient {
 	}
 
     fit{|dataset, action|
-        this.prSendMsg(\fit,[dataset.asString],action);
+        this.prSendMsg(\fit,[dataset.asSymbol],action);
     }
 
-    standardize{|sourceDataset, destDataset, action|
+    transform{|sourceDataset, destDataset, action|
-        this.prSendMsg(\standardize,[sourceDataset.asString, destDataset.asString],action);
+        this.prSendMsg(\transform,[sourceDataset.asSymbol, destDataset.asSymbol],action);
     }
 
-    standardizePoint{|sourceBuffer, destBuffer, action|
+	fitTransform{|dataset, action|
-        this.prSendMsg(\standardizePoint,[sourceBuffer.asUGenInput, destBuffer.asUGenInput],action);
+        this.prSendMsg(\fitTransform,[dataset.asSymbol],action);
+    }
+
+    transformPoint{|sourceBuffer, destBuffer, action|
+        this.prSendMsg(\transformPoint,[sourceBuffer.asUGenInput, destBuffer.asUGenInput],action);
     }
 
     cols {|action|
+		action ?? {action = postit};
         this.prSendMsg(\cols,[],action,[numbers(FluidMessageResponse,_,1,_)]);
     }
 

release-packaging/HelpSource/Classes/FluidNormalize.schelp

@@ -14,81 +14,136 @@ private:: kr
 
 METHOD:: new
 Create a new instance
-
 ARGUMENT:: server
 The link::Classes/Server:: on which to run
-
 ARGUMENT:: min
 Minimum output value, default 0
-
 ARGUMENT:: max
 Maximum output value, default 1
 
-returns:: new instance
-
 
 INSTANCEMETHODS::
 
 METHOD:: fit
 Normalize a link::Classes/FluidDataSet:: strong::in-place::
-
 ARGUMENT:: dataset
 The link::Classes/FluidDataSet:: to normalize
+ARGUMENT:: action
+A function to run when processing is complete
 
+METHOD:: fitTransform
+Normalize a link::Classes/FluidDataSet:: strong::in-place::
+ARGUMENT:: dataset
+The link::Classes/FluidDataSet:: to normalize
 ARGUMENT:: action
 A function to run when processing is complete
 
-METHOD:: normalize
+METHOD:: transform
 Normalize a link::Classes/FluidDataSet:: non-destructively into another link::Classes/FluidDataSet::
-
 ARGUMENT:: sourceDataset
 The link::Classes/FluidDataSet:: to normalize
-
 ARGUMENT:: destDataset
 The link::Classes/FluidDataSet:: to populate with normalized data
-
 ARGUMENT:: action
 A function to run when processing is complete
 
-METHOD:: normalizePoint
+METHOD:: transformPoint
 Normalize a new data point, using the learned extrema from a previous link::Classes/FluidNormalize#fit::ting
-
 ARGUMENT:: sourceBuffer
 A link::Classes/Buffer:: with the new data point
-
 ARGUMENT:: destBuffer
 A link::Classes/Buffer:: to contain the normalized value
-
 ARGUMENT:: action
 A function to run when processing is complete
 
+METHOD:: cols
+Retreive the dimensionality of the data set we have fitted on
+ARGUMENT:: action
+A function to run when the server responds, taking the dimensions as its argument
+
 METHOD:: read
 Load internal state (dimensionality, mins, maxes) from a JSON file
-
 ARGUMENT:: filename
 Absolute path to the JSON file
-
 ARGUMENT:: action
 A function to run when file is loaded
 
 METHOD:: write
 Store the internal state of object on disk as a JSON file. Will not overwrite existing files
-
 ARGUMENT:: filename
 Absolute path of file to write
-
 ARGUMENT:: action
 A function to run when file is written
 
-METHOD:: cols
-Retreive the dimensionality of the data set we have fitted on
-
-ARGUMENT:: action
-A function to run when the server responds, taking the dimensions as its argument
-
 
 EXAMPLES::
-
 code::
-(some example code)
+s.boot;
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers and a FluidNormalize
+(
+~audiofile = File.realpath(FluidBufPitch.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav";
+~raw = FluidDataSet(s,\norm_help_raw);
+~norm = FluidDataSet(s,\norm_help_normd);
+~audio = Buffer.read(s,~audiofile);
+~pitch_feature = Buffer.new(s);
+~stats = Buffer.new(s);
+~datapoint = Buffer.alloc(s,2);
+~normalizer = FluidNormalize(s);
+)
+
+// Do a pitch analysis on the audio, which gives us pitch and pitch confidence (so a 2D datum)
+// Divide the time series in to 10, and take the mean of each segment and add this as a point to
+// the 'raw' FluidDataSet
+(
+~raw.clear;
+~norm.clear;
+FluidBufPitch.process(s,~audio,features:~pitch_feature,action:{
+	"Pitch analysis.complete. Doing stats".postln;
+	fork{
+		var chunkLen = (~pitch_feature.numFrames / 10).asInteger;
+		10.do{ |i|
+			s.sync;	FluidBufStats.process(s,~pitch_feature,startFrame:i*chunkLen,numFrames:chunkLen,stats:~stats, action:{
+			~stats.loadToFloatArray(action:{ |statsdata|
+					[statsdata[0],statsdata[1]].postln;
+					~datapoint.setn(0,[statsdata[0],statsdata[1]]);
+					s.sync;
+					("Adding point" ++ i).postln;
+					~raw.addPoint(i,~datapoint);
+				})
+			});
+			if(i == 9) {"Analysis done, dataset ready".postln}
+		}
+	}
+});
+)
+
+//Fit the FluidNormalizer to the raw data, and then apply the scaling out of place into
+//our second FluidDataSet, so we can compare.
+//Download the dataset contents into arrays for plotting
+(
+~normalizer.fit(~raw);
+~normalizer.transform(~raw,~norm);
+~rawarray = Array.new(10);
+~normedarray= Array.new(10);
+fork{
+	10.do{|i|
+		~raw.getPoint(i,~datapoint,{
+			~datapoint.loadToFloatArray(action:{|a| ~rawarray.add(Array.newFrom(a))})
+		});
+		s.sync;
+		~norm.getPoint(i,~datapoint,{
+
+			~datapoint.loadToFloatArray(action:{|a| ~normedarray.add(Array.newFrom(a))})
+		});
+		s.sync;
+		if(i==9){"Data downloaded".postln};
+	}
+}
+)
+//Plot side by side. Before normalization the two dimensions have radically different scales
+//which can be unhelpful in many cases
+(
+~rawarray.flatten(1).unlace.plot("Unnormalized",Rect(0,0,400,400),minval:0,maxval:[5000,1]).plotMode=\bars;
+~plot2 = ~normedarray.flatten(1).unlace.plot("Normalized",Rect(410,0,400,400)).plotMode=\bars;
+)
 ::

release-packaging/HelpSource/Classes/FluidStandardize.schelp

@@ -1,7 +1,7 @@
 TITLE:: FluidStandardize
 summary:: Standardize a FluidDataSet
 categories:: FluidManipulation
-related:: Classes/FluidDataSet, Classes/FluidNormalize
+related:: Classes/FluidDataSet, Classes/FluidStandardize
 
 DESCRIPTION::
 Standardize a link::Classes/FluidDataSet::, i.e. rescale using its mean(s) and standard deviation(s) in each dimension.
@@ -10,68 +10,132 @@ See http://www.faqs.org/faqs/ai-faq/neural-nets/part2/section-16.html
 
 CLASSMETHODS::
 
+METHOD:: new
+Create a new instance
+ARGUMENT:: server
+The server for this model
 
 INSTANCEMETHODS::
 
 METHOD:: fit
-Standardize a link::Classes/FluidDataSet:: strong::in-place::
+Fit model to a dataset without applying scaling
-
 ARGUMENT:: dataset
 The link::Classes/FluidDataSet:: to standardize
-
 ARGUMENT:: action
 A function to run when processing is complete
 
-METHOD:: standardize
+METHOD:: transform
 Standrdize a link::Classes/FluidDataSet:: non-destructively into another link::Classes/FluidDataSet::
-
 ARGUMENT:: sourceDataset
 The link::Classes/FluidDataSet:: to standardize
-
 ARGUMENT:: destDataset
 The link::Classes/FluidDataSet:: to populate with standardized data
+ARGUMENT:: action
+A function to run when processing is complete
 
+METHOD:: fitTransform
+Standrdize a link::Classes/FluidDataSet:: fit and scale a link::Classes/FluidDataSet:: in-place
+ARGUMENT:: sourceDataset
+The link::Classes/FluidDataSet:: to standardize
 ARGUMENT:: action
 A function to run when processing is complete
 
-METHOD:: standardizePoint
+METHOD:: transformPoint
 Standardize a new data point, using the learned statistics from a previous link::Classes/FluidStandardize#fit::ting
-
 ARGUMENT:: sourceBuffer
 A link::Classes/Buffer:: with the new data point
-
 ARGUMENT:: destBuffer
 A link::Classes/Buffer:: to contain the standardize value
-
 ARGUMENT:: action
 A function to run when processing is complete
 
+METHOD:: cols
+Retreive the dimensionality of the data set we have fitted on
+ARGUMENT:: action
+A function to run when the server responds, taking the dimensions as its argument. Will print to post window by default
+
 METHOD:: read
 Load internal state (dimensionality, means, deviations) from a JSON file
-
 ARGUMENT:: filename
 Absolute path to the JSON file
-
 ARGUMENT:: action
 A function to run when file is loaded
 
 METHOD:: write
-Store the internal state of object on disk as a JSON file. Will not overwrite existing files
+Store the internal state of object on disk as a JSON file.
-
 ARGUMENT:: filename
 Absolute path of file to write
-
 ARGUMENT:: action
 A function to run when file is written
 
-METHOD:: cols
-Retreive the dimensionality of the data set we have fitted on
-
-ARGUMENT:: action
-A function to run when the server responds, taking the dimensions as its argument
-
 EXAMPLES::
-
 code::
-(some example code)
+s.boot;
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers and a FluidStandardize
+(
+~audiofile = File.realpath(FluidBufPitch.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav";
+~raw = FluidDataSet(s,\stand_help_raw);
+~stand = FluidDataSet(s,\stand_help_standd);
+~audio = Buffer.read(s,~audiofile);
+~pitch_feature = Buffer.new(s);
+~stats = Buffer.new(s);
+~datapoint = Buffer.alloc(s,2);
+~standardizer = FluidStandardize(s);
+)
+
+// Do a pitch analysis on the audio, which gives us pitch and pitch confidence (so a 2D datum)
+// Divide the time series in to 10, and take the mean of each segment and add this as a point to
+// the 'raw' FluidDataSet
+(
+~raw.clear;
+~stand.clear;
+FluidBufPitch.process(s,~audio,features:~pitch_feature,action:{
+	"Pitch analysis.complete. Doing stats".postln;
+	fork{
+		var chunkLen = (~pitch_feature.numFrames / 10).asInteger;
+		10.do{ |i|
+			s.sync;	FluidBufStats.process(s,~pitch_feature,startFrame:i*chunkLen,numFrames:chunkLen,stats:~stats, action:{
+			~stats.loadToFloatArray(action:{ |statsdata|
+					[statsdata[0],statsdata[1]].postln;
+					~datapoint.setn(0,[statsdata[0],statsdata[1]]);
+					s.sync;
+					("Adding point" ++ i).postln;
+					~raw.addPoint(i,~datapoint);
+				})
+			});
+			if(i == 9) {"Analysis done, dataset ready".postln}
+		}
+	}
+});
+)
+
+//Fit the FluidStandardizer to the raw data, and then apply the scaling out of place into
+//our second FluidDataSet, so we can compare.
+//Download the dataset contents into arrays for plotting
+(
+~standardizer.fit(~raw);
+~standardizer.transform(~raw,~stand);
+~rawarray = Array.new(10);
+~stdarray= Array.new(10);
+fork{
+	10.do{|i|
+		~raw.getPoint(i,~datapoint,{
+			~datapoint.loadToFloatArray(action:{|a| ~rawarray.add(Array.newFrom(a))})
+		});
+		s.sync;
+		~stand.getPoint(i,~datapoint,{
+
+			~datapoint.loadToFloatArray(action:{|a| ~stdarray.add(Array.newFrom(a))})
+		});
+		s.sync;
+		if(i==9){"Data downloaded".postln};
+	}
+}
+)
+//Plot side by side. Before standardization the two dimensions have radically different scales
+//which can be unhelpful in many cases. Now they are zero-centered, and comparable
+(
+~rawarray.flatten(1).unlace.plot("Unstandardized",Rect(0,0,400,400),minval:0,maxval:[5000,1]).plotMode=\bars;
+~plot2 = ~stdarray.flatten(1).unlace.plot("Standardized",Rect(410,0,400,400)).plotMode=\bars;
+)
 ::