快速用低度下降法实现一个Logistic Regression 分类器

  1  public class LogisticRegression
  2     {
  3         private int _maxIteration = 1000;
  4         private double _stepSize = 0.000005;
  5         //private double _stepSize = 0.1;
  6         private double _lambda = 0.1;
  7         private double decay = 0.95;
  8 
  9         public int dim;
 10         public double[] theta;
 11 
 12         public LogisticRegression(int dim)
 13         {
 14             this.dim = dim;
 15         }
 16 
 17         public LogisticRegression(int dim, double stepSize)
 18             : this(dim)
 19         {
 20             this._stepSize = stepSize;
 21         }
 22 
 23         public void Train(Instance[] instances)
 24         {
 25             Initialize();
 26 
 27             int instCnt = instances.Length;
 28             double[] dev =new double[this.dim];
 29             for (int t = 0; t < this._maxIteration; t++)
 30             {
 31                 double cost = 0;
 32                 for (int i = 0; i < instCnt; i++)
 33                 {
 34                     double h_x = MathLib.Logistic(MathLib.VectorInnerProd(instances[i].featureValues, this.theta));
 35                     // calculate cost function
 36                     cost += instances[i].label * Math.Log(h_x) + (1 - instances[i].label) * Math.Log(1 - h_x);
 37                 }
 38                 cost *= -1.0 / instCnt; 
 39                 Console.WriteLine("{0},{1}", t, cost);
 40 
 41                
 42                 for (int i = 0; i < instCnt; i++)
 43                 {
 44                     ResetArray(dev);
 45                     double h_x = MathLib.Logistic(MathLib.VectorInnerProd(instances[i].featureValues, this.theta));
 46                     double error =   h_x- instances[i].label ;
 47                     for (int j = 0; j < this.dim; j++)
 48                     {
 49                         dev[j] += error*instances[i].featureValues[j] + 2*dev[j]*this._lambda;
 50                         this.theta[j] -= this._stepSize * dev[j] ;
 51                         //BoundaryLimiting(ref this.theta[j], 0, 1);
 52                     }
 53                 }
 54                 //this._stepSize *= decay;
 55                 //if (this._stepSize > 0.000001)
 56                 //{
 57                 //    this._stepSize = 0.000001;
 58                 //}
 59             }
 60         }
 61          
 62         private void BoundaryLimiting(ref double alpha, double lowerbound, double upperbound)
 63         {
 64             if (alpha < lowerbound)
 65             {
 66                 alpha = lowerbound;
 67             }
 68             else if (alpha > upperbound)
 69             {
 70                 alpha = upperbound;
 71             }
 72         }
 73  
 74         public double[] Predict(Instance[] instances)
 75         {
 76             double[] results = new double[instances.Length];
 77             for (int i = 0; i < results.Length; i++)
 78             {
 79                 results[i] = MathLib.Logistic(MathLib.VectorInnerProd(instances[i].featureValues, this.theta));
 80             }
 81             return results;
 82         }
 83 
 84         private void ResetArray(double[] dev)
 85         {
 86             for (int i = 0; i < dev.Length; i++)
 87             {
 88                 dev[i] = 0;
 89             }
 90         }
 91 
 92         private void Initialize()
 93         {
 94             Random ran = new Random(DateTime.Now.Second);
 95 
 96             this.theta = new double[this.dim];
 97             for (int i = 0; i < this.dim; i++)
 98             {
 99                 this.theta[i] = ran.NextDouble() * 0 ; // initialize theta with a small value
100             }
101         }
102 
103 
104         public static void Test()
105         {
106             LogisticRegression lr = new LogisticRegression(3);
107 
108             List<Instance> instances = new List<Instance>();
109             using (StreamReader rd = new StreamReader(@"D:\\local exp\\data.csv"))
110             {
111                 string content = rd.ReadLine();
112                 while ((content = rd.ReadLine()) != null)
113                 {
114                     instances.Add(Instance.ParseInstance(content,‘,‘));
115                 }
116             }
117 
118            // MinMaxNormalize(instances); 
119 
120             lr.Train(instances.ToArray()); 
121             
122         }
123 
124         private static void MinMaxNormalize(List<Instance> instances)
125         {
126             int dim = instances[0].dim;
127             double[] min = new double[dim];
128             double[] max = new double[dim];
129 
130             int instCnt = instances.Count;
131             for (int i = 0; i < instCnt; i++)
132             {
133                 for (int j = 0; j < dim; j++)
134                 {
135                     if (i == 0 || instances[i].featureValues[j] < min[j])
136                     {
137                         min[j] = instances[i].featureValues[j];
138                     }
139                     if (i == 0 || instances[i].featureValues[j] > max[j])
140                     {
141                         max[j] = instances[i].featureValues[j];
142                     }
143                 }
144             }
145 
146 
147             for (int j = 0; j < dim; j++)
148             {
149                 double gap = max[j] - min[j];
150                 if (gap <= 0)
151                 {
152                     continue;
153                 }
154                 for (int i = 0; i < instCnt; i++)
155                 {
156                     instances[i].featureValues[j] = (instances[i].featureValues[j] - min[j]) / gap;
157                 }
158             }
159              
160         }
161     }