SGD

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            List<float[]> inputs_x = new List<float[]>();
            inputs_x.Add( new float[] { 0.9f, 0.6f});
            inputs_x.Add(new float[] { 2f, 2.5f } );
            inputs_x.Add(new float[] { 2.6f, 2.3f });
            inputs_x.Add(new float[] { 2.7f, 1.9f });
 
            List<float> inputs_y = new List<float>();
            inputs_y.Add( 2.5f);
            inputs_y.Add( 2.5f);
            inputs_y.Add( 3.5f);
            inputs_y.Add( 4.2f);
 
            float[] weights = new float[3];
            for (var i= 0;i < weights.Length;i++)
                weights[i] = (float)new Random().NextDouble();
 
            int epoch = 30000;
            float epsilon =0.00001f;
            float lr = 0.01f;
 
            float lastCost=0;
 
            for (var epoch_i = 0; epoch_i <= epoch; epoch_i++)
            {
                //随机获取input
                var batch = GetRandomBatch(inputs_x, inputs_y, 2);
 
                float[] weights_in_poch = new float[weights.Length];
 
                foreach (var x_y in batch)
                {
                    var x1 = x_y.Item1.First();
                    var x2 = x_y.Item1.Skip(1).Take(1).First();
                    var target_y = x_y.Item2;
 
                    float diffWithTargetY = target_y - fun(x1, x2, weights[1], weights[2], weights[0]);
 
                    weights_in_poch[0] += diffWithTargetY * dy_b(x1, x2);
                    weights_in_poch[1] +=  diffWithTargetY * dy_theta1(x1, x2);
                    weights_in_poch[2] += diffWithTargetY * dy_theta2(x1, x2);
                }
 
                for(var i=0;i<weights.Length;i++)
                    weights[i] += lr * weights_in_poch[i];
 
                float totalErrorCost = 0f;
                foreach (var x_y in batch)
                {
                    var x1 = x_y.Item1.First();
                    var x2 = x_y.Item1.Skip(1).Take(1).First();
                    var target_y = x_y.Item2;
 
                    float diffWithTargetY = target_y - fun(x1, x2, weights[1], weights[2], weights[0]);
                    totalErrorCost += (float)System.Math.Pow(diffWithTargetY, 2)/2;
                }
 
                float cost = totalErrorCost / batch.Count;
 
                if (System.Math.Abs(cost - lastCost) <= epsilon)
                {
                    Console.WriteLine(string.Format("EPOCH {0}", epoch_i));
                    Console.WriteLine(string.Format("LAST MSE {0}", lastCost));
                    Console.WriteLine(string.Format("MSE {0}", cost));
                    break;
                }
 
                lastCost = cost;
 
                if (epoch_i % 100 == 0|| epoch_i==epoch)
                {
                    Console.WriteLine(string.Format("MSE {0}", cost));
                }
            }
 
            print(weights[1], weights[2], weights[0]);
 
            Console.ReadLine();
        }
 
        private static List<Tuple<float[], float>> GetRandomBatch(List<float[]> inputs_x, List<float> inputs_y, int maxCount)
        {
            List<Tuple<float[], float>> lst = new List<Tuple<float[], float>>();
 
            System.Random rnd = new Random((int)DateTime.Now.Ticks);
 
            int count = 0;
            while (count<maxCount)
            {
                int rndIndex = rnd.Next(inputs_x.Count);
                var item=Tuple.Create<float[], float>(inputs_x[rndIndex], inputs_y[rndIndex]);
                lst.Add(item);
                count++;
            }
 
            return lst;
        }
 
        private static void print(float theta1, float theta2, float b)
        {
            Console.WriteLine(string.Format("y={0}*x1+{1}*x2+{2}", theta1, theta2, b));
        }
        private static float fun(float x1, float x2, float theta1, float theta2, float b)
        {
            return theta1 * x1 + theta2 * x2 + b;
        }
        private static float dy_theta1(float x1, float x2)
        {
            return x1;
        }
 
        private static float dy_theta2(float x1, float x2)
        {
            return x2;
        }
 
        private static float dy_b(float x1, float x2)
        {
            return 1;
        }
    }
}