LM法 java版

最新推荐文章于 2024-04-18 22:51:27 发布
最新推荐文章于 2024-04-18 22:51:27 发布
阅读量476 收藏 1
点赞数 1
分类专栏： 算法 文章标签： java android LM算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuanyuanyelian/article/details/79584003
版权 
package com.reallife.arithmetic;

import android.util.Log;
import Jama.Matrix;

public class GaussNewton {
	// double[] xData = new double[]{36, 37, 38, 39, 40, 41, 42, 43, 44, 45};
	// double[] yData = new double[]{2475.8, 2854.63, 3141.37, 3333.83,
	// 3455.6, 3522.2, 3557.77, 3568.27, 3573.63, 3586.83};
	private final String TAG = "GaussNewton";
	private double[] xData;
	private double[] yData;
	
	private double def_residual = 0.01;//默认迭代收敛条件
	private double residual = 0;//当前拟合精度
	private double lamda = 0.01;//迭代步长
	private double v = 10.0;//步长倍数
//	private boolean isUpdate = false;//是否需要更新雅可比矩阵
	
	private double[][] unitMatrix;// 单位阵
	private double[] bMatrix;// 系数β矩阵
	private double[] init_b;// 系数β矩阵
	private int index = 0;//计算方程的编号
	private boolean reCalculate = false;
	private int count = 0;
	private int c_count = 0;
	private int m;
	private int n;
	private int iterations = 1;// 迭代次数
	
	/**
	 * @param data
	 * 
	 * */
	public GaussNewton(double[][] data) {
		super();

		xData = new double[data.length];
		yData = new double[data.length];

		for (int i = 0; i < data.length; i++) {
			xData[i] = data[i][0];
			yData[i] = data[i][1]; 
//			Log.e(TAG, "GaussNewton  "+xData[i]+"  "+yData[i]);
		}
	}
	
	/**
	 * @param xData
	 * @param yData
	 * 
	 * */
	public GaussNewton(double[] xData, double[] yData) {
		super();

		this.xData = xData;
		this.yData = yData;
	}
	
	/**
	 * @param row 求解的未知参数个数
	 * @param init_b 未知参数初值数组
	 * @param def_residual 0表示使用默认值
	 * */
	public void setInit(int row, double[] init_b, double def_residual, int iterations, int index) throws MyAlgorithmException{
		// β1,β2迭代初值
		// bMatrix[0][0] = 23.4502;
		// bMatrix[1][0] = 0.4553;
		// bMatrix[2][0] = 3621.22;
		if (row == init_b.length) {
			
			if (def_residual < 0) {
				throw new MyAlgorithmException("Def_residual must be a number greater than 0.",2);
			}else if (def_residual > 0) {
				this.def_residual = def_residual;
			}
			
			if (iterations != 0) {
				this.iterations = iterations;
			}
			
			unitMatrix = new double[row][row];
			for (int i = 0; i < row; i++) {
				for (int j = 0; j < row; j++) {
					if (i==j) {
						unitMatrix[i][j] = 1;
					}else {
						unitMatrix[i][j] = 0;
					}
				}
			}
			
			if (!reCalculate) {
				this.init_b = new double[row];
				count = 0;
				c_count = 0;
			}
			bMatrix = new double[row];
			m = xData.length;
			n = row;
			//1、选取初值点bMatrix、拟合精度def_residual、迭代次数iterations、初始步长lamda、步长倍数
			lamda = 0.01;
			
			for (int i = 0; i < row; i++) {
				bMatrix[i] = init_b[i];
				if (!reCalculate) {
					this.init_b[i] = init_b[i];
				}
			}
			scal = init_b[1]/init_b[0];
			
			this.index = index;
			
		}else {
			throw new MyAlgorithmException("Row must be the same as the length of init_b.",0);
		}
	}

