Changeset 2415 for trunk/sources/LibSVM/GaussianTransform.cs

Timestamp:

10/07/09 11:58:21 (15 years ago)

Author:

gkronber

Message:

Updated LibSVM project to latest version. #774

File:

• trunk/sources/LibSVM/GaussianTransform.cs (modified) (7 diffs)

trunk/sources/LibSVM/GaussianTransform.cs

@@ -21 +21 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Globalization;
+using System.Threading;
 
 namespace SVM
 {
-    /// <remarks>
+    /// <summary>
     /// A transform which learns the mean and variance of a sample set and uses these to transform new data
     /// so that it has zero mean and unit variance.
-    /// </remarks>
+    /// </summary>
     public class GaussianTransform : IRangeTransform
     {
-        private List<Node[]> _samples;
-        private int _maxIndex;
-
         private double[] _means;
         private double[] _stddevs;
 
         /// <summary>
+        /// Determines the Gaussian transform for the provided problem.
+        /// </summary>
+        /// <param name="prob">The Problem to analyze</param>
+        /// <returns>The Gaussian transform for the problem</returns>
+        public static GaussianTransform Compute(Problem prob)
+        {
+            int[] counts = new int[prob.MaxIndex];
+            double[] means = new double[prob.MaxIndex];
+            foreach (Node[] sample in prob.X)
+            {
+                for (int i = 0; i < sample.Length; i++)
+                {
+                    means[sample[i].Index-1] += sample[i].Value;
+                    counts[sample[i].Index-1]++;
+                }
+            }
+            for (int i = 0; i < prob.MaxIndex; i++)
+            {
+                if (counts[i] == 0)
+                    counts[i] = 2;
+                means[i] /= counts[i];
+            }
+
+            double[] stddevs = new double[prob.MaxIndex];
+            foreach (Node[] sample in prob.X)
+            {
+                for (int i = 0; i < sample.Length; i++)
+                {
+                    double diff = sample[i].Value - means[sample[i].Index - 1];
+                    stddevs[sample[i].Index - 1] += diff * diff;
+                }
+            }
+            for (int i = 0; i < prob.MaxIndex; i++)
+            {
+                if (stddevs[i] == 0)
+                    continue;
+                stddevs[i] /= (counts[i] - 1);
+                stddevs[i] = Math.Sqrt(stddevs[i]);
+            }
+
+            return new GaussianTransform(means, stddevs);
+        }
+
+        /// <summary>
         /// Constructor.
         /// </summary>
-        /// <param name="maxIndex">The maximum index of the vectors to be transformed</param>
-        public GaussianTransform(int maxIndex)
-        {
-            _samples = new List<Node[]>();
-        }
-        private GaussianTransform(double[] means, double[] stddevs, int maxIndex)
+        /// <param name="means">Means in each dimension</param>
+        /// <param name="stddevs">Standard deviation in each dimension</param>
+        public GaussianTransform(double[] means, double[] stddevs)
         {
             _means = means;
             _stddevs = stddevs;
-            _maxIndex = maxIndex;
-        }
-
-        /// <summary>
-        /// Adds a sample to the data.  No computation is performed.  The maximum index of the
-        /// sample must be less than MaxIndex.
-        /// </summary>
-        /// <param name="sample">The sample to add</param>
-        public void Add(Node[] sample)
-        {
-            _samples.Add(sample);
-        }
-
-        /// <summary>
-        /// Computes the statistics for the samples which have been obtained so far.
-        /// </summary>
-        public void ComputeStatistics()
-        {
-            int[] counts = new int[_maxIndex];
-            _means = new double[_maxIndex];
-            foreach(Node[] sample in _samples)
-            {
-                for (int i = 0; i < sample.Length; i++)
-                {
-                    _means[sample[i].Index] += sample[i].Value;
-                    counts[sample[i].Index]++;
-                }
-            }
-            for (int i = 0; i < _maxIndex; i++)
-            {
-                if (counts[i] == 0)
-                    counts[i] = 2;
-                _means[i] /= counts[i];
-            }
-
-            _stddevs = new double[_maxIndex];
-            foreach(Node[] sample in _samples)
-            {
-                for (int i = 0; i < sample.Length; i++)
-                {
-                    double diff = sample[i].Value - _means[sample[i].Index];
-                    _stddevs[sample[i].Index] += diff * diff;
-                }
-            }
-            for (int i = 0; i < _maxIndex; i++)
-            {
-                if (_stddevs[i] == 0)
-                    continue;
-                _stddevs[i] /= (counts[i]-1);
-                _stddevs[i] = Math.Sqrt(_stddevs[i]);
-            }
         }
 
@@ -109 +98 @@
         public static void Write(Stream stream, GaussianTransform transform)
         {
+            TemporaryCulture.Start();
+
             StreamWriter output = new StreamWriter(stream);
-            output.WriteLine(transform._maxIndex);
-            for (int i = 0; i < transform._maxIndex; i++)
+            output.WriteLine(transform._means.Length);
+            for (int i = 0; i < transform._means.Length; i++)
                 output.WriteLine("{0} {1}", transform._means[i], transform._stddevs[i]);
             output.Flush();
+
+            TemporaryCulture.Stop();
         }
 
@@ -123 +116 @@
         public static GaussianTransform Read(Stream stream)
         {
+            TemporaryCulture.Start();
+
             StreamReader input = new StreamReader(stream);
-            int length = int.Parse(input.ReadLine());
+            int length = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
             double[] means = new double[length];
             double[] stddevs = new double[length];
@@ -130 +125 @@
             {
                 string[] parts = input.ReadLine().Split();
-                means[i] = double.Parse(parts[0]);
-                stddevs[i] = double.Parse(parts[1]);
-            }
-            return new GaussianTransform(means, stddevs, length);
+                means[i] = double.Parse(parts[0], CultureInfo.InvariantCulture);
+                stddevs[i] = double.Parse(parts[1], CultureInfo.InvariantCulture);
+            }
+
+            TemporaryCulture.Stop();
+
+            return new GaussianTransform(means, stddevs);
         }
 
@@ -177 +175 @@
         /// <summary>
         /// Transform the input value using the transform stored for the provided index.
-        /// <see cref="ComputeStatistics"/> must be called first, or the transform must
-        /// have been read from the disk.
         /// </summary>
         /// <param name="input">Input value</param>
@@ -185 +181 @@
         public double Transform(double input, int index)
         {
+            index--;
             if (_stddevs[index] == 0)
                 return 0;
@@ -192 +189 @@
         }
         /// <summary>
-        /// Transforms the input array.  <see cref="ComputeStatistics"/> must be called 
-        /// first, or the transform must have been read from the disk.
+        /// Transforms the input array.
         /// </summary>
         /// <param name="input">The array to transform</param>