牛顿法改进版（吴恩达机器学习c#实践）

参考书目：机械最优设计技术，孟兆明 常德功编著

namespace 牛顿法改进版//求函数minF（X）=x0^2+x1^2-x0*x1-10*x0-4*x1+60
{
    //1,如何求偏导数？
    //2,如何求黑塞矩阵逆矩阵？
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        int 维数N = 2;
        double 收敛精度E = 0.01;
        double[] X;
        private void Form1_Load(object sender, EventArgs e)
        {
            X = new double[维数N];
            for (int n = 0; n < 维数N; n++)
            {
                X[n] = 0; // X[0] = 0;
                // X[1] = 0;
            }
            newton迭代(X[0], X[1]);
        }
        private void newton迭代(double a0, double a1)
        {
            double[] X的偏导数P = new double[维数N];
            X的偏导数P[0] = 2 * a0 - a1 - 10;//x0^2+x1^2-x0*x1-10*x0-4*x1+60=f
            X的偏导数P[1] = 2 * a1 - a0-4;//x0^2+x1^2-x0*x1-10*x0-4*x1+60=f
            //求梯度幅值
            double G = 0;
            for (int i = 0; i < 维数N; i++)
            {
                G += X的偏导数P[i] * X的偏导数P[i];
            }
            G = Math.Sqrt(G);
            double f = a0 * a0 + a1 * a1 - a0 * a1 - 10 * a0 - 4 * a1 + 60;
            //求黑塞矩阵，此处已经求出
            int H00 = 2;//X的偏导数P[0]二阶x0x0=求导2 * a0 - a1 - 10=2//A
            int H01 = -1;//X的偏导数P[0]二阶x0x1=求导2 * a0 - a1 - 10=-1//C
            int H10 = -1;//X的偏导数P[1]二阶x1x0=求导 2 * a1 - a0-4=-1//B
            int H11 = 2;//X的偏导数P[1]二阶x1x1=求导 2 * a1 - a0-4=2//D
            if (G > 收敛精度E)//继续迭代
            {
                //求黑塞矩阵的逆矩阵，此处已经求出
                //double 逆H00 = 2.0 / 3;//AA
                //double 逆H01 = 1.0 / 3;//CC
                //double 逆H10 = 1.0 / 3;//BB
                //double 逆H11 = 2.0 / 3;//DD
                double 逆H00 = 2;//AA
                double 逆H01 = -1;//CC
                double 逆H10 = -1;//BB
                double 逆H11 = 2;//DD
                黑塞矩阵的逆(ref 逆H00, ref 逆H01, ref 逆H10, ref 逆H11);
                a0 = a0 - 逆H00 * X的偏导数P[0] - 逆H01 * X的偏导数P[1];
                a1 = a1 - 逆H10 * X的偏导数P[0] - 逆H11 * X的偏导数P[1];
                //继续迭代
                newton迭代(a0, a1);
            }
        }
        private void 黑塞矩阵的逆(ref double a,ref double c,ref double b,ref double d)
        {//未考虑bc-ad==0
            //因为黑塞矩阵的逆*黑塞矩阵=单位矩阵
            //a c*AA CC=1  0
            //b d BB DD 0  1
            //a*AA+c*BB=1;
            //b*AA+d*BB=0;
            aa=-d/(bc-ad);bb=b/(bc-ad)
            //a*cc+c*dd=0;
            //b*cc+d*dd=1;
            ///cc=c/(bc-ad);dd=-a/(bc-ad);
            //所以a c*1/(bc-ad)*-d   c= 1   0
            //    b d            b  -a  0   1
            double tempa=0; double tempb=0; double tempc=0; double tempd=0;
            double 系数=1.0/(b*c-a*d);
            tempa=系数*(-d);
            tempc = 系数 * (c);
            tempb = 系数 * (b);
            tempd = 系数 * (-a);
            a = tempa; b = tempb; c = tempc; d = tempd;
           
        }
    }
}

还可以有如下改进，注意非二次牛顿法不是等号，是近似等于；阻尼牛顿法，又引入了步长t，回归等号：

以下公式，要求理解泰勒展开和矩阵求导，可以参考我的博文，sift高斯差分函数泰勒展开的理解（矩阵求导）

 

最后的改进：我们梯度下降，坐标上升法，牛顿法中使用的迭代函数其实可以用do{.....}while(条件)循环语句替代，效率会提高，因为递归迭代让人脑瓜疼！！！！！！