【机器学习实战】SGD 梯度下降

最新推荐文章于 2024-03-13 05:20:35 发布
最新推荐文章于 2024-03-13 05:20:35 发布
阅读量96 收藏
点赞数
文章标签： 人工智能 java python
原文链接：https://my.oschina.net/u/204498/blog/639280
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、梯度下降简介

http://baike.baidu.com/link?url=JRP2bhxuJzeawEEEXgqNRavoZBlGxbm4QW0EEoPz1epO4DFoTRnvssRAK0i2P95yMg8EBa_jf3qU_9u1JnQ1k_


梯度下降法是一个最优化算法。是求解无约束优化问题最简单和最古老的方法之一。

例子：

f(x)=x^2的最小值

利用梯度下降的方法解题步骤：

  1. 求梯度;grad=2x ===> 梯度是求导(多元就是求偏导)，几何意义就是某点变化最快的方向求最小值，就是梯度的相反方向移动

  2. x := x - step * grad ==> step为步长，就学习速率，如果步长足够下，保证了每一次迭代都在减小，但是收敛慢。如果步长太大，不能保证每一次迭代都减少，也不能保证收敛。可能在最优解出波动。

  3. 循环第2步.直到x的变化使得f(x)在两次的迭代之间的差值足够小。比如0.00000001，也就是说两次迭代f(x)基本没有变化。则说明f(x)已经达到了局部最小值。

package examples.mllib;

import java.text.DecimalFormat;

/**
 * @function ==> f(x) = x^2
 * @result => figure out the smallest of f(x)
 * @learning_rate => 0.1
 * @result_conditions => difference between every change is samller than
 *                    0.00000001
 * @author Harry Wu
 *
 */
public class JavaSGDExample {

	final static DecimalFormat df = new DecimalFormat("0.0000");
	
	static double func(double x) {
		return Math.pow(x, 2);
	}

	static double grad(double x) {
		return 2 * x;
	}

	public static void main(String[] args) {
		double step = 0.1;
		double x = 2;
		int k = 0;
		double change = func(x);
		double current = func(x);
		final double returnThreshold = 0.00000001;

		while (change > returnThreshold) {
			x = x - step * grad(x);
			change = current - func(x);
			current = func(x);
			k += 1;
		}
		
		System.out.println(df.format(x));
	}
}


二、多元

http://www.lxway.com/562680451.htm

package examples.mllib;

import java.util.ArrayList;

/**
 * spark-1.5.1-bin-hadoop2.6/data/mllib/ridge-data/lpsa.data
 * 
 * @author Harry Wu
 *
 */
public class JavaLinearRegressionWithSGDExample2 {

