<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>一维搜索 &#8211; 编码无悔 /  Intent &amp; Focused</title>
	<atom:link href="https://www.codelast.com/tag/%E4%B8%80%E7%BB%B4%E6%90%9C%E7%B4%A2/feed/" rel="self" type="application/rss+xml" />
	<link>https://www.codelast.com</link>
	<description>最优化之路</description>
	<lastBuildDate>Mon, 27 Apr 2020 17:31:28 +0000</lastBuildDate>
	<language>zh-Hans</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1</generator>
	<item>
		<title>[原创] line search中的重要定理 - 梯度与方向的点积为零</title>
		<link>https://www.codelast.com/%e5%8e%9f%e5%88%9b-line-search%e4%b8%ad%e7%9a%84%e9%87%8d%e8%a6%81%e5%ae%9a%e7%90%86-%e6%a2%af%e5%ba%a6%e4%b8%8e%e6%96%b9%e5%90%91%e7%9a%84%e7%82%b9%e7%a7%af%e4%b8%ba%e9%9b%b6/</link>
					<comments>https://www.codelast.com/%e5%8e%9f%e5%88%9b-line-search%e4%b8%ad%e7%9a%84%e9%87%8d%e8%a6%81%e5%ae%9a%e7%90%86-%e6%a2%af%e5%ba%a6%e4%b8%8e%e6%96%b9%e5%90%91%e7%9a%84%e7%82%b9%e7%a7%af%e4%b8%ba%e9%9b%b6/#respond</comments>
		
		<dc:creator><![CDATA[learnhard]]></dc:creator>
		<pubDate>Sun, 02 Mar 2014 04:17:53 +0000</pubDate>
				<category><![CDATA[Algorithm]]></category>
		<category><![CDATA[Math]]></category>
		<category><![CDATA[原创]]></category>
		<category><![CDATA[line search]]></category>
		<category><![CDATA[optimization]]></category>
		<category><![CDATA[一维搜索]]></category>
		<category><![CDATA[最优化]]></category>
		<guid isPermaLink="false">http://www.codelast.com/?p=7838</guid>

					<description><![CDATA[<p>
对精确的line search（线搜索），有一个重要的定理：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/line_search_important_theory.png" style="width: 292px; height: 62px;" /></div>
<p>这个定理表明，当前点在 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 方向上移动到的那一点（ <span class='MathJax_Preview'>\({x_k} + {\alpha _k}{d_k}\)</span><script type='math/tex'>{x_k} + {\alpha _k}{d_k}</script> ）处的梯度，与当前点的搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 的点积为零。<br />
<span id="more-7838"></span><br />
其中， <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> 是称之为&#8220;步长&#8221;的一个实数，它是通过line search算法求出来的。</p>
<p>为什么会有这样的结论？我们来看看。<br />
对每一个line search过程来说，搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 已经已经是确定的了（在最优化算法中，如何找出一个合适的 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 不是line search干的事情）。所以，在一个确定的 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 上，要找到一个合适的 <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> ，使得 <span class='MathJax_Preview'>\(\phi (\alpha ) = f({x_k} + \alpha {d_k})\)</span><script type='math/tex'>\phi (\alpha ) = f({x_k} + \alpha {d_k})</script> 这个函数满足 <span class='MathJax_Preview'>\(f({x_k} + {\alpha _k}{d_k}) < f({x_k})\)</span><script type='math/tex'>f({x_k} + {\alpha _k}{d_k}) < f({x_k})</script> ，这就是line search的目的。说白了，就是要找到 <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> 使 <span class='MathJax_Preview'>\(\phi (\alpha )\)</span><script type='math/tex'>\phi (\alpha )</script> 的函数函数值变小。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a>&#8230; <a href="https://www.codelast.com/%e5%8e%9f%e5%88%9b-line-search%e4%b8%ad%e7%9a%84%e9%87%8d%e8%a6%81%e5%ae%9a%e7%90%86-%e6%a2%af%e5%ba%a6%e4%b8%8e%e6%96%b9%e5%90%91%e7%9a%84%e7%82%b9%e7%a7%af%e4%b8%ba%e9%9b%b6/" class="read-more">Read More </a></p>]]></description>
										<content:encoded><![CDATA[<p>
对精确的line search（线搜索），有一个重要的定理：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/line_search_important_theory.png" style="width: 292px; height: 62px;" /></div>
<p>这个定理表明，当前点在 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 方向上移动到的那一点（ <span class='MathJax_Preview'>\({x_k} + {\alpha _k}{d_k}\)</span><script type='math/tex'>{x_k} + {\alpha _k}{d_k}</script> ）处的梯度，与当前点的搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 的点积为零。<br />
<span id="more-7838"></span><br />
其中， <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> 是称之为&ldquo;步长&rdquo;的一个实数，它是通过line search算法求出来的。</p>
<p>为什么会有这样的结论？我们来看看。<br />
对每一个line search过程来说，搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 已经已经是确定的了（在最优化算法中，如何找出一个合适的 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 不是line search干的事情）。所以，在一个确定的 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 上，要找到一个合适的 <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> ，使得 <span class='MathJax_Preview'>\(\phi (\alpha ) = f({x_k} + \alpha {d_k})\)</span><script type='math/tex'>\phi (\alpha ) = f({x_k} + \alpha {d_k})</script> 这个函数满足 <span class='MathJax_Preview'>\(f({x_k} + {\alpha _k}{d_k}) < f({x_k})\)</span><script type='math/tex'>f({x_k} + {\alpha _k}{d_k}) < f({x_k})</script> ，这就是line search的目的。说白了，就是要找到 <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> 使 <span class='MathJax_Preview'>\(\phi (\alpha )\)</span><script type='math/tex'>\phi (\alpha )</script> 的函数函数值变小。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
但是，要小到什么程度呢？假设小到有可能的&ldquo;最小&rdquo;，即：<br />
 <span class='MathJax_Preview'>\(\phi ({\alpha _k}) = f({x_k} + {\alpha _k}{d_k}) = \mathop {\min }\limits_{\alpha > 0} f({x_k} + \alpha {d_k}) = \mathop {\min }\limits_{\alpha > 0} \phi (\alpha )\)</span><script type='math/tex'>\phi ({\alpha _k}) = f({x_k} + {\alpha _k}{d_k}) = \mathop {\min }\limits_{\alpha > 0} f({x_k} + \alpha {d_k}) = \mathop {\min }\limits_{\alpha > 0} \phi (\alpha )</script> <br />
那么，我们称这样的line search为&ldquo;精确的line search&rdquo;&mdash;&mdash;你看，这名字好贴切：我们精确地找到了函数值最小的那个点。</p>
<p>既然 <span class='MathJax_Preview'>\({x_k} + {\alpha _k}{d_k}\)</span><script type='math/tex'>{x_k} + {\alpha _k}{d_k}</script> 是函数值最小的那个点，那么，在该点处的一阶导数（即梯度）为零，所以我们对上式求导（ <span class='MathJax_Preview'>\(\alpha \)</span><script type='math/tex'>\alpha </script> 是自变量， <span class='MathJax_Preview'>\({x_k}\)</span><script type='math/tex'>{x_k}</script> 和 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 为常量）：<br />
 <span class='MathJax_Preview'>\(\phi '({\alpha _k}) = {\left[ {f({x_k} + {\alpha _k}{d_k})} \right]^\prime } \cdot (0 + 1 \cdot {d_k}) = {\left[ {f({x_k} + {\alpha _k}{d_k})} \right]^\prime }{d_k} = \nabla f{({x_k} + {\alpha _k}{d_k})^T}{d_k} = 0\)</span><script type='math/tex'>\phi '({\alpha _k}) = {\left[ {f({x_k} + {\alpha _k}{d_k})} \right]^\prime } \cdot (0 + 1 \cdot {d_k}) = {\left[ {f({x_k} + {\alpha _k}{d_k})} \right]^\prime }{d_k} = \nabla f{({x_k} + {\alpha _k}{d_k})^T}{d_k} = 0</script> <br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
这就是我们前面说的定理了。</p>
<p><span style="color: rgb(255, 255, 255);">文章来源：</span><a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">https://www.codelast.com/</span></a><br />
<span style="color: rgb(255, 0, 0);">➤➤</span>&nbsp;版权声明&nbsp;<span style="color: rgb(255, 0, 0);">➤➤</span>&nbsp;<br />
转载需注明出处：<u><a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><em><span style="color: rgb(0, 0, 255);"><strong style="font-size: 16px;"><span style="font-family: arial, helvetica, sans-serif;">codelast.com</span></strong></span></em></a></u>&nbsp;<br />
感谢关注我的微信公众号（微信扫一扫）：</p>
<p style="border: 0px; font-size: 13px; margin: 0px 0px 9px; outline: 0px; padding: 0px; color: rgb(77, 77, 77);">
	<img decoding="async" alt="wechat qrcode of codelast" src="https://www.codelast.com/codelast_wechat_qr_code.jpg" style="width: 200px; height: 200px;" /></p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.codelast.com/%e5%8e%9f%e5%88%9b-line-search%e4%b8%ad%e7%9a%84%e9%87%8d%e8%a6%81%e5%ae%9a%e7%90%86-%e6%a2%af%e5%ba%a6%e4%b8%8e%e6%96%b9%e5%90%91%e7%9a%84%e7%82%b9%e7%a7%af%e4%b8%ba%e9%9b%b6/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>[原创]使用一维搜索(line search)的算法的收敛性</title>
		<link>https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%bd%bf%e7%94%a8%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2line-search%e7%9a%84%e7%ae%97%e6%b3%95%e7%9a%84%e6%94%b6%e6%95%9b%e6%80%a7/</link>
					<comments>https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%bd%bf%e7%94%a8%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2line-search%e7%9a%84%e7%ae%97%e6%b3%95%e7%9a%84%e6%94%b6%e6%95%9b%e6%80%a7/#respond</comments>
		
		<dc:creator><![CDATA[learnhard]]></dc:creator>
		<pubDate>Tue, 29 Oct 2013 15:24:10 +0000</pubDate>
				<category><![CDATA[Algorithm]]></category>
		<category><![CDATA[Math]]></category>
		<category><![CDATA[原创]]></category>
		<category><![CDATA[optimization]]></category>
		<category><![CDATA[一维搜索]]></category>
		<category><![CDATA[收敛性]]></category>
		<category><![CDATA[最优化]]></category>
		<guid isPermaLink="false">http://www.codelast.com/?p=7514</guid>

					<description><![CDATA[<p>
在最优化领域中，有一类使用一维搜索（line search）的算法，例如<a href="http://www.codelast.com/?p=2573" target="_blank" rel="noopener noreferrer"><span style="background-color:#ffa07a;">牛顿法</span></a>等。这类算法采用的是 <span style="color:#0000ff;">确定搜索方向&#8594;进行一维搜索&#8594;调整搜索方向&#8594;进行一维搜索</span> 的迭代过程来求解。那么，这类算法应该满足什么条件的时候才能收敛？本文将略为讨论一下。请务必看清本文的标题：不是讨论line search的收敛性，而是讨论使用line search的算法的收敛性。<br />
<span id="more-7514"></span><br />
<span style="background-color:#00ff00;">【1】</span>搜索方向条件<br />
搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 满足什么条件时算法才能收敛？谈到这个问题，首先就要定义搜索方向&#8212;&#8212;要有一个&#8220;参照物&#8221;，要不然何来方向之说呢？<br />
用 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 与负梯度 <span class='MathJax_Preview'>\( - {g_k}\)</span><script type='math/tex'> - {g_k}</script> 的夹角 <span class='MathJax_Preview'>\({\theta _k}\)</span><script type='math/tex'>{\theta _k}</script> 来衡量搜索方向。我们先给出结论： <span class='MathJax_Preview'>\({\theta _k}\)</span><script type='math/tex'>{\theta _k}</script> 应满足：<br />
<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_convergence_property_1.png" style="width: 280px; height: 73px;" /><br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
为了说明这个式子是怎么来的，需要先说明两个向量（ <span class='MathJax_Preview'>\({d_k}, - {g_k}\)</span><script type='math/tex'>{d_k}, - {g_k}</script> 都是向量）夹角的余弦怎么计算：<br />
<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_convergence_property_2.png" style="width: 200px; height: 86px;" /><br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a>&#8230; <a href="https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%bd%bf%e7%94%a8%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2line-search%e7%9a%84%e7%ae%97%e6%b3%95%e7%9a%84%e6%94%b6%e6%95%9b%e6%80%a7/" class="read-more">Read More </a></p>]]></description>
										<content:encoded><![CDATA[<p>
在最优化领域中，有一类使用一维搜索（line search）的算法，例如<a href="http://www.codelast.com/?p=2573" target="_blank" rel="noopener noreferrer"><span style="background-color:#ffa07a;">牛顿法</span></a>等。这类算法采用的是 <span style="color:#0000ff;">确定搜索方向&rarr;进行一维搜索&rarr;调整搜索方向&rarr;进行一维搜索</span> 的迭代过程来求解。那么，这类算法应该满足什么条件的时候才能收敛？本文将略为讨论一下。请务必看清本文的标题：不是讨论line search的收敛性，而是讨论使用line search的算法的收敛性。<br />
<span id="more-7514"></span><br />
<span style="background-color:#00ff00;">【1】</span>搜索方向条件<br />
搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 满足什么条件时算法才能收敛？谈到这个问题，首先就要定义搜索方向&mdash;&mdash;要有一个&ldquo;参照物&rdquo;，要不然何来方向之说呢？<br />
用 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 与负梯度 <span class='MathJax_Preview'>\( - {g_k}\)</span><script type='math/tex'> - {g_k}</script> 的夹角 <span class='MathJax_Preview'>\({\theta _k}\)</span><script type='math/tex'>{\theta _k}</script> 来衡量搜索方向。我们先给出结论： <span class='MathJax_Preview'>\({\theta _k}\)</span><script type='math/tex'>{\theta _k}</script> 应满足：<br />
<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_convergence_property_1.png" style="width: 280px; height: 73px;" /><br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
为了说明这个式子是怎么来的，需要先说明两个向量（ <span class='MathJax_Preview'>\({d_k}, - {g_k}\)</span><script type='math/tex'>{d_k}, - {g_k}</script> 都是向量）夹角的余弦怎么计算：<br />
<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_convergence_property_2.png" style="width: 200px; height: 86px;" /><br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
分子 <span class='MathJax_Preview'>\({ - {g_k}^T{d_k}}\)</span><script type='math/tex'>{ - {g_k}^T{d_k}}</script> 是两个向量的点积（数量积），分母 <span class='MathJax_Preview'>\({\left\| {{g_k}} \right\|\left\| {{d_k}} \right\|}\)</span><script type='math/tex'>{\left\| {{g_k}} \right\|\left\| {{d_k}} \right\|}</script> 是两个向量的范数之积，分母&gt;0。<br />
由上面 <span class='MathJax_Preview'>\({\theta _k}\)</span><script type='math/tex'>{\theta _k}</script> 的取值范围可知 <span class='MathJax_Preview'>\(\cos {\theta _k} \in (0,1)\)</span><script type='math/tex'>\cos {\theta _k} \in (0,1)</script> ，即 <span class='MathJax_Preview'>\(\cos {\theta _k} > 0\)</span><script type='math/tex'>\cos {\theta _k} > 0</script> ，因此 <span class='MathJax_Preview'>\({g_k}^T{d_k} < 0\)</span><script type='math/tex'>{g_k}^T{d_k} < 0</script> <br />
所以，根据泰勒展开式（忽略掉高阶无穷小部分）：<br />
 <span class='MathJax_Preview'>\(f({x_k} + \alpha {d_k}) = f({x_k}) + \alpha {g_k}^T{d_k} + o(\alpha )\)</span><script type='math/tex'>f({x_k} + \alpha {d_k}) = f({x_k}) + \alpha {g_k}^T{d_k} + o(\alpha )</script> <br />
我们可知， <span class='MathJax_Preview'>\(f({x_k} + \alpha {d_k}) < f({x_k})\)</span><script type='math/tex'>f({x_k} + \alpha {d_k}) < f({x_k})</script> ，即<span style="color:#0000ff;">函数值是下降的</span>&mdash;&mdash;下降正是最优化的目标。<br />
所以你现在明白为什么 <span class='MathJax_Preview'>\({\theta _k}\)</span><script type='math/tex'>{\theta _k}</script> 要满足上面的条件了。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
<span style="background-color:#00ff00;">【2】</span>两个关于收敛性的重要理论<br />
这两个理论非常重要，作个比喻，如果你要自己设计一个使用line search技术的算法，并且要保证它能收敛的话，那么，你可能就要让你的算法符合这两个理论的要求。<br />
其中一个理论描述了使用精确line search技术的算法的收敛性，另一个描述了使用不精确line search技术的算法的收敛性。<br />
<span style="background-color:#dda0dd;">①</span>适用于使用精确line search技术的算法<br />
设最优化算法产生的点序列为 <span class='MathJax_Preview'>\(\{ {x_k}\} ,\{ f({x_k})\} \)</span><script type='math/tex'>\{ {x_k}\} ,\{ f({x_k})\} </script> ，对任意 <span class='MathJax_Preview'>\({x_0} \in {R^n}\)</span><script type='math/tex'>{x_0} \in {R^n}</script> ，目标函数的梯度 <span class='MathJax_Preview'>\(g(x)\)</span><script type='math/tex'>g(x)</script> 在水平集 <span class='MathJax_Preview'>\(L = \{ x \in {R^n}:f(x) \le f({x_0})\} \)</span><script type='math/tex'>L = \{ x \in {R^n}:f(x) \le f({x_0})\} </script> 上<span style="color:#ff0000;">一致连续</span>，若line search的步长 <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> 满足精确搜索条件 <span class='MathJax_Preview'>\({\alpha _k} = \arg \mathop {\min }\limits_{\alpha > 0} f({x_k} + \alpha {d_k})\)</span><script type='math/tex'>{\alpha _k} = \arg \mathop {\min }\limits_{\alpha > 0} f({x_k} + \alpha {d_k})</script> ，搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 与 <span class='MathJax_Preview'>\( - {g_k}\)</span><script type='math/tex'> - {g_k}</script> 的夹角满足前面所说的搜索方向条件，那么，必然会发生下面3种情况中的一种：<br />
<span style="color:#0000ff;">（1）</span>存在某个有限的 <span class='MathJax_Preview'>\(k\)</span><script type='math/tex'>k</script> ，使得 <span class='MathJax_Preview'>\({g_k} = 0\)</span><script type='math/tex'>{g_k} = 0</script> <br />
<span style="color:#0000ff;">（2）</span> <span class='MathJax_Preview'>\(f({x_k}) \to - \infty \)</span><script type='math/tex'>f({x_k}) \to - \infty </script> <br />
<span style="color:#0000ff;">（3）</span><span style="color:#ff0000;"> <span class='MathJax_Preview'>\({g_k} \to 0\)</span><script type='math/tex'>{g_k} \to 0</script> </span><br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
其中，（3）是最常见的情况，（1）和（2）很少出现&mdash;&mdash;书上是这么说的，至于为什么，我不知道。<br />
（3）中的 <span class='MathJax_Preview'>\({g_k} \to 0\)</span><script type='math/tex'>{g_k} \to 0</script> 又是个什么概念呢？大家可以想像一下二维平面上的寻优过程，一个图像类似于抛物线的函数，当搜索点逐渐向极小值点逼近时，其梯度 <span class='MathJax_Preview'>\({g_k}\)</span><script type='math/tex'>{g_k}</script> 正是趋于0的。</p>
<p>另外，上面出现了&ldquo;<a href="http://zh.wikipedia.org/zh/%E4%B8%80%E8%87%B4%E8%BF%9E%E7%BB%AD" target="_blank" rel="noopener noreferrer"><span style="background-color:#ffa07a;">一致连续</span></a>&rdquo;的概念，我不太了解，这里摘录Wiki的部分内容：<br />
<span style="color:#800000;">一致连续性描述定义在一定度量空间上的函数的性质。与连续性刻画函数在局部的性质不同，一致连续刻画的是函数的整体性质。一致连续是比连续更苛刻的条件。一个函数在某度量空间上一致连续，则其在此度量空间上必然连续，但反之未必成立。直观上，一致连续可以理解为，当自变量 <span class='MathJax_Preview'>\(x\)</span><script type='math/tex'>x</script> 在足够小的范围内变动时，函数值 <span class='MathJax_Preview'>\(y\)</span><script type='math/tex'>y</script> 的变动也会被限制在足够小的范围内。</span><br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
<span style="background-color:#dda0dd;">②</span>适用于使用不精确line search技术的算法<br />
设最优化算法产生的点序列为 <span class='MathJax_Preview'>\(\{ {x_k}\} ,\{ f({x_k})\} \)</span><script type='math/tex'>\{ {x_k}\} ,\{ f({x_k})\} </script> ，对任意 <span class='MathJax_Preview'>\({x_0} \in {R^n}\)</span><script type='math/tex'>{x_0} \in {R^n}</script> ，目标函数的梯度 <span class='MathJax_Preview'>\(g(x)\)</span><script type='math/tex'>g(x)</script> 在 <span class='MathJax_Preview'>\({R^n}\)</span><script type='math/tex'>{R^n}</script> 上<span style="color:#ff0000;">Lipschitz连续</span>，若line search的步长 <span class='MathJax_Preview'>\({\alpha _k}\)</span><script type='math/tex'>{\alpha _k}</script> 满足<a href="http://www.codelast.com/?p=7320" target="_blank" rel="noopener noreferrer"><span style="background-color:#ffa07a;">Wolfe-Powell准则</span></a>，搜索方向 <span class='MathJax_Preview'>\({d_k}\)</span><script type='math/tex'>{d_k}</script> 与 <span class='MathJax_Preview'>\( - {g_k}\)</span><script type='math/tex'> - {g_k}</script> 的夹角满足前面所说的搜索方向条件，那么，必然会发生下面3种情况中的一种：</p>
<div>
	<span style="color:#0000ff;">（1）</span>存在某个有限的 <span class='MathJax_Preview'>\(k\)</span><script type='math/tex'>k</script> ，使得 <span class='MathJax_Preview'>\({g_k} = 0\)</span><script type='math/tex'>{g_k} = 0</script> </div>
<div>
	<span style="color:#0000ff;">（2）</span> <span class='MathJax_Preview'>\(f({x_k}) \to - \infty \)</span><script type='math/tex'>f({x_k}) \to - \infty </script> </div>
<div>
	<span style="color:#0000ff;">（3）</span><span style="color:#ff0000;"> <span class='MathJax_Preview'>\({g_k} \to 0\)</span><script type='math/tex'>{g_k} \to 0</script> </span><br />
	和上面一样，书上说，（3）是最常见的情况，（1）和（2）很少出现。对（3）的含义的解释，还是请看上面。</p>
<p>	这里又出现了一个新名词：<a href="http://zh.wikipedia.org/zh/%E5%88%A9%E6%99%AE%E5%B8%8C%E8%8C%A8%E9%80%A3%E7%BA%8C" target="_blank" rel="noopener noreferrer"><span style="background-color:#ffa07a;">Lipschitz（利普希茨）连续</span></a>。很抱歉，这个我还是不懂（数学不好的人泪奔）。但是从Wiki的解释，我们仍可以看出个大概来：<br />
	<span style="color:#800000;">符合利普希茨条件的函数一致连续，也连续。直觉上，利普希茨连续函数限制了函数改变的速度。</span></p>
<p>	我感觉，利普希茨连续是比&ldquo;一致连续&rdquo;更强的条件。我从《数学分析（上）第四章》里看到一个结论：由函数 <span class='MathJax_Preview'>\(f(x)\)</span><script type='math/tex'>f(x)</script> 在区间 <span class='MathJax_Preview'>\(I\)</span><script type='math/tex'>I</script> 上Lipschitz连续可得： <span class='MathJax_Preview'>\(f(x)\)</span><script type='math/tex'>f(x)</script> 在 <span class='MathJax_Preview'>\(I\)</span><script type='math/tex'>I</script> 上一致连续。</p>
<p>	有人会说，为什么不精确的一维搜索需要一个&ldquo;更强&rdquo;的连续条件啊？我猜是不是由于它是不精确的，所以满足的条件就需要强一些才能达到收敛？当然，这只是直观猜测，谁来给补充一下吧。<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">https://www.codelast.com/</span></a><br />
	<span style="color: rgb(255, 0, 0);">➤➤</span>&nbsp;版权声明&nbsp;<span style="color: rgb(255, 0, 0);">➤➤</span>&nbsp;<br />
	转载需注明出处：<u><a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><em><span style="color: rgb(0, 0, 255);"><strong style="font-size: 16px;"><span style="font-family: arial, helvetica, sans-serif;">codelast.com</span></strong></span></em></a></u>&nbsp;<br />
	感谢关注我的微信公众号（微信扫一扫）：</p>
<p style="border: 0px; font-size: 13px; margin: 0px 0px 9px; outline: 0px; padding: 0px; color: rgb(77, 77, 77);">
		<img decoding="async" alt="wechat qrcode of codelast" src="https://www.codelast.com/codelast_wechat_qr_code.jpg" style="width: 200px; height: 200px;" /></p>
</div>
]]></content:encoded>
					
					<wfw:commentRss>https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%bd%bf%e7%94%a8%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2line-search%e7%9a%84%e7%ae%97%e6%b3%95%e7%9a%84%e6%94%b6%e6%95%9b%e6%80%a7/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>[原创]一维搜索中的划界(Bracket)算法</title>
		<link>https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2%e4%b8%ad%e7%9a%84%e5%88%92%e7%95%8cbracket%e7%ae%97%e6%b3%95/</link>
					<comments>https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2%e4%b8%ad%e7%9a%84%e5%88%92%e7%95%8cbracket%e7%ae%97%e6%b3%95/#comments</comments>
		
		<dc:creator><![CDATA[learnhard]]></dc:creator>
		<pubDate>Sat, 26 Oct 2013 15:30:03 +0000</pubDate>
				<category><![CDATA[Algorithm]]></category>
		<category><![CDATA[Math]]></category>
		<category><![CDATA[原创]]></category>
		<category><![CDATA[bracket]]></category>
		<category><![CDATA[line search]]></category>
		<category><![CDATA[optimization]]></category>
		<category><![CDATA[一维搜索]]></category>
		<category><![CDATA[划界]]></category>
		<category><![CDATA[最优化]]></category>
		<guid isPermaLink="false">http://www.codelast.com/?p=7360</guid>

					<description><![CDATA[<p>
很多最优化算法需要用到一维搜索（line search）子算法，而在众多的一维搜索算法中，大多数都要求函数被限制在一个<span style="color:#0000ff;">单峰区间</span>内，也就是说，在进行一维搜索的区间内，函数是一个<span style="color:#0000ff;">单峰函数</span>。尽管有一些改进的一维搜索算法（例如 <span class='MathJax_Preview'>\(H\ddot opfinger\)</span><script type='math/tex'>H\ddot opfinger</script> 建议的一种改进过的黄金搜索算法）可以处理函数非单峰的情况，但是，在没有确定函数在一个区间内是单峰的之前，即使在搜索过程中，函数值持续减小，我们也不能说极小值是一定存在的，因此，找出一个区间，在此区间之内使函数是单峰的，这个过程是必需的（我更倾向于接受这种观点）。这个过程就叫作<span style="color:#ff0000;">划界</span>（<span style="color:#0000ff;">Bracket</span>）。Bracket这个单词是括号的意思，很形象&#8212;&#8212;用括号包住一个范围，就是划界。在某些书中，划界算法也被称为<span style="color:#0000ff;">进退法</span>。<br />
<span id="more-7360"></span><br />
<span style="background-color:#00ff00;">【1】</span>什么是单峰区间？什么是单峰函数？<br />
从字面上理解，&#8220;单峰&#8221;即函数只有一个峰，如下图所示（在区间[-8,8]内是单峰的）：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_1.png" style="width: 309px; height: 153px;" /></div>
<p><span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
而下面的这个函数，在区间[2,14]内就不是单峰函数了：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_2.png" style="width: 462px; height: 129px;" /></div>
<p>现在，我们再用数学的话来定义一下单峰区间和单峰函数：<br />
 <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 为 <span class='MathJax_Preview'>\(R\)</span><script type='math/tex'>R</script> 的子集，存在 <span class='MathJax_Preview'>\({\alpha ^*} \in [a,b]\)</span><script type='math/tex'>{\alpha ^*} \in [a,b]</script> ，使得 <span class='MathJax_Preview'>\(f(\alpha )\)</span><script type='math/tex'>f(\alpha )</script> 在 <span class='MathJax_Preview'>\([a,{\alpha ^*}]\)</span><script type='math/tex'>[a,{\alpha ^*}]</script> 上严格单调减，在 <span class='MathJax_Preview'>\([{\alpha ^*},b]\)</span><script type='math/tex'>[{\alpha ^*},b]</script> 上严格单调增，则称 <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 是 <span class='MathJax_Preview'>\(f(\alpha )\)</span><script type='math/tex'>f(\alpha )</script> 的单峰区间，  <span class='MathJax_Preview'>\(f(\alpha )\)</span><script type='math/tex'>f(\alpha )</script> 是 <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 上的单峰函数。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a>&#8230; <a href="https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2%e4%b8%ad%e7%9a%84%e5%88%92%e7%95%8cbracket%e7%ae%97%e6%b3%95/" class="read-more">Read More </a></p>]]></description>
										<content:encoded><![CDATA[<p>
很多最优化算法需要用到一维搜索（line search）子算法，而在众多的一维搜索算法中，大多数都要求函数被限制在一个<span style="color:#0000ff;">单峰区间</span>内，也就是说，在进行一维搜索的区间内，函数是一个<span style="color:#0000ff;">单峰函数</span>。尽管有一些改进的一维搜索算法（例如 <span class='MathJax_Preview'>\(H\ddot opfinger\)</span><script type='math/tex'>H\ddot opfinger</script> 建议的一种改进过的黄金搜索算法）可以处理函数非单峰的情况，但是，在没有确定函数在一个区间内是单峰的之前，即使在搜索过程中，函数值持续减小，我们也不能说极小值是一定存在的，因此，找出一个区间，在此区间之内使函数是单峰的，这个过程是必需的（我更倾向于接受这种观点）。这个过程就叫作<span style="color:#ff0000;">划界</span>（<span style="color:#0000ff;">Bracket</span>）。Bracket这个单词是括号的意思，很形象&mdash;&mdash;用括号包住一个范围，就是划界。在某些书中，划界算法也被称为<span style="color:#0000ff;">进退法</span>。<br />
<span id="more-7360"></span><br />
<span style="background-color:#00ff00;">【1】</span>什么是单峰区间？什么是单峰函数？<br />
从字面上理解，&ldquo;单峰&rdquo;即函数只有一个峰，如下图所示（在区间[-8,8]内是单峰的）：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_1.png" style="width: 309px; height: 153px;" /></div>
<p><span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
而下面的这个函数，在区间[2,14]内就不是单峰函数了：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_2.png" style="width: 462px; height: 129px;" /></div>
<p>现在，我们再用数学的话来定义一下单峰区间和单峰函数：<br />
 <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 为 <span class='MathJax_Preview'>\(R\)</span><script type='math/tex'>R</script> 的子集，存在 <span class='MathJax_Preview'>\({\alpha ^*} \in [a,b]\)</span><script type='math/tex'>{\alpha ^*} \in [a,b]</script> ，使得 <span class='MathJax_Preview'>\(f(\alpha )\)</span><script type='math/tex'>f(\alpha )</script> 在 <span class='MathJax_Preview'>\([a,{\alpha ^*}]\)</span><script type='math/tex'>[a,{\alpha ^*}]</script> 上严格单调减，在 <span class='MathJax_Preview'>\([{\alpha ^*},b]\)</span><script type='math/tex'>[{\alpha ^*},b]</script> 上严格单调增，则称 <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 是 <span class='MathJax_Preview'>\(f(\alpha )\)</span><script type='math/tex'>f(\alpha )</script> 的单峰区间，  <span class='MathJax_Preview'>\(f(\alpha )\)</span><script type='math/tex'>f(\alpha )</script> 是 <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 上的单峰函数。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
<span style="background-color: rgb(0, 255, 0);">【2】</span>&ldquo;划界&rdquo;是如何实现的<br />
方法是：<span style="color:#0000ff;">寻找使函数值达到&ldquo;高&rarr;低&rarr;高&rdquo;的3个点</span>。</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_3.png" style="width: 300px; height: 153px;" /></div>
<p>如上图所示，当我们找到 <span class='MathJax_Preview'>\(a,b,c\)</span><script type='math/tex'>a,b,c</script> 这样3个点的时候，它们就能确定一个单峰区间了。<br />
一定有人会有疑问说：这不一定，万一 <span class='MathJax_Preview'>\(b,c\)</span><script type='math/tex'>b,c</script> 之间还有一个峰怎么办？确实，这里举的例子并不是一个完善的例子，在一个实用的划界程序中，它所做的考虑会非常多，各种意外情况都要处理，此处只是为了说明&ldquo;划界&rdquo;是怎么一回事，以及一个最简单的划界程序是怎么做的。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
与各种教科书上仅有令人讨厌的公式说明不同（从不考虑读者的感受），我把几个简单的划界步骤画成了几幅图，我觉得有小学文凭已经足够理解了（一图胜千言）：<br />
<span style="background-color:#dda0dd;">①</span>：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_4.png" style="width: 400px; height: 255px;" /></div>
<p><span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
起始点为 <span class='MathJax_Preview'>\({x_0}\)</span><script type='math/tex'>{x_0}</script> ，假设一开始向右寻找，步长为 <span class='MathJax_Preview'>\(h\)</span><script type='math/tex'>h</script> ，图中的 <span class='MathJax_Preview'>\(k\)</span><script type='math/tex'>k</script> 表示迭代的次数。<br />
则第一点挪动到了 <span class='MathJax_Preview'>\({x_1} = {x_0} + h\)</span><script type='math/tex'>{x_1} = {x_0} + h</script> ，计算函数值，发现 <span class='MathJax_Preview'>\(f({x_1}) < f({x_0})\)</span><script type='math/tex'>f({x_1}) < f({x_0})</script> ，很好，&ldquo;高&rarr;低&rarr;高&rdquo;的3点中，我们已经有了两点。<br />
然后下一点我们挪动到 <span class='MathJax_Preview'>\({x_2} = {x_1} + t \times h,\;t > 1\)</span><script type='math/tex'>{x_2} = {x_1} + t \times h,\;t > 1</script> ，这里用加倍系数 <span class='MathJax_Preview'>\(t\)</span><script type='math/tex'>t</script> 来乘以步长是为了加速搜索的过程。再计算函数值，发现 <span class='MathJax_Preview'>\(f({x_2}) > f({x_1})\)</span><script type='math/tex'>f({x_2}) > f({x_1})</script> ，很好，我们已经找到了&ldquo;高&rarr;低&rarr;高&rdquo;的3点。任务完成， <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 即为所求区间。<br />
总结一下步骤就是：<br />
 <span class='MathJax_Preview'>\({x_1} = {x_0} + h\)</span><script type='math/tex'>{x_1} = {x_0} + h</script> <br />
 <span class='MathJax_Preview'>\({x_2} = {x_1} + t \times h\)</span><script type='math/tex'>{x_2} = {x_1} + t \times h</script> <br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
<span style="background-color:#dda0dd;">②</span>：<br />
如果运气没那么好，例如：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_5.png" style="width: 400px; height: 258px;" /></div>
<p><span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
即：<br />
和①一样，搜索也经历了 <span class='MathJax_Preview'>\({x_0},{x_1},{x_2}\)</span><script type='math/tex'>{x_0},{x_1},{x_2}</script> 这几个点，与①不同的是，到了 <span class='MathJax_Preview'>\({x_2}\)</span><script type='math/tex'>{x_2}</script> 点之后，我们发现其函数值仍然小于 <span class='MathJax_Preview'>\({x_1}\)</span><script type='math/tex'>{x_1}</script> 点处的函数值，也就是说，我们还没有找到&ldquo;高&rarr;低&rarr;高&rdquo;的3点。<br />
于是我们继续放大步长，令 <span class='MathJax_Preview'>\({x_3} = {x_2} + t \times t \times h\)</span><script type='math/tex'>{x_3} = {x_2} + t \times t \times h</script> ，再计算函数值，发现 <span class='MathJax_Preview'>\(f({x_3}) > f({x_2})\)</span><script type='math/tex'>f({x_3}) > f({x_2})</script> ，很好，我们已经找到了&ldquo;高&rarr;低&rarr;高&rdquo;的3点。任务完成， <span class='MathJax_Preview'>\([a,b]\)</span><script type='math/tex'>[a,b]</script> 即为所求区间。<br />
总结一下步骤就是：<br />
 <span class='MathJax_Preview'>\({x_1} = {x_0} + h\)</span><script type='math/tex'>{x_1} = {x_0} + h</script> <br />
 <span class='MathJax_Preview'>\({x_2} = {x_1} + t \times h\)</span><script type='math/tex'>{x_2} = {x_1} + t \times h</script> （加大步长）<br />
 <span class='MathJax_Preview'>\({x_3} = {x_2} + t \times t \times h\)</span><script type='math/tex'>{x_3} = {x_2} + t \times t \times h</script> （继续加大步长）<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
<span style="background-color: rgb(221, 160, 221);">③</span>：<br />
①是向右搜索，如果我们运气更差一些，一开始就是个错误（应该向左搜索），怎么办？</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_6.png" style="width: 400px; height: 256px;" /></div>
<p><span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
如上图，起始点为 <span class='MathJax_Preview'>\({x_0}\)</span><script type='math/tex'>{x_0}</script> ，第一个挪动到的点起始点为 <span class='MathJax_Preview'>\({x_1}\)</span><script type='math/tex'>{x_1}</script> ，而 <span class='MathJax_Preview'>\({x_1}\)</span><script type='math/tex'>{x_1}</script> 处的函数值竟然比起始点 <span class='MathJax_Preview'>\({x_0}\)</span><script type='math/tex'>{x_0}</script> 处的函数值要大（函数值不降反升）。于是我们可以向左搜索（将步长 <span class='MathJax_Preview'>\(h\)</span><script type='math/tex'>h</script> 设为负值），并且把 <span class='MathJax_Preview'>\({x_1}\)</span><script type='math/tex'>{x_1}</script> 挪到 <span class='MathJax_Preview'>\({x_0}\)</span><script type='math/tex'>{x_0}</script> ，继续按①的节奏进行下去。<br />
总结一下步骤就是：<br />
 <span class='MathJax_Preview'>\({x_1} = {x_0} + h\)</span><script type='math/tex'>{x_1} = {x_0} + h</script> （发现函数值不降反升）<br />
 <span class='MathJax_Preview'>\(h' = - h\)</span><script type='math/tex'>h' = - h</script> （步长设为负值，向左搜索）<br />
 <span class='MathJax_Preview'>\({x_1} = {x_0}\)</span><script type='math/tex'>{x_1} = {x_0}</script> （重置 <span class='MathJax_Preview'>\({x_1}\)</span><script type='math/tex'>{x_1}</script> 点）<br />
 <span class='MathJax_Preview'>\({x_2} = {x_1} + h'\)</span><script type='math/tex'>{x_2} = {x_1} + h'</script> <br />
 <span class='MathJax_Preview'>\({x_3} = {x_2} + t \times h'\)</span><script type='math/tex'>{x_3} = {x_2} + t \times h'</script> （加大步长，函数值回升，停止搜索）<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
<span style="background-color: rgb(0, 255, 0);">【3】</span>加快划界的速度：逆抛物内插<br />
有没有什么办法可以加快划界的速度呢？有，<span style="color:#ff0000;">逆抛物内插</span>（<span style="color:#0000ff;">Inverse Parabolic Interpolation</span>）就是一种技术，它可以使得划界算法<span style="color:#0000ff;">超线性收敛</span>。<br />
为了解释什么是逆抛物内插，这里用书上的一幅图来讲解：</p>
<div style="text-align: center;">
	<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_7.png" style="width: 450px; height: 322px;" /></div>
<p><span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
如图，实线为目标函数曲线。在该曲线上，如果我们要尽快逼近极小值点，可以这样做：通过①②③三点作一条抛物线（图中粗虚线所示），可以计算出该抛物线的极小值点的<span style="color:#b22222;">横坐标</span>，从而可以找到同一横坐标下，目标函数上的点，即点④；然后再过①②④三点作一条抛物线（图中细虚线所示），可以计算出该抛物线的极小值点的横坐标，从而又可以找到同一横坐标下，目标函数上的点，即点⑤。这样，我们就很快地逼近了极小值。</p>
<p>那么，过三点的抛物线，其极小值点的横坐标怎么求？<br />
已知函数 <span class='MathJax_Preview'>\(f(x)\)</span><script type='math/tex'>f(x)</script> ，过 <span class='MathJax_Preview'>\(f(a),f(b),f(c)\)</span><script type='math/tex'>f(a),f(b),f(c)</script> 三点的抛物线，其极小值点的横坐标 <span class='MathJax_Preview'>\(x\)</span><script type='math/tex'>x</script> 为：<br />
<img decoding="async" alt="" src="http://www.codelast.com/wp-content/uploads/ckfinder/images/optimization_bracket_8.png" style="width: 550px; height: 74px;" /><br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
注：为什么叫&ldquo;<span style="color:#ff0000;">逆</span>&rdquo;？因为上面的方法是用来求横坐标 <span class='MathJax_Preview'>\(x\)</span><script type='math/tex'>x</script> ，而不是求 <span class='MathJax_Preview'>\(y\)</span><script type='math/tex'>y</script> 的。</p>
<p>有人会问：划界的目标就是找到3个点，而你怎么会预先知道3个点的坐标，从而进行逆抛物内插？这不是因果倒置了吗？<br />
其实，这里的三个点，并不是划界的结果，而是初始的猜测，通过初始的猜测点进行逆抛物内插，再根据内插点的不同情况，分别作不同的处理，最终可以找到划界的3个点。<br />
例如，我们总要知道两个初始点 <span class='MathJax_Preview'>\(a,b\)</span><script type='math/tex'>a,b</script> 吧？好吧，如果你已知的真的只有一个点 <span class='MathJax_Preview'>\(a\)</span><script type='math/tex'>a</script> ，那么 <span class='MathJax_Preview'>\(b\)</span><script type='math/tex'>b</script> 就随便取比 <span class='MathJax_Preview'>\(a\)</span><script type='math/tex'>a</script> 大一点的值好了，这也能凑够两个点啊。通过这两个点，可以通过 <span class='MathJax_Preview'>\(c = b + COE \times (b - a)\)</span><script type='math/tex'>c = b + COE \times (b - a)</script> 来得到猜测的第一个 <span class='MathJax_Preview'>\(c\)</span><script type='math/tex'>c</script> 点（这里的 <span class='MathJax_Preview'>\(COE\)</span><script type='math/tex'>COE</script> 表示一个系数，例如1.618），从而可以通过这3点开始逆抛物内插。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" target="_blank" rel="noopener noreferrer"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
一个实用的划界程序还是挺复杂的&mdash;&mdash;这里的复杂是比较于上面陈述的最简单的划界算法来说的，因为要保证程序在很多&ldquo;意外情况&rdquo;下都能正确运行，必须做很多工作。这里就不分析具体的程序了，大家可以到网上找来看一下。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">https://www.codelast.com/</span></a><br />
<span style="color: rgb(255, 0, 0);">➤➤</span>&nbsp;版权声明&nbsp;<span style="color: rgb(255, 0, 0);">➤➤</span>&nbsp;<br />
转载需注明出处：<u><a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><em><span style="color: rgb(0, 0, 255);"><strong style="font-size: 16px;"><span style="font-family: arial, helvetica, sans-serif;">codelast.com</span></strong></span></em></a></u>&nbsp;<br />
感谢关注我的微信公众号（微信扫一扫）：</p>
<p style="border: 0px; font-size: 13px; margin: 0px 0px 9px; outline: 0px; padding: 0px; color: rgb(77, 77, 77);">
	<img decoding="async" alt="wechat qrcode of codelast" src="https://www.codelast.com/codelast_wechat_qr_code.jpg" style="width: 200px; height: 200px;" /></p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.codelast.com/%e5%8e%9f%e5%88%9b%e4%b8%80%e7%bb%b4%e6%90%9c%e7%b4%a2%e4%b8%ad%e7%9a%84%e5%88%92%e7%95%8cbracket%e7%ae%97%e6%b3%95/feed/</wfw:commentRss>
			<slash:comments>3</slash:comments>
		
		
			</item>
	</channel>
</rss>
