<?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%BA%A4%E5%8F%89%E7%86%B5/feed/" rel="self" type="application/rss+xml" />
	<link>https://www.codelast.com</link>
	<description>最优化之路</description>
	<lastBuildDate>Mon, 27 Apr 2020 16:54:16 +0000</lastBuildDate>
	<language>zh-Hans</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=6.9.4</generator>
	<item>
		<title>[原创] 用人话解释机器学习中的Logistic Regression（逻辑回归）</title>
		<link>https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e7%94%a8%e4%ba%ba%e8%af%9d%e8%a7%a3%e9%87%8a%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0%e4%b8%ad%e7%9a%84logistic-regression%ef%bc%88%e9%80%bb%e8%be%91%e5%9b%9e%e5%bd%92%ef%bc%89/</link>
					<comments>https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e7%94%a8%e4%ba%ba%e8%af%9d%e8%a7%a3%e9%87%8a%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0%e4%b8%ad%e7%9a%84logistic-regression%ef%bc%88%e9%80%bb%e8%be%91%e5%9b%9e%e5%bd%92%ef%bc%89/#comments</comments>
		
		<dc:creator><![CDATA[learnhard]]></dc:creator>
		<pubDate>Fri, 19 Feb 2016 08:47:08 +0000</pubDate>
				<category><![CDATA[Algorithm]]></category>
		<category><![CDATA[Math]]></category>
		<category><![CDATA[原创]]></category>
		<category><![CDATA[cross entropy]]></category>
		<category><![CDATA[Logistic Regression]]></category>
		<category><![CDATA[Logit Regression]]></category>
		<category><![CDATA[machine learning]]></category>
		<category><![CDATA[optimization]]></category>
		<category><![CDATA[交叉熵]]></category>
		<category><![CDATA[最优化]]></category>
		<category><![CDATA[机器学习]]></category>
		<category><![CDATA[逻辑回归]]></category>
		<guid isPermaLink="false">http://www.codelast.com/?p=8629</guid>

					<description><![CDATA[<p>友情提示：如果觉得页面中的公式显示太小，可以放大页面查看（不会失真）。</p>
<p><span style="color:#0000ff;">Logistic Regression</span>（或<span style="color:#0000ff;">Logit Regression</span>），即<span style="color:#0000ff;">逻辑回归</span>，简记为<span style="color:#0000ff;">LR</span>，是机器学习领域的一种极为常用的算法／方法／模型。<br />
你能从网上搜到十万篇讲述Logistic Regression的文章，也不多我这一篇，但是，就像我写过的<a href="http://www.codelast.com/?p=7364" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">最优化系列文章</span></a>一样，我仍然试图用&#8220;人话&#8221;来再解释一遍&#8212;&#8212;可能不专业，但是容易看得懂。那些一上来就是几页数学公式什么的最讨厌了，不是吗？<br />
所以这篇文章是写给完全没听说过Logistic Regression的人看的，我相信看完这篇文章，你差不多可以从无到有，把逻辑回归应用到实践中去。<br />
<span id="more-8629"></span><br />
Logistic Regression是一种<span style="color:#0000ff;">分类</span>算法。分类，也就是把一个群体（或问题，或数据）分为几个类别，例如，男/女/人妖；爱她的人/不爱她的人；今天会下雨/今天不会下雨。<br />
Logistic Regression最常用于处理&#8220;<span style="color:#0000ff;">二分类</span>&#8221;问题，也就是说分类只有两个，像&#8220;爱她的人/不爱她的人&#8221;就是二分类，而&#8220;男/女/人妖&#8221;就不是二分类。当然，Logistic Regression也可以用于处理多分类问题，即所谓的&#8220;<span style="color:#800080;">多分类逻辑回归</span>&#8221;（<span style="color:#b22222;">Multiclass Logistic Regression</span>），但本文并不涉及这个方面。<br />
所以，说得简单点就是，给你一条数据，用Logistic Regression可以判断出这条数据应该被分到两个类别中的哪个中去。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
Logistic Regression在现实世界中非常有用。例如，可以用它来判断一个用户是否会点击一个广告（会点击／不会点击），可以用Logistic Regression来判断两类人是否会相爱（会相爱／不会相爱），等等。</p>
<p>机器学习的主旨就是通过对历史数据的计算（即&#8220;学习&#8221;），得到一些未知参数的值，从而可以推断出新数据会有什么结论。例如一个非常简单的函数： <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0fdb61c8abfb7bfd67516c1f8c8055b2.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = ax + b" /></span><script type='math/tex'>y = ax + b</script> ，在已知几组  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_90cbc22edf225adf8a68974f51227f05.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="(x,y)" /></span><script type='math/tex'>(x,y)</script>  历史数据的情况下：</p>
<div>
<blockquote>
<div>
			(1, 5.5)<br />
			(1.5, 7)<br />
			(2, 6.5)</div>
</blockquote>
<p>	我们怎样能够预测一个未知的自变量  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_4c63f2fd29fec6c20010a36949e9752d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="x = 3" /></span><script type='math/tex'>x = 3</script>  会对应什么样的因变量&#160; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_415290769594460e2e485922904f345d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y" /></span><script type='math/tex'>y</script>  呢？也就是说， <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_4c63f2fd29fec6c20010a36949e9752d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="x = 3" /></span><script type='math/tex'>x = 3</script>  时&#160; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_232ec2a90bc0ab9fb1a405d8ffe47582.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = ?" /></span><script type='math/tex'>y = ?</script></p></div>&#8230; <a href="https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e7%94%a8%e4%ba%ba%e8%af%9d%e8%a7%a3%e9%87%8a%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0%e4%b8%ad%e7%9a%84logistic-regression%ef%bc%88%e9%80%bb%e8%be%91%e5%9b%9e%e5%bd%92%ef%bc%89/" class="read-more">Read More </a>]]></description>
										<content:encoded><![CDATA[<p>友情提示：如果觉得页面中的公式显示太小，可以放大页面查看（不会失真）。</p>
<p><span style="color:#0000ff;">Logistic Regression</span>（或<span style="color:#0000ff;">Logit Regression</span>），即<span style="color:#0000ff;">逻辑回归</span>，简记为<span style="color:#0000ff;">LR</span>，是机器学习领域的一种极为常用的算法／方法／模型。<br />
你能从网上搜到十万篇讲述Logistic Regression的文章，也不多我这一篇，但是，就像我写过的<a href="http://www.codelast.com/?p=7364" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">最优化系列文章</span></a>一样，我仍然试图用&ldquo;人话&rdquo;来再解释一遍&mdash;&mdash;可能不专业，但是容易看得懂。那些一上来就是几页数学公式什么的最讨厌了，不是吗？<br />
所以这篇文章是写给完全没听说过Logistic Regression的人看的，我相信看完这篇文章，你差不多可以从无到有，把逻辑回归应用到实践中去。<br />
<span id="more-8629"></span><br />
Logistic Regression是一种<span style="color:#0000ff;">分类</span>算法。分类，也就是把一个群体（或问题，或数据）分为几个类别，例如，男/女/人妖；爱她的人/不爱她的人；今天会下雨/今天不会下雨。<br />
Logistic Regression最常用于处理&ldquo;<span style="color:#0000ff;">二分类</span>&rdquo;问题，也就是说分类只有两个，像&ldquo;爱她的人/不爱她的人&rdquo;就是二分类，而&ldquo;男/女/人妖&rdquo;就不是二分类。当然，Logistic Regression也可以用于处理多分类问题，即所谓的&ldquo;<span style="color:#800080;">多分类逻辑回归</span>&rdquo;（<span style="color:#b22222;">Multiclass Logistic Regression</span>），但本文并不涉及这个方面。<br />
所以，说得简单点就是，给你一条数据，用Logistic Regression可以判断出这条数据应该被分到两个类别中的哪个中去。<br />
<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
Logistic Regression在现实世界中非常有用。例如，可以用它来判断一个用户是否会点击一个广告（会点击／不会点击），可以用Logistic Regression来判断两类人是否会相爱（会相爱／不会相爱），等等。</p>
<p>机器学习的主旨就是通过对历史数据的计算（即&ldquo;学习&rdquo;），得到一些未知参数的值，从而可以推断出新数据会有什么结论。例如一个非常简单的函数： <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0fdb61c8abfb7bfd67516c1f8c8055b2.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = ax + b" /></span><script type='math/tex'>y = ax + b</script> ，在已知几组  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_90cbc22edf225adf8a68974f51227f05.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="(x,y)" /></span><script type='math/tex'>(x,y)</script>  历史数据的情况下：</p>
<div>
<blockquote>
<div>
			(1, 5.5)<br />
			(1.5, 7)<br />
			(2, 6.5)</div>
</blockquote>
<p>	我们怎样能够预测一个未知的自变量  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_4c63f2fd29fec6c20010a36949e9752d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="x = 3" /></span><script type='math/tex'>x = 3</script>  会对应什么样的因变量&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_415290769594460e2e485922904f345d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y" /></span><script type='math/tex'>y</script>  呢？也就是说， <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_4c63f2fd29fec6c20010a36949e9752d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="x = 3" /></span><script type='math/tex'>x = 3</script>  时&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_232ec2a90bc0ab9fb1a405d8ffe47582.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = ?" /></span><script type='math/tex'>y = ?</script> <br />
	显然我们的任务就是计算出两个未知参数&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0cc175b9c0f1b6a831c399e269772661.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="a" /></span><script type='math/tex'>a</script>  和&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_92eb5ffee6ae2fec3ad71c777531578f.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="b" /></span><script type='math/tex'>b</script>  的值，有了这两个值，那么任意给定一个&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_9dd4e461268c8034f5c8564e155c67a6.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="x" /></span><script type='math/tex'>x</script> ，我们都能通过函数&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0fdb61c8abfb7bfd67516c1f8c8055b2.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = ax + b" /></span><script type='math/tex'>y = ax + b</script>  计算出&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_415290769594460e2e485922904f345d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y" /></span><script type='math/tex'>y</script>  的值了，这就是所谓的&ldquo;预测&rdquo;。<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
	Logistic Regression也是类似，我们有一个函数  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_d19546fa62d4242fb94dd1e54f1497ec.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = f(X)" /></span><script type='math/tex'>y = f(X)</script> ，里面包含若干个未知参数  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_600c746b4b1e96f24bf5e68ffdd17c32.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{\theta _0},{\theta _1},{\theta _2}, \cdots ,{\theta _n}" /></span><script type='math/tex'>{\theta _0},{\theta _1},{\theta _2}, \cdots ,{\theta _n}</script> 。<br />
	由于现实世界是复杂的，因变量&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_415290769594460e2e485922904f345d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y" /></span><script type='math/tex'>y</script>  通常会跟很多因素（自变量  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_9dd4e461268c8034f5c8564e155c67a6.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="x" /></span><script type='math/tex'>x</script> ）有关系，即&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_51e1680e3df2c1a03394b225f5754880.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{x_0},{x_1},{x_2}, \cdots ,{x_n}" /></span><script type='math/tex'>{x_0},{x_1},{x_2}, \cdots ,{x_n}</script> ，所以这里自变量是一个<span style="color:#0000ff;">向量</span>，这里用大写的  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_02129bb861061d1a052c592e2dc6b383.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="X" /></span><script type='math/tex'>X</script>  来表示。同理，那一堆未知的参数也是一个向量，用一个字母  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script>  来表示。<br />
	现在给我们一堆 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_90cbc22edf225adf8a68974f51227f05.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="(x,y)" /></span><script type='math/tex'>(x,y)</script> 的历史数据，我们要想办法计算出所有未知参数的值，然后就可以拿来预测新的&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_9dd4e461268c8034f5c8564e155c67a6.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="x" /></span><script type='math/tex'>x</script>  值所对应的&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_415290769594460e2e485922904f345d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y" /></span><script type='math/tex'>y</script>  值了。<br />
	但是这个函数是什么呢？如下：<br />
	<span style="color:#0000ff;"> <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_d75712642d3eb1dbfc0bc0718cdfb7cd.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="f(X) = \frac{1}{{1 + {e^{ - {\theta ^T}X}}}}{\rm{ }}" /></span><script type='math/tex'>f(X) = \frac{1}{{1 + {e^{ - {\theta ^T}X}}}}{\rm{ }}</script> </span> <span style="color:#ff0000;">&hellip;&hellip;（1）</span><br />
	其中， <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script>  是参数向量， <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_02129bb861061d1a052c592e2dc6b383.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="X" /></span><script type='math/tex'>X</script>  是自变量（向量）。<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
	那么，这个略显奇怪的函数是怎么来的呢？<br />
	首先我们看  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_7214334e01f01d7c5648efcd790e4631.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{{\theta ^T}X}" /></span><script type='math/tex'>{{\theta ^T}X}</script>  这部分：这是参数向量与自变量（向量）的<a href="https://zh.wikipedia.org/wiki/%E6%95%B0%E9%87%8F%E7%A7%AF" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">点积</span></a>，这个式子想要表达的含义是：计算某个事件发生的可能性，可以把跟这个事件相关的所有特征加权求和。例如，要求今天下雨的可能性，可以把今天所有和下雨相关的概率加权求和，例如梅雨季节权重为9（每天都很可能下雨），有台风经过权重为6，等等，每一个因素都影响着&ldquo;下雨的可能性&rdquo;，即：<br />
	 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_bbeb4b1d67260873773804370090ce01.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="s = \sum\limits_{i = 0}^n {{\theta _i}{x_i}} = {\theta _0}{x_0} + {\theta _1}{x_1} + \cdots + {\theta _n}{x_n} = {\theta ^T}X" /></span><script type='math/tex'>s = \sum\limits_{i = 0}^n {{\theta _i}{x_i}} = {\theta _0}{x_0} + {\theta _1}{x_1} + \cdots + {\theta _n}{x_n} = {\theta ^T}X</script> <br />
	但是这个加权求和的结果是在  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_d0b6f29f7312261c6da8700518a6a27e.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="( - \infty , + \infty )" /></span><script type='math/tex'>( - \infty , + \infty )</script>  范围内的，为了能表示预测的概率，我们希望把输出值限制在  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_b6dbc33006b907f2db1855810abfce98.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="(0,1)" /></span><script type='math/tex'>(0,1)</script>  之间，而不是&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_d0b6f29f7312261c6da8700518a6a27e.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="( - \infty , + \infty )" /></span><script type='math/tex'>( - \infty , + \infty )</script> 。所以，这时，<span style="color: rgb(0, 0, 255);">逻辑函数</span>就出场了。</div>
<div>
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
	通过<a href="https://zh.wikipedia.org/wiki/%E9%82%8F%E8%BC%AF%E5%87%BD%E6%95%B8" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">这个WiKi页面</span></a>你可以知道，其实所谓的<span style="color:#0000ff;">逻辑函数</span>，就是这样的一个函数：<br />
	 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_88b4cd1dcd65e1f12fe0d827ba791108.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="P(t) = \frac{1}{{1 + {e^{ - t}}}}" /></span><script type='math/tex'>P(t) = \frac{1}{{1 + {e^{ - t}}}}</script> <br />
	这个函数是由 Pierre Fran&ccedil;ois Verhulst（皮埃尔&middot;弗朗索瓦&middot;韦吕勒）在1844～1845年的时候给它起的名字。而我们上面的函数(1)，就是这个形式。<br />
	逻辑函数的图像是这个样子的：<br />
	<img decoding="async" alt="logistic function" src="https://www.codelast.com/wp-content/uploads/2016/01/logistic_function.png" style="width: 517px; height: 273px;" /><br />
	它的函数值刚好就是在(0,1)之间。<br />
	所以，我们通过逻辑函数，就可以计算出一个事件的概率了（(0,1)之间）。但是不要忘了，我们前面说要处理二分类问题，得到一个(0,1)之间的任意值并不能归到两个分类中的一个里去，所以还要把这个概率值&ldquo;归类&rdquo;。其实这里很简单，我们可以在&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_4b8d6a6375fd790e922b90da0ecd933d.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="f(X) > 0.5" /></span><script type='math/tex'>f(X) > 0.5</script> &nbsp;的时候，把它归到类别1中， <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_224bae9043a536776b0b33751b1b72b0.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="f(X) \le 0.5" /></span><script type='math/tex'>f(X) \le 0.5</script> &nbsp;的时候，把它归到类别2中就可以了（概率值的&ldquo;分水岭&rdquo;可以根据实际情况调整）。用数学公式来表达这段话的含义就是：</p>
<div>
		 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_fd236b87dd9852ea434e65a277b2398c.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y' = \left\{ {\begin{array}{*{20}{c}}{0,f(X) > 0.5}\\{1,f(X) \le 0.5}\end{array}} \right." /></span><script type='math/tex'>y' = \left\{ {\begin{array}{*{20}{c}}{0,f(X) > 0.5}\\{1,f(X) \le 0.5}\end{array}} \right.</script> </div>
<p>
	在各种机器学习的文章中，你都会看到，它们给了逻辑函数一个常用的名字：<span style="color:#0000ff;">Sigmoid函数</span>。sigmoid，意为&ldquo;S形的&rdquo;，这正符合其函数图像特点，所以大家记住就行了。<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
	现在，我们已经有了函数，下一步任务就是求出函数表达式中的未知参数向量  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script>  了。这个过程是机器学习中最为核心的计算步骤。<br />
	以前面讲过的函数  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0fdb61c8abfb7bfd67516c1f8c8055b2.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = ax + b" /></span><script type='math/tex'>y = ax + b</script> &nbsp;为例：<br />
	你会发现，当已知几组  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_90cbc22edf225adf8a68974f51227f05.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="(x,y)" /></span><script type='math/tex'>(x,y)</script> &nbsp;数据的情况下：</p>
<blockquote><p>
		(1, 5.5)<br />
		(1.5, 7)<br />
		(2, 6.5)</p></blockquote>
<p>	你无论如何也不可能找到一对  <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0cc175b9c0f1b6a831c399e269772661.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="a" /></span><script type='math/tex'>a</script>  和&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_92eb5ffee6ae2fec3ad71c777531578f.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="b" /></span><script type='math/tex'>b</script>  的值，使得以上3组数据能精确地满足方程&nbsp;&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0fdb61c8abfb7bfd67516c1f8c8055b2.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="y = ax + b" /></span><script type='math/tex'>y = ax + b</script> ，正如下面的图像所示：<br />
	<img decoding="async" alt="logistic function" src="https://www.codelast.com/wp-content/uploads/2016/01/ax_b.png" style="width: 1010px; height: 234px;" /></p>
<p>	这条直线如果要精确地通过其中的两个点，那么就不能通过第三个点。所以，最终求出来的&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0cc175b9c0f1b6a831c399e269772661.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="a" /></span><script type='math/tex'>a</script>  和&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_92eb5ffee6ae2fec3ad71c777531578f.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="b" /></span><script type='math/tex'>b</script>  的值，并不是方程的<a href="https://zh.wikipedia.org/wiki/%E8%A7%A3%E6%9E%90%E8%A7%A3" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">解析解</span></a>，而是&ldquo;<span style="color:#0000ff;">最优解</span>&rdquo;。<br />
	因此，问题在于，我们如何画一条直线，使得其是&ldquo;最优&rdquo;的？&ldquo;最优&rdquo;的评判标准是什么？<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
	为了理解&ldquo;最优&rdquo;，我们需要先了解一些概念。</p>
<ul>
<li>
			<span style="color:#0000ff;">损失函数</span>／<span style="color: rgb(0, 0, 255);">Loss Function</span>／<span style="color: rgb(0, 0, 255);">代价函数</span>／<span style="color: rgb(0, 0, 255);">Cost Function</span></li>
</ul>
</div>
<div>
	很多文章说，这几个名词的含义是一样的。但是也有文章说，Loss Function和Cost Function不是一回事，例如<a href="http://image.diku.dk/shark/sphinx_pages/build/html/rest_sources/tutorials/concepts/library_design/losses.html" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">这篇</span></a>文章。但通常认为，这二者是一回事。我觉得嘛，大家就按通常的概念来接受就好了。<br />
	按<a href="https://en.wikipedia.org/wiki/Loss_function" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">WiKi</span></a>的定义：</div>
<blockquote>
<div>
		In mathematical optimization, statistics, decision theory and machine learning, a loss function or cost function is a function that maps an event or values of one or more variables onto a real number intuitively representing some &quot;cost&quot; associated with the event. An optimization problem seeks to minimize a loss function.</div>
</blockquote>
<div>
	以及：</div>
<blockquote>
<div>
		The loss function quantifies the amount by which the prediction deviates from the actual values.</div>
</blockquote>
<div>
	我们可以知道，损失函数用于衡量预测值与实际值的偏离程度，如果预测是完全精确的，则损失函数值为0；如果损失函数值不为0，则其表示的是预测的错误有多糟糕。使得损失函数值最小的那些待求参数值，就是&ldquo;最优&rdquo;的参数值。<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
	所以现在问题来了，损失函数的表达式又是什么？<br />
	在探讨损失函数的表达式之前，我们先来看一下损失函数有哪些种类。<br />
	损失函数有很多种，例如下面几个：<br />
	<span style="background-color:#dda0dd;">（1）</span>0-1损失函数：可用于<span style="color:#0000ff;">分类</span>问题，即该函数用于衡量<span style="color:#0000ff;">分类错误</span>的数量，但由于此损失函数是非凸（non-convex）的，因此在做最优化计算时，难以求解，所以，正因为如此，0-1损失函数不是那么&ldquo;实用&rdquo;（如果这句话有误，请指正）。<br />
	<span style="background-color:#dda0dd;">（2）</span>平方损失函数（Square Loss）：常用于线性回归（Linear Regression）。<br />
	<span style="background-color:#dda0dd;">（3）</span>对数损失（Log Loss）函数：常用于其模型输出每一类概率的分类器（classifier），例如逻辑回归。<br />
	<span style="background-color:#dda0dd;">（4）</span>Hinge损失函数：常用于SVM（Support Vector Machine，支持向量机，一种机器学习算法）。中文名叫&ldquo;<span style="color:#0000ff;">合页</span>损失函数&rdquo;，因为hinge有&ldquo;合页&rdquo;之意。这个翻译虽然直白，但是你会发现，99％的文章都不会用它的中文名来称呼它，而是用&ldquo;Hinge损失&rdquo;之类的说法。</p>
<p>	这些都是人们的经验总结，当然，说每一种损失函数常用于什么机器学习算法，也都是有数学依据的。但是在这里，我们讲的是Logistic Regression，所以只看对数损失函数。对数损失函数通常用于衡量分类器（classifier）的精度，这里的&ldquo;分类器&rdquo;也就是指机器学习的模型，它对每一个类别输出一个概率值。从前面的文章中，我们已经知道了，逻辑回归就是这样一种分类器，所以才用对数损失函数来衡量其精度。<br />
	有时候，对数损失函数（Log Loss）也被叫作<span style="color:#0000ff;">交叉熵</span>损失函数（Cross-entropy Loss）。<a href="https://en.wikipedia.org/wiki/Cross_entropy" rel="noopener noreferrer" target="_blank"><span style="color:#0000ff;">交叉熵</span></a>这个名字比较拗口，在信息理论中，<span style="color:#0000ff;">熵</span>用于衡量某种事件的&ldquo;不可预测性&rdquo;，而<span style="color:#0000ff;">交叉熵</span>=事件的真实分布+不可预测性，所以交叉熵可以用于度量两个概率分布（真实分布&amp;预测分布）之间的差异性，即：交叉熵损失函数（对数损失函数）可以衡量一个模型对真实值带来的额外噪音，通过最小化交叉熵损失函数（对数损失函数），我们就可以最大化分类器（模型）的精度。<br />
	上面这一大段话试图用简单的描述让你相信，为什么要用Log Loss来衡量Logistic Regression的误差，但是没有给出证明。有人可能会说，为什么不能用其他的方法来衡量，例如用平方损失函数（Square Loss）。事实上，这是有数学依据的&mdash;&mdash;它会导致损失函数是一个关于参数向量 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> 的<span style="color:#0000ff;">非</span><a href="https://zh.wikipedia.org/wiki/%E5%87%B8%E5%87%BD%E6%95%B0" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">凸函数</span></a>，而用对数损失函数就没有这种问题。凸函数的性质为我们后面求解参数向量 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> 提供了极大便利，非凸函数有很多局部最优解，不利于求解 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> 的计算过程。<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a><br />
	到这里为止，我们还是没有提到损失函数的数学表达式，但是如果要计算损失函数的值，我们是回避不了的，必须要知道。所以，这里用 L 来表示损失函数（取<span style="color: rgb(255, 0, 0);">L</span>oss之意），则对数损失函数的表达式为：<br />
	<span style="color:#0000ff;"> <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_276a829ddba9850126edcea1af119036.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="L = - \frac{1}{n}\sum\limits_{i = 1}^n {[{y_i}\log ({{\hat y}_i}) + (1 - {y_i})\log (1 - {{\hat y}_i})]} " /></span><script type='math/tex'>L = - \frac{1}{n}\sum\limits_{i = 1}^n {[{y_i}\log ({{\hat y}_i}) + (1 - {y_i})\log (1 - {{\hat y}_i})]} </script> </span> <span style="color:#ff0000;">......（2）</span><br />
	其中， <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_eb80f83e86467cf361778c55e850e5e0.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{{y_i}}" /></span><script type='math/tex'>{{y_i}}</script> 是第i个真实值（ <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_64903c82c12bd5f8d201e975ac2c3101.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{y_i} \in \{ 0,1\} " /></span><script type='math/tex'>{y_i} \in \{ 0,1\} </script> ）， <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_e466a7d704ae3cf2e5b7414bbae760ba.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{{{\hat y}_i}}" /></span><script type='math/tex'>{{{\hat y}_i}}</script> 是第i个预测值。<br />
	这个对数损失函数的表达式中并没有出现我们要求解的参数&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> ，所以我们把&nbsp; <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_683296a9a6612653594c598476e669a8.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\hat y = f(X) = \frac{1}{{1 + {e^{ - {\theta ^T}X}}}}" /></span><script type='math/tex'>\hat y = f(X) = \frac{1}{{1 + {e^{ - {\theta ^T}X}}}}</script>  代到（2）式中去：<br />
	 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_961181b6fd923c712b21a4cb9334697a.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="L = - \frac{1}{N}\sum\limits_{i = 1}^n {\left[ {{y_i}\log \left( {\frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right) + (1 - {y_i})\log \left( {1 - \frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right)} \right]} " /></span><script type='math/tex'>L = - \frac{1}{N}\sum\limits_{i = 1}^n {\left[ {{y_i}\log \left( {\frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right) + (1 - {y_i})\log \left( {1 - \frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right)} \right]} </script> <br />
	再来仔细看一下这个式子：N 为数据集的条数（有多少组 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_0340c3897ed6af331d4d59a20946c451.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="(X,y)" /></span><script type='math/tex'>(X,y)</script> ，N就是多少），已知； <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_eb80f83e86467cf361778c55e850e5e0.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{{y_i}}" /></span><script type='math/tex'>{{y_i}}</script>  是真实值，已知； <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_2af46b114c169c94ea9a86ca7b36758b.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="{{X_i}}" /></span><script type='math/tex'>{{X_i}}</script> 是输入的向量，也已知。所以整个式子里只有 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> 是未知的，可以记为 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_bd346812a06f2d43be738a6f13cc17ee.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="L(\theta )" /></span><script type='math/tex'>L(\theta )</script> ，称之为<span style="color:#0000ff;">目标函数</span>：<br />
	 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_ea3fb6a016e9c65dd4bae8aeb9ee1f68.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="L(\theta ) = - \frac{1}{N}\sum\limits_{i = 1}^n {\left[ {{y_i}\log \left( {\frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right) + (1 - {y_i})\log \left( {1 - \frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right)} \right]} " /></span><script type='math/tex'>L(\theta ) = - \frac{1}{N}\sum\limits_{i = 1}^n {\left[ {{y_i}\log \left( {\frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right) + (1 - {y_i})\log \left( {1 - \frac{1}{{1 + {e^{ - {\theta ^T}{X_i}}}}}} \right)} \right]} </script> <br />
	因此，我们只要找到一个参数向量 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> ，能使得此式的值最小，那么这个参数向量 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> 就是&ldquo;最优&rdquo;的参数向量。<br />
	求得了这个最优的 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> 之后，把它代入式（1），则对任一个未知的 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_02129bb861061d1a052c592e2dc6b383.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="X" /></span><script type='math/tex'>X</script> ，我们都可以计算出 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_41c2f2136110516f7d332adc5041b0fe.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="f(X)" /></span><script type='math/tex'>f(X)</script> 值，然后再根据一个阈值把它调整到 0 或 1，就得到了这个 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_02129bb861061d1a052c592e2dc6b383.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="X" /></span><script type='math/tex'>X</script> 所属的分类，这样，我们就完成了一次&ldquo;预测&rdquo;的过程。<br />
	<span style="color: rgb(255, 255, 255);">文章来源：</span><a href="http://www.codelast.com/" rel="noopener noreferrer" target="_blank"><span style="color: rgb(255, 255, 255);">http://www.codelast.com/</span></a></div>
<ul>
<li>
		求解方法</li>
</ul>
<div>
	所以现在问题来了，这个&ldquo;最优&rdquo;的参数向量 <span class='MathJax_Preview'><img src='https://www.codelast.com/wp-content/plugins/latex/cache/tex_50d91f80cbb8feda1d10e167107ad1ff.gif' style='vertical-align: middle; border: none; padding-bottom:2px;' class='tex' alt="\theta " /></span><script type='math/tex'>\theta </script> 怎么求解？<br />
	在大的方向上，你可以选择不使用搜索方向的算法（例如<a href="http://www.codelast.com/?p=7488" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">信赖域算法</span></a>），也可以选择众多使用搜索方向的算法（例如<a href="http://www.codelast.com/?p=8006" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">梯度下降法</span></a>）。<br />
	在是否计算<span style="color:#0000ff;">目标函数</span>的导数这个方面，你可以使用不用求目标函数导数的算法（例如<a href="http://www.codelast.com/?p=388" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">Powell共轭方向集方法</span></a>），也可以使用要求目标函数导数的算法（例如<span style="background-color: rgb(255, 160, 122);"><a href="http://www.codelast.com/?p=8006" rel="noopener noreferrer" target="_blank">梯度下降法</a></span>）。由于某些目标函数形式特别复杂，计算其导数特别麻烦，所以在这种时候，不用计算导数的算法可能大有帮助。</div>
<div>
	求解的过程就是一个<a href="http://www.codelast.com/?p=7364" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">最优化</span></a>的过程，本文无法用一两句话描述清楚，请大家移步链接进行阅读。</p>
<p>	事实上，在现在各种机器学习library百花齐放的今天，我们基本上不需要自己编写这些算法的具体实现，只需要调用它们即可。例如，通过Spark的Machine Learning Library (MLlib)，我们可以直接使用Stochastic gradient descent (SGD)，Limited-memory <a href="http://www.codelast.com/?p=2780" rel="noopener noreferrer" target="_blank"><span style="background-color:#ffa07a;">BFGS</span></a> (L-BFGS)等实现。但是对这背后的原理有所了解，对工作学习是有帮助的。<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-%e7%94%a8%e4%ba%ba%e8%af%9d%e8%a7%a3%e9%87%8a%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0%e4%b8%ad%e7%9a%84logistic-regression%ef%bc%88%e9%80%bb%e8%be%91%e5%9b%9e%e5%bd%92%ef%bc%89/feed/</wfw:commentRss>
			<slash:comments>19</slash:comments>
		
		
			</item>
	</channel>
</rss>