	/**
	 * 迭代公式求解，即1中公式⑩
	 * */
	public double[] magic() throws MyAlgorithmException {
		
		if (bMatrix == null) {
			throw new MyAlgorithmException("The initial value of bMatrix must be given.",1);
		}else {
			double[][] J = new double[m][n];
			double[][] JT = new double[n][m];
			double[][] invertedPart = null;
			
			//2、计算拟合精度 ------求方差r(β)矩阵: ri = yi - f(xi, b)
			double[][] residuals = new double[m][1];//残差集合
			double newresidual = 0;//残差
			for (int i = 0; i < m; i++) {
				if (index == 1) {
					residuals[i][0] = yData[i] - (bMatrix[2]/(1+Math.exp(bMatrix[0]-bMatrix[1]*xData[i])));
					if (i==0) {
						newresidual = Math.abs(residuals[i][0]);
					}else {
						if (newresidual > Math.abs(residuals[i][0])) {
							newresidual = Math.abs(residuals[i][0]);
						}
					}
//					newresidual += residuals[i][0]*residuals[i][0];
				}else {
					residuals[i][0] = yData[i] - (bMatrix[2] - Math.exp(bMatrix[0] - bMatrix[1] * xData[i]));
					if (i==0) {
						newresidual = Math.abs(residuals[i][0]);
					}else {
						if (newresidual > Math.abs(residuals[i][0])) {
							newresidual = Math.abs(residuals[i][0]);
						}
					}
//					newresidual += residuals[i][0]*residuals[i][0];
				}
			}
			residual = newresidual;
//			System.out.println("Step2、计算拟合精度   " + newresidual);
			
			for (int k = 0; k < iterations; k++) {
//				System.out.println("-------------------------------------------");
//				System.out.println("---------------------"+k+"--------------------");
				
				//3、计算雅可比矩阵
//				if (isUpdate || k == 0) {
					for (int i = 0; i < m; i++) {
						for (int j = 0; j < n; j++) {
							if (index == 1) {
								J[i][j] = secondDerivative1(xData[i], bMatrix[0], bMatrix[1], bMatrix[2], j);
//							System.out.println("Step3、计算雅可比矩阵   J[" + i + "]["+j+"]  " + J[i][j]);
							}else {
								J[i][j] = secondDerivative2(xData[i], bMatrix[0], bMatrix[1], bMatrix[2], j);
//							System.out.println("Step3、计算雅可比矩阵   J[" + i + "]["+j+"]  " + J[i][j]);
							}
						}
					}
//				}
				
				
				//4、计算JTJ+lamda*I
				//求转置矩阵JT
				JT = MatrixMath.invert(J);
				// 矩阵JT与J相乘
				invertedPart = MatrixMath.mult(JT, J);
				double[][] unitPart = MatrixMath.mult(unitMatrix, lamda);
				double[][] totalPart = MatrixMath.plus(invertedPart, unitPart);
				
				//5、求解delta
				double[][] reversedPart;
				try {
					// 求矩阵invertedPart的逆矩阵:(JT*J+lamda*I)^-1 
					Matrix reversedMatrix = new Matrix(totalPart);
					reversedPart = reversedMatrix.inverse().getArray();
				} catch (Exception e) {
					// 矩阵invertedPart行列式的值：|JT*J+lamda*I|
					double result = MatrixMath.mathDeterminantCalculation(totalPart);
					// 求矩阵invertedPart的逆矩阵:(JT*J+lamda*I)^-1 
					reversedPart = MatrixMath.getInverseMatrix(totalPart, result);
//					e.printStackTrace();
				}

//				System.out.println("-----------reversedPart  "+k+"-------------");
//				for (int i = 0; i < reversedPart.length; i++) {
//					for (int l = 0; l < reversedPart[i].length; l++) {
//						System.out.println("reversedPart[" + i + "]["+l+"]  " + reversedPart[i][l]);
//					}
//				}
				
				// 求矩阵积reversedPart*JT*residuals: (JT*J+lamda*I)^-1*JT*r
				double[][] products = MatrixMath.mult(MatrixMath.mult(reversedPart, JT), residuals);
				double[] product = new double[products.length];
				double[] product_temporary = new double[products.length];
				double delta = 0;
				for (int i = 0; i < products.length; i++) {
					product[i] = products[i][0];
					product_temporary[i] = bMatrix[i]+product[i];
					if (i==0) {
						delta = Math.abs(product[i]);
					}else {
						if (delta > Math.abs(product[i])) {
							delta = Math.abs(product[i]);
						}
					}
//					for (int l = 0; l < products[i].length; l++) {
//						System.out.println("Step5、求解delta  product[" + i + "][" + l + "]  " + products[i][l]);
//					}
				}
				
				//6、(1)判断当前精度是否小于上一次的精度
				for (int i = 0; i < m; i++) {
					if (index == 1) {
						residuals[i][0] = yData[i] - (product_temporary[2]/(1+Math.exp(product_temporary[0]-product_temporary[1]*xData[i])));
						if (i==0) {
							newresidual = Math.abs(residuals[i][0]);
						}else {
							if (newresidual > Math.abs(residuals[i][0])) {
								newresidual = Math.abs(residuals[i][0]);
							}
						}
//						newresidual += residuals[i][0]*residuals[i][0];
					}else {
						residuals[i][0] = yData[i] - (product_temporary[2] - Math.exp(product_temporary[0] - product_temporary[1] * xData[i]));
						if (i==0) {
							newresidual = Math.abs(residuals[i][0]);
						}else {
							if (newresidual > Math.abs(residuals[i][0])) {
								newresidual = Math.abs(residuals[i][0]);
							}
						}
//						newresidual += residuals[i][0]*residuals[i][0];
					}
				}
//				System.out.println("Step6、判断当前精度是否小于上一次的精度  newresidual  " + newresidual+"  "+(newresidual <= residual));
//				if (newresidual <= residual) {
					//7、(1.1)是，则迭代Xn+1=Xn+delta
					// 迭代公式, 即公式⑩
					bMatrix = MatrixMath.plus(bMatrix, product);
					residual = newresidual;
//					for (int i = 0; i < bMatrix.length; i++) {
//						System.out.println("Step7、迭代公式, 即公式⑩  bMatrix[" + i + "]  " + bMatrix[i]);
//					}
//					isUpdate = true;
					
					//8、(2)判断是否delta满足拟合精度
					if (Math.abs(product[0]) < def_residual && Math.abs(product[1]) < def_residual && Math.abs(product[2]) < def_residual) {
						//9、(2.1)是，则结束迭代
//						System.out.println("Step9、(2.1)是，则结束迭代  "+k+"  lamda  "+lamda);
//						for (int i = 0; i < bMatrix.length; i++) {
//							System.out.println(bMatrix[i]);
//						}
						break;
					}else {
						//10、(2.2)否，lamda=lamda/v，n=n+1，重复4
						if (newresidual < residual) {
							lamda=lamda/v;
						}else {
							lamda=lamda*v;
						}
//						lamda=lamda/v;
//						System.out.println("Step10、lamda  " + lamda);
					}
//				}else {
//					//11、(1.2)否，lamda=lamda*v，n=n+1，重复4
//					
//					bMatrix = MatrixMath.plus(bMatrix, product);
//					// 迭代公式, 即公式⑩
//					if (Math.abs(product[0]) < def_residual && Math.abs(product[1]) < def_residual && Math.abs(product[2]) < def_residual) {
//						residual = newresidual;
//						for (int i = 0; i < bMatrix.length; i++) {
//							System.out.println("Step11、满足条件，退出循环  bMatrix[" + i + "]  " + bMatrix[i]);
//						}
//						break;
//					}else {
//						isUpdate = false;
//						lamda=lamda*v;
//					}
//					System.out.println("Step11、lamda  " + lamda);
//				}
				
				
//				if (k == 0) {
//					residual = newresidual;
//				}else {
//					System.out.println("-----------residual  "+residual+"  "+newresidual+"-------------");
//					if (newresidual > residual) {
//						isMore = true;
//						lamda = lamda*10;
//					}else {
//						isMore = false;
//						lamda = lamda/10;
//					}
//					residual = newresidual;
//				}
//				
//				System.out.println("-----------lamda  "+lamda+"-------------");
//				
//				//判断product是否满足条件，若满足条件则跳出迭代循环
//				boolean iteration_end = true;
//				for (int i = 0; i < product.length; i++) {
//					// || Double.isNaN(product[i][0])
//					if (Math.abs(product[i]) > def_residual) {
//						iteration_end = false;
//					}
//				}
//				if (iteration_end) {
//					break;
//				}
			}
			
			// 计算拟合优度
			
//			// 显示系数值
//			System.out.println("----------------------------------");
//			System.out.println("b1: " + bMatrix[0] + "\nb2: " + bMatrix[1] + "\nb3: " + bMatrix[2]+"  "+(Math.abs(bMatrix[2]) > Math.pow(10, 10)));
//			System.out.println("***********"+c_count+"**********"+count+"*************");
			if (index == 1 && (Double.isNaN(bMatrix[0]) || Double.isNaN(bMatrix[1]) || Double.isNaN(bMatrix[2])
					|| bMatrix[0] < 0
					|| bMatrix[1]/bMatrix[0] > 0.035 || bMatrix[0] < 10)) {
				
				if (count == 0) {
					if (bMatrix[1]/bMatrix[0] > 0.035) {
						scal = 0.015;
					}
				}else {
					if (scal >= 0.035) {
						scal = 0.035;
					}else {
						scal = 0.015+0.001*count;
					}
				}
				
				count ++;
				
				if (count < 22) {
					double r2 = calculateR2(bMatrix);
					if (r2 > best_r2) {
						best_r2 = r2;
						best_value[0] = bMatrix[0];
						best_value[1] = bMatrix[1];
						best_value[2] = bMatrix[2];
					}
					bMatrix[0] = init_b[0];
					bMatrix[1] = init_b[0]*scal;
					bMatrix[2] = init_b[2];
//					System.out.println(">>>  count < 22 init change  "+bMatrix[0]+"  "+bMatrix[1]+"  "+bMatrix[2]);
					//重新计算  初始化计数参数
					reCalculate = true;
					setInit(bMatrix.length, bMatrix, def_residual, iterations, index);
					magic();
				}else {
					bMatrix[0] = best_value[0];
					bMatrix[1] = best_value[1];
					bMatrix[2] = best_value[2];
				}
//				else {
//					c_count ++;
//					if (c_count <= 30) {
//						count = 0;
//						scal = 0.015;
//						bMatrix[0][0] = init_b[0];
//						bMatrix[1][0] = init_b[0]*scal;
//						bMatrix[2][0] = init_b[2]*Math.pow(1.4, c_count);
//						System.out.println(">>>  c_count < 5 init change  "+bMatrix[0][0]+"  "+bMatrix[1][0]+"  "+bMatrix[2][0]);
//						magic();
//					}
//				}
			}
		}
		return bMatrix;
	}
	private double[] best_value = new double[3];
	private double best_r2 = 0;
	private double scal = 0;
	