	static ArrayList<LabeledPoint> datas = new ArrayList<LabeledPoint>() {
		{
			add(new LabeledPoint(-0.4307829,
					new double[] { -1.63735562648104, -2.00621178480549, -1.86242597251066, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(-0.1625189,
					new double[] { -1.98898046126935, -0.722008756122123, -0.787896192088153, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(-0.1625189,
					new double[] { -1.57881887548545, -2.1887840293994, 1.36116336875686, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, 0.342627053981254, -0.155348103855541 }));
			add(new LabeledPoint(-0.1625189,
					new double[] { -2.16691708463163, -0.807993896938655, -0.787896192088153, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(0.3715636,
					new double[] { -0.507874475300631, -0.458834049396776, -0.250631301876899, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(0.7654678,
					new double[] { -2.03612849966376, -0.933954647105133, -1.86242597251066, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(0.8544153,
					new double[] { -0.557312518810673, -0.208756571683607, -0.787896192088153, 0.990146852537193,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.2669476,
					new double[] { -0.929360463147704, -0.0578991819441687, 0.152317365781542, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.2669476, new double[] { -2.28833047634983, -0.0706369432557794, -0.116315079324086,
					0.80409888772376, -0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.2669476, new double[] { 0.223498042876113, -1.41471935455355, -0.116315079324086,
					-1.02470580167082, -0.522940888712441, -0.29928234305568, 0.342627053981254, 0.199211097885341 }));
			add(new LabeledPoint(1.3480731,
					new double[] { 0.107785900236813, -1.47221551299731, 0.420949810887169, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, 0.342627053981254, -0.687186906466865 }));
			add(new LabeledPoint(1.446919,
					new double[] { 0.162180092313795, -1.32557369901905, 0.286633588334355, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.4701758, new double[] { -1.49795329918548, -0.263601072284232, 0.823898478545609,
					0.788388310173035, -0.522940888712441, -0.29928234305568, 0.342627053981254, 0.199211097885341 }));
			add(new LabeledPoint(1.4929041, new double[] { 0.796247055396743, 0.0476559407005752, 0.286633588334355,
					-1.02470580167082, -0.522940888712441, 0.394013435896129, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.5581446,
					new double[] { -1.62233848461465, -0.843294091975396, -3.07127197548598, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.5993876, new double[] { -0.990720665490831, 0.458513517212311, 0.823898478545609,
					1.07379746308195, -0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.6389967,
					new double[] { -0.171901281967138, -0.489197399065355, -0.65357996953534, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.6956156,
					new double[] { -1.60758252338831, -0.590700340358265, -0.65357996953534, -0.619561070667254,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.7137979, new double[] { 0.366273918511144, -0.414014962912583, -0.116315079324086,
					0.232904453212813, -0.522940888712441, 0.971228997418125, 0.342627053981254, 1.26288870310799 }));
			add(new LabeledPoint(1.8000583, new double[] { -0.710307384579833, 0.211731938156277, 0.152317365781542,
					-1.02470580167082, -0.522940888712441, -0.442797990776478, 0.342627053981254, 1.61744790484887 }));
			add(new LabeledPoint(1.8484548, new double[] { -0.262791728113881, -1.16708345615721, 0.420949810887169,
					0.0846342590816532, -0.522940888712441, 0.163172393491611, 0.342627053981254, 1.97200710658975 }));
			add(new LabeledPoint(1.8946169, new double[] { 0.899043117369237, -0.590700340358265, 0.152317365781542,
					-1.02470580167082, -0.522940888712441, 1.28643254437683, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(1.9242487, new double[] { -0.903451690500615, 1.07659722048274, 0.152317365781542,
					1.28380453408541, -0.522940888712441, -0.442797990776478, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.008214, new double[] { -0.0633337899773081, -1.38088970920094, 0.958214701098423,
					0.80409888772376, -0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.0476928,
					new double[] { -1.15393789990757, -0.961853075398404, -0.116315079324086, -1.02470580167082,
							-0.522940888712441, -0.442797990776478, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.1575593, new double[] { 0.0620203721138446, 0.0657973885499142, 1.22684714620405,
					-0.468824786336838, -0.522940888712441, 1.31421001659859, 1.72741139715549, -0.332627704725983 }));
			add(new LabeledPoint(2.1916535,
					new double[] { -0.75731027755674, -2.92717970468456, 0.018001143228728, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, 0.342627053981254, -0.332627704725983 }));
			add(new LabeledPoint(2.2137539, new double[] { 1.11226993252773, 1.06484916245061, 0.555266033439982,
					0.877691038550889, 1.89254797819741, 1.43890404648442, 0.342627053981254, 0.376490698755783 }));
			add(new LabeledPoint(2.2772673,
					new double[] { -0.468768642850639, -1.43754788774533, -1.05652863719378, 0.576050411655607,
							-0.522940888712441, 0.0120483832567209, 0.342627053981254, -0.687186906466865 }));
			add(new LabeledPoint(2.2975726, new double[] { -0.618884859896728, -1.1366360750781, -0.519263746982526,
					-1.02470580167082, -0.522940888712441, -0.863171185425945, 3.11219574032972, 1.97200710658975 }));
			add(new LabeledPoint(2.3272777, new double[] { -0.651431999123483, 0.55329161145762, -0.250631301876899,
					1.11210019001038, -0.522940888712441, -0.179808625688859, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.5217206, new double[] { 0.115499102435224, -0.512233676577595, 0.286633588334355,
					1.13650173283446, -0.522940888712441, -0.179808625688859, 0.342627053981254, -0.155348103855541 }));
			add(new LabeledPoint(2.5533438,
					new double[] { 0.266341329949937, -0.551137885443386, -0.384947524429713, 0.354857790686005,
							-0.522940888712441, -0.863171185425945, 0.342627053981254, -0.332627704725983 }));
			add(new LabeledPoint(2.5687881, new double[] { 1.16902610257751, 0.855491905752846, 2.03274448152093,
					1.22628985326088, 1.89254797819741, 2.02833774827712, 3.11219574032972, 2.68112551007152 }));
			add(new LabeledPoint(2.6567569, new double[] { -0.218972367124187, 0.851192298581141, 0.555266033439982,
					-1.02470580167082, -0.522940888712441, -0.863171185425945, 0.342627053981254, 0.908329501367106 }));
			add(new LabeledPoint(2.677591, new double[] { 0.263121415733908, 1.4142681068416, 0.018001143228728,
					1.35980653053822, -0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.7180005, new double[] { -0.0704736333296423, 1.52000996595417, 0.286633588334355,
					1.39364261119802, -0.522940888712441, -0.863171185425945, 0.342627053981254, -0.332627704725983 }));
			add(new LabeledPoint(2.7942279,
					new double[] { -0.751957286017338, 0.316843561689933, -1.99674219506348, 0.911736065044475,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.8063861,
					new double[] { -0.685277652430997, 1.28214038482516, 0.823898478545609, 0.232904453212813,
							-0.522940888712441, -0.863171185425945, 0.342627053981254, -0.155348103855541 }));
			add(new LabeledPoint(2.8124102, new double[] { -0.244991501432929, 0.51882005949686, -0.384947524429713,
					0.823246560137838, -0.522940888712441, -0.863171185425945, 0.342627053981254, 0.553770299626224 }));
			add(new LabeledPoint(2.8419982, new double[] { -0.75731027755674, 2.09041984898851, 1.22684714620405,
					1.53428167116843, -0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.8535925, new double[] { 1.20962937075363, -0.242882661178889, 1.09253092365124,
					-1.02470580167082, -0.522940888712441, 1.24263233939889, 3.11219574032972, 2.50384590920108 }));
			add(new LabeledPoint(2.9204698, new double[] { 0.570886990493502, 0.58243883987948, 0.555266033439982,
					1.16006887775962, -0.522940888712441, 1.07357183940747, 0.342627053981254, 1.61744790484887 }));
			add(new LabeledPoint(2.9626924, new double[] { 0.719758684343624, 0.984970304132004, 1.09253092365124,
					1.52137230773457, -0.522940888712441, -0.179808625688859, 0.342627053981254, -0.509907305596424 }));
			add(new LabeledPoint(2.9626924,
					new double[] { -1.52406140158064, 1.81975700990333, 0.689582255992796, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(2.9729753, new double[] { -0.132431544081234, 2.68769877553723, 1.09253092365124,
					1.53428167116843, -0.522940888712441, -0.442797990776478, 0.342627053981254, -0.687186906466865 }));
			add(new LabeledPoint(3.0130809, new double[] { 0.436161292804989, -0.0834447307428255, -0.519263746982526,
					-1.02470580167082, 1.89254797819741, 1.07357183940747, 0.342627053981254, 1.26288870310799 }));
			add(new LabeledPoint(3.0373539, new double[] { -0.161195191984091, -0.671900359186746, 1.7641120364153,
					1.13650173283446, -0.522940888712441, -0.863171185425945, 0.342627053981254, 0.0219314970149 }));
			add(new LabeledPoint(3.2752562, new double[] { 1.39927182372944, 0.513852869452676, 0.689582255992796,
					-1.02470580167082, 1.89254797819741, 1.49394503405693, 0.342627053981254, -0.155348103855541 }));
			add(new LabeledPoint(3.3375474, new double[] { 1.51967002306341, -0.852203755696565, 0.555266033439982,
					-0.104527297798983, 1.89254797819741, 1.85927724828569, 0.342627053981254, 0.908329501367106 }));
			add(new LabeledPoint(3.3928291, new double[] { 0.560725834706224, 1.87867703391426, 1.09253092365124,
					1.39364261119802, -0.522940888712441, 0.486423065822545, 0.342627053981254, 1.26288870310799 }));
			add(new LabeledPoint(3.4355988, new double[] { 1.00765532502814, 1.69426310090641, 1.89842825896812,
					1.53428167116843, -0.522940888712441, -0.863171185425945, 0.342627053981254, -0.509907305596424 }));
			add(new LabeledPoint(3.4578927, new double[] { 1.10152996153577, -0.10927271844907, 0.689582255992796,
					-1.02470580167082, 1.89254797819741, 1.97630171771485, 0.342627053981254, 1.61744790484887 }));
			add(new LabeledPoint(3.5160131, new double[] { 0.100001934217311, -1.30380956369388, 0.286633588334355,
					0.316555063757567, -0.522940888712441, 0.28786643052924, 0.342627053981254, 0.553770299626224 }));
			add(new LabeledPoint(3.5307626, new double[] { 0.987291634724086, -0.36279314978779, -0.922212414640967,
					0.232904453212813, -0.522940888712441, 1.79270085261407, 0.342627053981254, 1.26288870310799 }));
			add(new LabeledPoint(3.5652984, new double[] { 1.07158528137575, 0.606453149641961, 1.7641120364153,
					-0.432854616994416, 1.89254797819741, 0.528504607720369, 0.342627053981254, 0.199211097885341 }));
			add(new LabeledPoint(3.5876769, new double[] { 0.180156323255198, 0.188987436375017, -0.519263746982526,
					1.09956763075594, -0.522940888712441, 0.708239632330506, 0.342627053981254, 0.199211097885341 }));
			add(new LabeledPoint(3.6309855, new double[] { 1.65687973755377, -0.256675483533719, 0.018001143228728,
					-1.02470580167082, 1.89254797819741, 1.79270085261407, 0.342627053981254, 1.26288870310799 }));
			add(new LabeledPoint(3.6800909, new double[] { 0.5720085322365, 0.239854450210939, -0.787896192088153,
					1.0605418233138, -0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(3.7123518, new double[] { 0.323806133438225, -0.606717660886078, -0.250631301876899,
					-1.02470580167082, 1.89254797819741, 0.342907418101747, 0.342627053981254, 0.199211097885341 }));
			add(new LabeledPoint(3.9843437, new double[] { 1.23668206715898, 2.54220539083611, 0.152317365781542,
					-1.02470580167082, 1.89254797819741, 1.89037692416194, 0.342627053981254, 1.26288870310799 }));
			add(new LabeledPoint(3.993603, new double[] { 0.180156323255198, 0.154448192444669, 1.62979581386249,
					0.576050411655607, 1.89254797819741, 0.708239632330506, 0.342627053981254, 1.79472750571931 }));
			add(new LabeledPoint(4.029806,
					new double[] { 1.60906277046565, 1.10378605019827, 0.555266033439982, -1.02470580167082,
							-0.522940888712441, -0.863171185425945, -1.04215728919298, -0.864466507337306 }));
			add(new LabeledPoint(4.1295508, new double[] { 1.0036214996026, 0.113496885050331, -0.384947524429713,
					0.860016436332751, 1.89254797819741, -0.863171185425945, 0.342627053981254, -0.332627704725983 }));
			add(new LabeledPoint(4.3851468, new double[] { 1.25591974271076, 0.577607033774471, 0.555266033439982,
					-1.02470580167082, 1.89254797819741, 1.07357183940747, 0.342627053981254, 1.26288870310799 }));
			add(new LabeledPoint(4.6844434, new double[] { 2.09650591351268, 0.625488598331018, -2.66832330782754,
					-1.02470580167082, 1.89254797819741, 1.67954222367555, 0.342627053981254, 0.553770299626224 }));
			add(new LabeledPoint(5.477509, new double[] { 1.30028987435881, 0.338383613253713, 0.555266033439982,
					1.00481276295349, 1.89254797819741, 1.24263233939889, 0.342627053981254, 1.97200710658975 }));
		}
	};

	static double[] thetas = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
	final static int numIterations = 1000;
	final static double stepSize = 0.0000001;
	
	public static void stochasticSGD(){
		for (int i = 0; i < numIterations; i++) {
			for (LabeledPoint point : datas) {
				for (int j = 0; j < thetas.length; j++) {
					double total = 0.0;
					for (int k = 0; k < thetas.length; k++) {
						total = thetas[k] * point.getFeatures()[k];
					}
					double diff = total - point.getLabel();
					thetas[j] = thetas[j] - stepSize * diff * point.getFeatures()[j];
				}
			}
		}
		
		
		for(double theta : thetas){
			System.out.println(theta);
		}
		
		
		double total = 0.0;
		for(LabeledPoint point : datas){
			double sum = 0.0;
			for(int i = 0;i < point.getFeatures().length;i++){
				sum += thetas[i] * point.getFeatures()[i];
			}
			
			total += Math.pow(sum - point.getLabel(), 2);
		}
		
		System.out.println(total / datas.size());
	}
	
	public static void batchSGD(){
		for (int i = 0; i < numIterations; i++) {
			for (LabeledPoint point : datas) {
				for (int j = 0; j < thetas.length; j++) {
					double total = 0.0;
					for (LabeledPoint point2 : datas) {
						for (int k = 0; k < thetas.length; k++) {
							total = thetas[k] * point2.getFeatures()[k];
						}
					}
					
					double diff = total - point.getLabel();
					thetas[j] = thetas[j] - stepSize * diff * point.getFeatures()[j];
				}
			}
		}
		
		
		for(double theta : thetas){
			System.out.println(theta);
		}
		
		
		double total = 0.0;
		for(LabeledPoint point : datas){
			double sum = 0.0;
			for(int i = 0;i < point.getFeatures().length;i++){
				sum += thetas[i] * point.getFeatures()[i];
			}
			
			total += Math.pow(sum - point.getLabel(), 2);
		}
		
		System.out.println(total / datas.size());
	}

	public static void main(String[] args) {
		stochasticSGD();
		System.out.println();
		batchSGD();
	}
}

class LabeledPoint {
	private double label;
	private double[] features;

	public LabeledPoint(double label, double[] features) {
		this.label = label;
		this.features = features;
	}

	public double getLabel() {
		return label;
	}

	public void setLabel(double label) {
		this.label = label;
	}

	public double[] getFeatures() {
		return features;
	}

	public void setFeatures(double[] features) {
		this.features = features;
	}
}


转载于:https://my.oschina.net/u/204498/blog/639280

weixin_34107955
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
梯度下降SGD
Aroon_yuan的博客
12-06 408
当数据过多时，无法将数据一次性加载到内存中，进行模型训练， 因此可以使用随机梯度下降回归器或分类器，作为线性预测器 该方法每次只是用一个观察点来进行参数优化，因此代码使用ridge或lasso回归到达可比较的结果之前，采用了更多的迭代，但只需要较少的内存和时间。 使用SGD优化时，需要测试不同的代价函数性能，一些SGD对异常点抵抗力较强，例如分类的modfied_huer和回归的huber ...
随机梯度下降算法SGD（Stochastic gradient descent）
weixin_40170393的博客
03-14 8186
随机梯度下降SGD stochastic gradient descent
随机梯度下降sgd
03-14
logistic随机梯度下降问题.docx
深度学习笔记:详解优化器之随机梯度下降（SGD）
weixin_53765658的博客
03-13 1667
欢迎收藏Star我的Machine Learning Blog:https://github.com/purepisces/Wenqing-Machine_Learning_Blog。如果收藏star, 有问题可以随时与我交流, 谢谢大家！在深度学习中，优化器被用来调整模型的参数。优化器的目的是调整模型权重以最小化损失函数。回顾一下，我们使用线性类和激活函数类构建了自己的MLP模型，并且已经了解了如何对神经网络中使用的核心组件进行前向传播和反向传播。前向传播用于估计，而反向传播告诉我们参数变化如何影响损失。
随机梯度下降法（stochastic gradient descent，SGD）
热门推荐
qq_58146842的博客
11-12 7万+
梯度下降法 大多数机器学习或者深度学习算法都涉及某种形式的优化。 优化指的是改变特征x以最小化或最大化某个函数 f(x) 的任务。 我们通常以最小化 f(x)指代大多数最优化问题。 最大化可经由最小化算法最小化 ​​​​​​​-f(x)来实现。 我们把要最小化或最大化的函数称为目标函数或准则。 当我们对其进行最小化时，我们也把它称为损失函数或误差函数。 下面，我们假设一个损失函数为 ，其中 然后要使得最小化它。 梯度下降：梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给...
深度学习与PyTorch入门实战教程-随机梯度下降.rar
04-07
本教程将带你深入理解并实战随机梯度下降（Stochastic Gradient Descent, SGD），这是优化深度学习模型中最基础且广泛使用的算法。 随机梯度下降是一种优化算法，用于在多维度空间中寻找最小化或最大化的函数。在...
Spark MLlib随机梯度下降法概述与实例
08-27
Spark MLlib随机梯度下降法概述与实例是机器学习算法中的一种重要技术，用于解决线性回归问题。该算法通过不断地判断和选择当前目标下最优的路径，从而能够在最短路径下达到最优的结果。 随机梯度下降算法的理论...
机器学习实战代码.zip
最新发布
04-16
3. 优化器：如梯度下降、随机梯度下降（SGD）、Adam等，调整模型参数以最小化损失函数。 4. 正则化：L1和L2正则化防止过拟合，保持模型的简洁性。 5. 学习率调度：动态调整学习率，初期快速收敛，后期精细调整。 五...
07.梯度下降-学习学习学习
05-28
在机器学习领域，梯度下降是一种广泛使用的优化算法，用于寻找函数最小值。在这个主题“07.梯度下降-学习学习学习”中，我们将深入探讨梯度下降的基本原理、应用以及它在实际问题中的重要性。这个压缩包可能包含了...
随机梯度下降算法SGD
weixin_37958272的博客
07-05 1554
随机梯度下降算法SGD 参考：为什么说随机最速下降法 (SGD) 是一个很好的方法？ 假如我们要优化一个函数f(x)f(x)f(x) ，即找到它的最小值，常用的方法叫做 Gradient Descent (GD)，也就是最速下降法。说起来很简单, 就是每次沿着当前位置的导数方向走一小步，走啊走啊就能够走到一个好地方了。 如上图, 就像你下山一样，每一步你都挑最陡的路走，如果最后你没摔死的话，一般你很快就能够走到山脚。用数学表示一下，就是 xt+1=xt−ηt∇f(xt)x_{t+1}=x_t-\eta_t
随机梯度下降SGD算法原理和实现
01-06
backpropagation backpropagation解决的核心问题损失函数c与w,b求偏导，(c为cost(w,b)) 整体来说，分两步 1.z=w*a’+b 2.a=sigmoid(z) 其中，a’表示上一层的输出值，a表示当前该层的输出值 1，输入x，正向的更新一遍所有的a值就都有了， 2，计算输出层的delta=(y-a)点乘sigmoid(z)函数对z的偏导数 3，计算输出层之前层的误差delta，该delta即为损失函数对b的偏导数， 4，然后根据公式4，求出对w的偏导数 公式推导详解 import numpy as np import random class Netwo
深度学习入门之SGD随机梯度下降法
weixin_46713695的博客
03-01 3万+
SGD SGD为随机梯度下降法。用数学式可以将 SGD 写成如下的式（6.1）。 这里把需要更新的权重参数记为W，把损失函数关于W的梯度记为∂L/∂W 。η 表示学习率，实际上会取 0.01 或 0.001 这些事先决定好的值。式子中的←表示用右边的值更新左边的值。如式（6.1）所示，SGD 是朝着梯度方向只前进一定距离的简单方法。现在，我们将 SGD 实现为一个 Python 类（为方便后面使用，我们将其实现为一个名为 SGD 的类）。 class SGD: def __init__(self,
机器学习优化过程中的各种梯度下降方法（（SGD， Momentum，Nesterov，Adagrad，RMSprop，Adadelta，Adam，Adamax，Nadam）
qq_40379132的博客
06-11 1608
除了调整学习率之外，还可以通过使用最近一段时间内的平均梯度来代替当前时刻的梯度来作为参数更新的方向。在小批量梯度下降中，如果每次选取样本数量比较小，损失会呈现震荡的方式下降。有效地缓解梯度下降中的震荡的方式是通过用梯度的移动平均来代替每次的实际梯度，并提高优化速度，这就是动量法。动量是模拟物理中的概念。一般而言，一个物体的动量指的是这个物体在它运动方向上保持运动的趋势，是物体的质量和速度的乘积。动量法（MomentumMethod）[Rumelhart et al., 1988]是用之前积累动量来替代真正的
梯度下降法与SGD
rover
02-08 620
梯度是一个矢量，有大小和方向。 梯度始终指向损失函数中增长最快的方向。梯度下降法算法会沿着负梯度的方向走一步，以便尽快降低损失。 梯度下降法 要使梯度下降法找到一个函数的局部极小值，必须向函数上当前点对应梯度（或者是近似梯 度）的反放向的规定步长距离点进行迭代搜索。如果相反地向梯度正方向迭代进行搜索，则会接近函 数的局部极大值点；这个过程则被称为梯度上升法。 梯度下降法算法用梯度乘以一个称为...
机器学习笔记（五）——最优化方法：梯度下降（BGD&SGD）
weixin_43312354的博客
03-29 2386
一、概念 （一） 为什么需要梯度下降算法 仅从数学抽象的角度来看：每个模型都有自己的损失函数，不管是监督式学习还是非监督式学习。损失函数包含了若干个位置的模型参数，比如在多元线性回归中，损失函数： (y−Xb⋅θ)T(Xb⋅θ) (y-X_b\cdot\theta)^T(X_b\cdot\theta)(y−Xb​⋅θ)T(Xb​⋅θ) ，其中向量表示未知的模型参数，我们就是要找到使损失函数尽可能...
一文通透优化算法：从梯度下降、SGD到牛顿法、共轭梯度(23修订版)
结构之法 算法之道
08-01 2万+
一文通透优化算法：从随机梯度、随机梯度下降法到牛顿法、共轭梯度 1 什么是梯度下降法 经常在机器学习中的优化问题中看到一个算法，即梯度下降法，那到底什么是梯度下降法呢？ 维基百科给出的定义是梯度下降法（Gradient descent）是一个一阶最优化算法，通常也称为最速下降法。 要使用梯度下降法找到一个函数的局部极小值，必须向函数上当前点对应梯度（或者是近...
梯度下降 BGD,SGD,MBGD
丑小鸭
08-06 890
梯度下降在深度学习里很常见，最近也在学习深度学习的基础知识，这里对于几种常用的梯度下降法做个简单的总结。 BGD：批量梯度下降法，SGD：随机梯度下降法，MBGD：小批量梯度下降 一 ：那么什么是梯度下降呢？（我们借例子来说一下） 假设我们提供了这样的数据样本（样本值取自于y=2*x1+3*x2）：   x1 x2 y 1 4 15 3 5 ...
A.深度学习基础入门篇[三]：优化策略梯度下降算法：SGD、MBGD、Momentum、Adam、AdamW
丨汀、的博客
04-05 2751
如果我们定义了一个机器学习模型，比如一个三层的神经网络，那么就需要使得这个模型能够尽可能拟合所提供的训练数据。但是我们如何评价模型对于数据的拟合是否足够呢？，当损失函数值下降，我们就认为模型在拟合的路上又前进了一步。最终模型对训练数据集拟合的最好的情况是在损失函数值最小的时候，在指定数据集上时，为损失函数的平均值最小的时候。
机器学习：随机梯度下降法
weixin_30622181的博客
06-27 5150
1.梯度下降 1）什么是梯度下降？ 因为梯度下降是一种思想，没有严格的定义，所以用一个比喻来解释什么是梯度下降。 简单来说，梯度下降就是从山顶找一条最短的路走到山脚最低的地方。但是因为选择方向的原因，我们找到的的最低点可能不是真正的最低点。如图所示，黑线标注的路线所指的方向并不是真正的地方。 既然是选择一个方向下山...
机器学习复习归纳1
08-08
"这篇资源是关于机器学习的复习总结，主要涵盖了梯度下降法、线性回归、逻辑回归以及Softmax回归等基本概念和方法。作者Zhc在2018年12月26日编写，目的是为次日的考试做准备。" **梯度下降法** 梯度下降法是优化...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值