	private double calculateR2(double[] bMatrix){
		double R2 = 0;
		
		/**
		 * （1）计算残差平方和Q=∑(y-y*)^2和∑y^2，其中，y代表的是实测值，y*代表的是预测值；
		 * （2）拟合度指标RNew=1-(Q/∑y^2)^(1/2)
		 * */
		double residual = 0;//残差平方和
		double quadratic = 0;//平方和
		
		int length = yData.length;
		double value = 0;
		for (int i = 0; i < length; i++) {
			if (index == 1) {
				value = (float) (bMatrix[2]/(1+Math.exp(bMatrix[0]-bMatrix[1]*(i+1))));
			}else {
				value = (float) (bMatrix[2] - Math.exp(bMatrix[0] - bMatrix[1] * (i+1)));
			}
			residual += Math.pow(yData[i]-value,2.0);
			quadratic += Math.pow(yData[i],2.0);
		}
		R2 = 1-Math.sqrt(residual/quadratic);
//		Log.e(TAG, "R2  "+R2);
		
		return R2;
	}

	/** c-Math.exp(a-b*x)*/
	private static double secondDerivative2(double x, double b1, double b2, double b3, int index) {
		switch (index) {
			case 0:
				return -Math.exp(b1 - b2 * x);// 对系数b1求导
			case 1:
				return x * Math.exp(b1 - b2 * x);// 对系数b2求导
			case 2:
				return 1;// 对系数b3求导
		}
		return 0;
	}

	/** c(Math.pow((1+Math.exp(a-b*x)), 2)))*/
	private static double secondDerivative1(double x, double b1, double b2, double b3, int index) {
		switch (index) {
			case 0:
				return -b3*(Math.exp(b1-b2*x)/(Math.pow((1+Math.exp(b1-b2*x)), 2)));// 对系数b1求导
			case 1:
				return x*b3*(Math.exp(b1-b2*x)/(Math.pow((1+Math.exp(b1-b2*x)), 2)));// 对系数b2求导
			case 2:
				return 1/(1+Math.exp(b1-b2*x));// 对系数b3求导
		}
		return 0;
	}

}

算法的原理就不多啰嗦了，反正网上一大把

可以参考原论文：下载地址

可以参考K. Madsen等人的《Methods for non-linear least squares problems》：下载地址

 

看过LM算法的应该都知道，LM是在高斯牛顿法的基础上修改的，所以可以先去了解一下高斯牛顿法，其实楼主也是一知半解的，但是根据改编的方法可以解决楼主的问题，所以也就不深究了。如有大神，请勿喷。

 

因为是在项目中需要进行曲线拟合，需要非线性最小二乘法然后用LM法进行迭代求最优解。算法是根据原理一步一步写下来的，在实际使用过程中有问题，所以做了一些改编。本文只是作为学习笔记，如有需要使用的，可以参考下，不推荐照搬照抄。

痆古酊旳琲伤
关注
专栏目录
非线性优化整理-3.Levenberg-Marquardt法(LM法)
boksic的专栏
02-01 3万+
基础 LM法 mu的计算 收敛条件 算法流程 结论 信赖域法 注意到关于LM法网上大部份资料内容比较混乱，主要是因为LM法是可以从两个不同的视角看的。一种是看作介于高斯牛顿和梯度下降法之间的一种算法，另一种是作为一种信赖域的算法来看，而两种视角下虽然最后结论比较相似，但公式推导的思路差别会比较大。 从历史上讲，LM法最初作为高斯牛顿法的改良而被提出，随后才有了信赖域法上应用。这里先从
LM算法学习笔记（一）
weixin_30314631的博客
01-03 1619
LM算法全称为Levenberg-Marquard algorithm，在正式介绍该算法之前，我们需要先研读一下对该算法的发展有重要意义的几篇论文。首先，我们从LM算法的开篇之作（Levenberg于1944年发表）开始。 A method for the solution of certain non-linear problems in least squares ...
LM算法的讲解
04-29
LM法概论
机器学习训练算法十(列文伯格-马夸尔特法(LM 法))
黎明鱼儿
01-09 3551
本文详细介绍了列文伯格-马夸尔特算法（LM算法），这是一种用于解决非线性最小二乘问题的优化算法。文章从算法的介绍、数学原理、阻尼因子更新策略、列文伯格方法与马夸尔特方法的区别，到Matlab程序实现，全面阐述了LM算法的理论和应用。LM算法结合了高斯牛顿法的快速局部收敛性和梯度下降法的全局搜索能力，通过引入阻尼因子实现算法的鲁棒性。
牛顿法，高斯牛顿法，列文伯格-马夸尔特(LM)法 (含代码)【最小二乘非线性求解】
weixin_43763292的博客
11-29 7288
牛顿法是一种函数逼近法,它的基本思想是：在极小点附近用x(k)x^{(k)}x(k)点的二阶泰勒多项式来近似目标函数f(x)f(x)f(x),并用选代点x(k)x^{(k)}x(k)处指向近似二次函数的极小点方向作为搜索方向p(k)p^{(k)}p(k)。minf(x),x∈Rnminf(x),x∈Rn其中f(x)f(x)f(x)在点x(k)x^{(k)}x(k。
分治法求逆序数的算法实现（Java）
weixin_43363034的博客
10-24 2633
分治法求逆序数的算法实现（Java） 使用分治法求取自然数序列的逆序数，其实现是建立在分治法归并排序的基础上。主要思路：分而治之，mergeSort_lm方法负责“分”（递归），merge_lm方法负责“治”（归并）。对于一个自然数序列A，设其逆序数为a，若将自然数序列划分为B1、B2，那么BI的逆序数+B2的逆序数+B2中元素与B1中元素组成的逆序对个数。可以按照以上模式（mergeSort_l...
Java 分治法 求解一组数组元素的最大值和最小值
wodedipang_的博客
06-28 5719
分治法的思想： 将求出的小规模的问题的解合并为一个更大规模的问题的解，自底向上逐步求出原来问题的解。分治法的设计思想，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，从小的问题一个个解决，分而治之。求解一组数组元素的最大值和最小值，传统的方法，我们可以使用遍历或者最简单的排序方法来实现，但是时间复杂度非常高，介于降低时间复杂度，我们可以采用分治法思想求出最大值和最小值。 步
蛮力法0/1背包问题java
05-24
下面是一个Java代码实现示例，仅供参考： ``` public class BruteForce01Knapsack { static int maxW = Integer.MIN_VALUE; // 存储背包中物品总重量的最大值 static int[] weight = {2, 2, 4, 6, 3}; // 物品...
java程序设计任务驱动实训教程答案，LeetCode 42
2401_84412469的博客
04-18 690
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]输出：6解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。输入：height = [4,2,0,3,2,5]输出：9按列枚举暴力法枚举每一个"凹坑"，然后向后向右找最高的柱子二者间的最小值。
非线性回归模型java_R中的非线性多元回归
weixin_42557803的博客
02-28 533
我正在尝试使用数据集在R中运行非线性多元回归，它有数千行，所以我只是将前几个放在这里：Header.1 Header.2 Header.3 Header.4 Header.5 Header.6 Header.71 -60 -45 615 720 1.8318 0.428 -11.6142 -59 -...
最优化 拟牛顿法，高斯-牛顿法，LM法，共轭梯度法
12-05
无约束最优化问题典型算法的MATLAB代码
优化算法学习（LM算法）
zhulinmanbu114的博客
07-18 2万+
LM算法可以理解为**Gauss-Newton算法与最速下降法的结合**
LM算法——列文伯格-马夸尔特算法（最速下降法，牛顿法，高斯牛顿法）（完美解释负梯度方向）
热门推荐
三眼二郎
10-23 6万+
首先谈一下应用场景——在拟合的时候进行应用 什么是拟合？你有一堆数据点，我有一个函数，但是这个函数的很多参数是未知的，我只知道你的这些数据点都在我的函数上，因此我可以用你的数据点来求我的函数的未知参数。例如：matlab中的fit函数 最小二乘法天生就是用来求拟合的，看函数和数据点的逼近关系。它通过最小化误差的平方和寻找数据的最佳函数匹配。 拟合我们可以认为是一种试探性的方法，这种方法在计算机出...
手写VIO代码中LM法的应用
qq_42700518的博客
01-29 599
LM 法的实现 废话不多说！！ 下面Solve函数实现了LM法的主要步骤。 总结起来： 1、构建初始优化问题的H矩阵 MakeHessian() 。 2、计算阻尼因子的初始值 ComputeLambdaInitLM()。 3、开始迭代 while(退出条件)，迭代有3个退出条件 ：(1)、迭代次数 (2)、变量更新很小 (3)、总残差很小。 while(一次迭代完成) (1)、为H矩阵添加...
最优化方法总结——梯度下降法、最速下降法、牛顿法、高斯牛顿法、LM法、拟牛顿法
Dfreedom.的博客
11-22 1万+
最优化方法总结——梯度下降法、最速下降法、牛顿法、高斯牛顿法、LM法、拟牛顿法。总结了算法的迭代公式以及改进的点和解决的问题
LM(列文伯格-马夸尔特)方法的个人理解，以及实现问题
Pengcode的博客
08-04 8183
前言 LM方法是适用于求解方程最小值的一种方法，在非线性优化的框架中，优化方法分为Line Search 和 Trust Region，也就是线搜索和信任域方法，它们是两种不同性质的方法。 不同之处: LIne Search:不管当前迭代点X(k)到最优解X*之间的路径，每次迭代X(k)得到X(k+1),都是使用该点的反向梯度方向进行值得寻找，这就导致了这样一种可能得问题：‘在靠近X*的时候，X(k)反复震荡，不容易收敛。这种情况特别是会发生在固定迭代步长的时候，Eg:对于求解f(x)=x^2的最优解
【转】LM(Levenberg-Marquard)算法的实现
xueyinhualuo的专栏
07-17 5096
转载请注明出处：http://www.codelast.com/   LM算法，全称为Levenberg-Marquard算法，它可用于解决非线性最小二乘问题，多用于曲线拟合等场合。 LM算法的实现并不算难，它的关键是用模型函数 f 对待估参数向量p在其邻域内做线性近似，忽略掉二阶以上的导数项，从而转化为线性最小二乘问题，它具有收敛速度快等优点。LM算法属于一种“信赖域法”——所谓的
android图像处理系统1.3
郑海波(莫川)的CSDN博客
08-30 5506
android图像处理系统1.3 项目成品：手相评分：http://as.baidu.com/a/item?docid=2758385 该版本由很大的更新。在处理图像的方式上，我引入了java中的矩阵类(Matrix)。该类由http://math.nist.gov/javanumerics/jama/提供。实现了矩阵的加、减、乘、转置、矩阵的逆、范数、行列式等算法，并有多种构造函数和获得矩阵
lm studio linux版本安装
最新发布
10-14
Lm Studio是一款用于Linux环境的开发工具，通常支持Ubuntu、Debian等发行版。下面是安装LM Studio Linux版本的基本步骤： 1. **更新包列表**： 打开终端（Terminal），输入命令`sudo apt update` 或者 `sudo yum ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值