<?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/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/feed/" rel="self" type="application/rss+xml" />
	<link>https://www.codelast.com</link>
	<description>最优化之路</description>
	<lastBuildDate>Wed, 24 May 2023 09:36:14 +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>[原创] 调戏了一番度娘&quot;最先进&quot;的PLATO-2预训练模型之后，我还是回到了和人类交谈...</title>
		<link>https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e8%b0%83%e6%88%8f%e4%ba%86%e4%b8%80%e7%95%aa%e5%ba%a6%e5%a8%98%e6%9c%80%e5%85%88%e8%bf%9b%e7%9a%84plato-2%e9%a2%84%e8%ae%ad%e7%bb%83%e6%a8%a1%e5%9e%8b%e4%b9%8b%e5%90%8e/</link>
					<comments>https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e8%b0%83%e6%88%8f%e4%ba%86%e4%b8%80%e7%95%aa%e5%ba%a6%e5%a8%98%e6%9c%80%e5%85%88%e8%bf%9b%e7%9a%84plato-2%e9%a2%84%e8%ae%ad%e7%bb%83%e6%a8%a1%e5%9e%8b%e4%b9%8b%e5%90%8e/#comments</comments>
		
		<dc:creator><![CDATA[learnhard]]></dc:creator>
		<pubDate>Mon, 13 Jul 2020 17:35:58 +0000</pubDate>
				<category><![CDATA[Algorithm]]></category>
		<category><![CDATA[原创]]></category>
		<category><![CDATA[综合]]></category>
		<category><![CDATA[NLP]]></category>
		<category><![CDATA[PLATO-2]]></category>
		<category><![CDATA[对话模型]]></category>
		<category><![CDATA[机器学习]]></category>
		<guid isPermaLink="false">https://www.codelast.com/?p=12698</guid>

					<description><![CDATA[<p><img decoding="async" alt="plato-2 network arch" src="https://www.codelast.com/wp-content/uploads/2020/07/plato_2_network_arch.png" style="width: 660px; height: 268px;" /><br />
（莫慌，这图是拿出来撑场面的，我可能和你一样看不懂）</p>
<p>前言：这是一篇很不严肃的实验文章。每一个会修电脑的人，都可以很容易地照着本文的描述，自己去操作一遍。</p>
<p>大概一周前，百度不是发布了一个&#8220;取得重要进展&#8221;的对话生成网络 PLATO-2&#160;吗？我当时一看到那消息，精神就来了，为什么？这得先从解释一下&#8220;这玩意是干什么用的&#8221;说起&#8212;&#8212;毕竟，这篇文章要让每一个群众都能看得懂，大家好才是真的好。</p>
<blockquote>
<p>
		近日，百度发布对话生成网络 PLATO-2，宣布在开放域对话生成模型上迎来重要进展。PLATO-2 承袭 PLATO 隐变量进行回复多样化生成特性，模型参数高达 16 亿，涵盖中英文版本，可就开放域话题深度畅聊。实验结果显示，PLATO-2 中英文对话效果已超越谷歌 Meena、微软小冰和 Facebook Blender 等先进模型。</p>
</blockquote>
<p>咳咳，这些专业术语说的是什么鬼？<br />
如果你完全看不明白这段话，只需要知道：它说的是和<a href="https://zh.wikipedia.org/wiki/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86" rel="noopener noreferrer" target="_blank">NLP</a>（自然语言处理，一门机器学习的分支学科）相关的一些东西。<br />
可能有的人只听说过这段话里提到的&#8220;微软小冰&#8221;&#8212;&#8212;她的主要功能就是一个【聊天机器人】，和小米的&#8220;小爱同学&#8221;颇为相似。<br />
&#8220;小爱同学，帮我把空调打开！&#8221; &#8220;好的，开啦！&#8221;<br />
&#8212;&#8212;相信这样的场景，早已飞入我国千千万万寻常百姓家。<br />
所以，百度发布的这个 PLATO-2，它可以用来做&#8220;小爱同学&#8221;的大脑，也就是最核心的那一块功能。不过现实中的&#8220;小爱同学&#8221;远比这个复杂，在这里只是做一个比喻而已。<br />
<span id="more-12698"></span><!--more--><br />
其实我对NLP也是一窍不通，但是我却算是半个<a href="https://www.codelast.com/?p=12576">英语学习</a>爱好者，每周几乎都要在<a href="http://cambly.com/invite/DZZZ" rel="noopener noreferrer" target="_blank">Cambly</a>平台上和native English speaker对话交流两次。另外，2020年1月的时候，Google发布了一个号称是技术极其牛B的聊天机器人：<a href="https://www.codelast.com/?p=11992">Meena</a>，我做梦都想能把花在<a href="http://cambly.com/invite/DZZZ" rel="noopener noreferrer" target="_blank">Cambly</a>上练口语的钱给省下来啊！苦于Google只是写了篇文章把Meena推到众人面前，却没有提供任何代码以及demo，所以当我看到度娘说&#8220;我整了一个比Meena还要牛B的机器人&#8221;的时候，我简直要感动哭了&#8212;&#8212;度娘，你是我的救世主！<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 />
还等什么？赶紧把这个机器人的代码跑起来啊！等不及了我马上就要上车！<br />
2话不说，找到PLATO-2的<a href="https://github.com/PaddlePaddle/Knover" rel="noopener noreferrer" target="_blank">GitHub</a>地址，checkout下来，看了一眼 README，貌似开箱即可用，我的心情乐开了花。<br />
看一下运行PLATO-2的要求：</p>
<pre style="box-sizing: border-box; font-family: SFMono-Regular, Consolas, &#34;Liberation Mono&#34;, Menlo, monospace; font-size: 13.6px; margin-top: 0px; margin-bottom: 16px; overflow-wrap: normal; padding: 16px; overflow: auto; line-height: 1.45; background-color: rgb(246, 248, 250); border-radius: 6px; color: rgb(36, 41, 46);">
<code style="box-sizing: border-box; font-family: SFMono-Regular, Consolas, &#34;Liberation Mono&#34;, Menlo, monospace; font-size: 13.6px; padding: 0px; margin: 0px; background: initial; border-radius: 6px; word-break: normal; border: 0px; display: inline; overflow: visible; line-height: inherit; overflow-wrap: normal;">- python &#62;= 3.7.0
- paddlepaddle-gpu &#62;= 1.8.1
- numpy
- sentencepiece
- termcolor</code></pre>
<p>没有什么过多的依赖，这很好。<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>&#8230; <a href="https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e8%b0%83%e6%88%8f%e4%ba%86%e4%b8%80%e7%95%aa%e5%ba%a6%e5%a8%98%e6%9c%80%e5%85%88%e8%bf%9b%e7%9a%84plato-2%e9%a2%84%e8%ae%ad%e7%bb%83%e6%a8%a1%e5%9e%8b%e4%b9%8b%e5%90%8e/" class="read-more">Read More </a></p>]]></description>
										<content:encoded><![CDATA[<p><img decoding="async" alt="plato-2 network arch" src="https://www.codelast.com/wp-content/uploads/2020/07/plato_2_network_arch.png" style="width: 660px; height: 268px;" /><br />
（莫慌，这图是拿出来撑场面的，我可能和你一样看不懂）</p>
<p>前言：这是一篇很不严肃的实验文章。每一个会修电脑的人，都可以很容易地照着本文的描述，自己去操作一遍。</p>
<p>大概一周前，百度不是发布了一个&ldquo;取得重要进展&rdquo;的对话生成网络 PLATO-2&nbsp;吗？我当时一看到那消息，精神就来了，为什么？这得先从解释一下&ldquo;这玩意是干什么用的&rdquo;说起&mdash;&mdash;毕竟，这篇文章要让每一个群众都能看得懂，大家好才是真的好。</p>
<blockquote>
<p>
		近日，百度发布对话生成网络 PLATO-2，宣布在开放域对话生成模型上迎来重要进展。PLATO-2 承袭 PLATO 隐变量进行回复多样化生成特性，模型参数高达 16 亿，涵盖中英文版本，可就开放域话题深度畅聊。实验结果显示，PLATO-2 中英文对话效果已超越谷歌 Meena、微软小冰和 Facebook Blender 等先进模型。</p>
</blockquote>
<p>咳咳，这些专业术语说的是什么鬼？<br />
如果你完全看不明白这段话，只需要知道：它说的是和<a href="https://zh.wikipedia.org/wiki/%E8%87%AA%E7%84%B6%E8%AF%AD%E8%A8%80%E5%A4%84%E7%90%86" rel="noopener noreferrer" target="_blank">NLP</a>（自然语言处理，一门机器学习的分支学科）相关的一些东西。<br />
可能有的人只听说过这段话里提到的&ldquo;微软小冰&rdquo;&mdash;&mdash;她的主要功能就是一个【聊天机器人】，和小米的&ldquo;小爱同学&rdquo;颇为相似。<br />
&ldquo;小爱同学，帮我把空调打开！&rdquo; &ldquo;好的，开啦！&rdquo;<br />
&mdash;&mdash;相信这样的场景，早已飞入我国千千万万寻常百姓家。<br />
所以，百度发布的这个 PLATO-2，它可以用来做&ldquo;小爱同学&rdquo;的大脑，也就是最核心的那一块功能。不过现实中的&ldquo;小爱同学&rdquo;远比这个复杂，在这里只是做一个比喻而已。<br />
<span id="more-12698"></span><!--more--><br />
其实我对NLP也是一窍不通，但是我却算是半个<a href="https://www.codelast.com/?p=12576">英语学习</a>爱好者，每周几乎都要在<a href="http://cambly.com/invite/DZZZ" rel="noopener noreferrer" target="_blank">Cambly</a>平台上和native English speaker对话交流两次。另外，2020年1月的时候，Google发布了一个号称是技术极其牛B的聊天机器人：<a href="https://www.codelast.com/?p=11992">Meena</a>，我做梦都想能把花在<a href="http://cambly.com/invite/DZZZ" rel="noopener noreferrer" target="_blank">Cambly</a>上练口语的钱给省下来啊！苦于Google只是写了篇文章把Meena推到众人面前，却没有提供任何代码以及demo，所以当我看到度娘说&ldquo;我整了一个比Meena还要牛B的机器人&rdquo;的时候，我简直要感动哭了&mdash;&mdash;度娘，你是我的救世主！<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 />
还等什么？赶紧把这个机器人的代码跑起来啊！等不及了我马上就要上车！<br />
2话不说，找到PLATO-2的<a href="https://github.com/PaddlePaddle/Knover" rel="noopener noreferrer" target="_blank">GitHub</a>地址，checkout下来，看了一眼 README，貌似开箱即可用，我的心情乐开了花。<br />
看一下运行PLATO-2的要求：</p>
<pre style="box-sizing: border-box; font-family: SFMono-Regular, Consolas, &quot;Liberation Mono&quot;, Menlo, monospace; font-size: 13.6px; margin-top: 0px; margin-bottom: 16px; overflow-wrap: normal; padding: 16px; overflow: auto; line-height: 1.45; background-color: rgb(246, 248, 250); border-radius: 6px; color: rgb(36, 41, 46);">
<code style="box-sizing: border-box; font-family: SFMono-Regular, Consolas, &quot;Liberation Mono&quot;, Menlo, monospace; font-size: 13.6px; padding: 0px; margin: 0px; background: initial; border-radius: 6px; word-break: normal; border: 0px; display: inline; overflow: visible; line-height: inherit; overflow-wrap: normal;">- python &gt;= 3.7.0
- paddlepaddle-gpu &gt;= 1.8.1
- numpy
- sentencepiece
- termcolor</code></pre>
<p>没有什么过多的依赖，这很好。<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 />
看到 paddlepaddle-gpu&nbsp;的时候，就知道用CPU的机器还不行，可能是inference的速度真的太慢了吧？但我去哪搞一台GPU的机器呢？当然是蹭公司的啦。感谢公司！<br />
为了干净，最好还是在Anaconda下新建一个Python 3.7的 env，然后再安装其他依赖的 Python package。<br />
按百度<a href="https://www.paddlepaddle.org.cn/install/quick#show_info" rel="noopener noreferrer" target="_blank">官方文档</a>就可以很容易搞定一切。<br />
我这里只简要地把几个主要步骤描述一下。<br />
先添加清华的源，再创建为PaddlePaddle创建一个单独的 env：</p>
<blockquote>
<p>
		conda create --name paddle python=3.7<br />
		conda activate paddle</p>
</blockquote>
<p>完了之后，剩下的安装步骤就简单啦：</p>
<blockquote>
<p>
		conda install paddlepaddle-gpu cudatoolkit=10.0<br />
		conda install -c conda-forge sentencepiece<br />
		conda install termcolor</p>
</blockquote>
<p>注意，这里我使用的是 cudatoolkit=10.0，这是因为我机器上的&nbsp;CUDA Version&nbsp;是10.x&nbsp;版本。<br />
最后按百度官方文档测试一下安装上的 PaddlePaddle&nbsp;是否正常，就行了。<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 />
现在可以把 PLATO-2&nbsp;用起来了。把它&nbsp;<a href="https://github.com/PaddlePaddle/Knover" rel="noopener noreferrer" target="_blank">GitHub</a>&nbsp;页面上提供的那两个预训练模型下载到GPU机器上（一个体积小参数少，另一个体积大参数多），按百度的文档里说的，解压到&nbsp;<span style="color:#0000ff;">Knover</span> 目录下：<br />
<a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><img decoding="async" alt="plato-2 pre-trained models" src="https://www.codelast.com/wp-content/uploads/2020/07/plato_2_pre_train_models.png" style="width: 300px; height: 94px;" /></a></p>
<p>下面就可以把&ldquo;交互式对话&rdquo;的程序跑起来了（会加载刚下载的模型）：</p>
<blockquote>
<p>
		cd Knover/plato-2/<br />
		bash ./scripts/32L_plato_interact.sh</p>
</blockquote>
<p>在这里，我用的是体积大参数多的那个模型 32L。<br />
经过一小段时间的耐心等待，模型完全加载好了，看一下显存占用情况，17个G：</p>
<blockquote>
<div>
		+-------------------------------------------------------------------------+</div>
<div>
		| Processes:&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;GPU Memory |</div>
<div>
		|&nbsp; GPU&nbsp; &nbsp; &nbsp; &nbsp;PID&nbsp; &nbsp;Type&nbsp; &nbsp;Process name&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Usage&nbsp; &nbsp; &nbsp; |</div>
<div>
		|============================================================|</div>
<div>
		|&nbsp; &nbsp; 0&nbsp; &nbsp; &nbsp;38736&nbsp; &nbsp; &nbsp; C&nbsp; &nbsp;python&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;17229MiB |</div>
</blockquote>
<div>
	由于在&nbsp;<span style="color:#0000ff;">32L_plato_interact.sh</span>&nbsp;脚本里默认使用的是第一张卡（export CUDA_VISIBLE_DEVICES=0），所以这里看到的 GPU 0&nbsp;就是了。<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 />
	虽然预训练的模型肯定达不到我的期望，不过我还是想看看这个聊天机器人的实际聊天效果怎么样。毕竟百度用了64张V100显卡+3周时间才训练出的模型，我怎么可能去自己训练一个模型呢？我没钱也没资源。</p>
<p>	我试着和机器人聊一下新冠肺炎(<span style="color: rgb(0, 0, 255);">COVID-19</span>)这个主题，但它显然&ldquo;完全不懂&rdquo;，可能是它的训练数据里完全没有这方面的数据吧。不过它不懂也就算了，而且它还一直对 <span style="color:#0000ff;">covid</span>&nbsp;这个它不懂的词纠缠不休，并且还误认成别的东西(pet)。我说东，它说西，最后实在没法聊下去，我只能输入一个 <span style="color:#ff0000;">[NEXT]</span>&nbsp;来让它开始一个新的会话过程。<br />
	下面这张图就是我和机器人的对话过程截图。<br />
	<a href="https://www.codelast.com/" rel="noopener noreferrer" target="_blank"><img decoding="async" alt="chat with plato-2 bot" src="https://www.codelast.com/wp-content/uploads/2020/07/chat_with_baidu_plato_bot.png" style="width: 660px; height: 536px;" /></a><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 />
	原来我还想着，这个预训练的模型聊天效果要是&ldquo;还行&rdquo;的话，我再给它套一个语音识别的功能，这样就可以真正地和它说话了，现在看来，暂时还是不行。<br />
	于是我又回到了<a href="http://cambly.com/invite/DZZZ" rel="noopener noreferrer" target="_blank">Cambly</a>和真人老外聊天去了。</p>
<p>	后记：从目前的技术发展情况来看，微软小冰、Meena之类的机器人要想在&ldquo;语言学习&rdquo;方面能代替一部分人类教师，真的太难了，如果要有令人直观感受强烈的突破的话，说10年那可能都是少的了。<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>
		<img decoding="async" alt="wechat qrcode of codelast" src="https://www.codelast.com/codelast_wechat_qr_code.jpg" style="color: rgb(77, 77, 77); font-size: 13px; width: 200px; height: 200px;" /><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="" src="https://www.codelast.com/wechat_shipinhao_qr_code.jpg" style="text-align: center; width: 200px; height: 199px;" /></p>
</div>
]]></content:encoded>
					
					<wfw:commentRss>https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e8%b0%83%e6%88%8f%e4%ba%86%e4%b8%80%e7%95%aa%e5%ba%a6%e5%a8%98%e6%9c%80%e5%85%88%e8%bf%9b%e7%9a%84plato-2%e9%a2%84%e8%ae%ad%e7%bb%83%e6%a8%a1%e5%9e%8b%e4%b9%8b%e5%90%8e/feed/</wfw:commentRss>
			<slash:comments>5</slash:comments>
		
		
			</item>
		<item>
		<title>[原创]Machine Learning/机器学习 文章合集</title>
		<link>https://www.codelast.com/%e5%8e%9f%e5%88%9bmachine-learning%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0-%e6%96%87%e7%ab%a0%e5%90%88%e9%9b%86/</link>
					<comments>https://www.codelast.com/%e5%8e%9f%e5%88%9bmachine-learning%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0-%e6%96%87%e7%ab%a0%e5%90%88%e9%9b%86/#comments</comments>
		
		<dc:creator><![CDATA[learnhard]]></dc:creator>
		<pubDate>Sat, 21 Jan 2017 10:57:16 +0000</pubDate>
				<category><![CDATA[Algorithm]]></category>
		<category><![CDATA[Math]]></category>
		<category><![CDATA[原创]]></category>
		<category><![CDATA[machine learning]]></category>
		<category><![CDATA[机器学习]]></category>
		<guid isPermaLink="false">http://www.codelast.com/?p=9137</guid>

					<description><![CDATA[<p>注：带有 <span style="color:#ff0000;">♬♬♬♬♬</span>&#160;标志的是文章合集。</p>
<p>✍<a href="https://www.codelast.com/?p=10907" rel="noopener noreferrer" target="_blank">强化学习(Reinforcement Learning)文章合集</a>&#160;<span style="color: rgb(255, 0, 0);">♬♬♬♬♬</span></p>
<p>✍<a href="https://www.codelast.com/?p=8629" rel="noopener noreferrer" target="_blank">用人话解释机器学习中的Logistic Regression（逻辑回归）</a></p>
<p>✍<a href="https://www.codelast.com/?p=9211" rel="noopener noreferrer" target="_blank">如何防止softmax函数上溢出(overflow)和下溢出(underflow)</a></p>
<p>✍<a href="https://www.codelast.com/?p=9754" rel="noopener noreferrer" target="_blank">ELL（Embedded Learning Library，微软嵌入式学习库）文章合集</a>&#160;<span style="color: rgb(255, 0, 0);">♬♬♬♬♬</span><br />
<span id="more-9137"></span><br />
✍<a href="https://www.codelast.com/?p=9040" rel="noopener noreferrer" target="_blank">《Neural Networks and Deep Learning》读书笔记：最简单的识别MNIST的神经网络程序(1)</a></p>
<p>✍<a href="https://www.codelast.com/?p=9083" rel="noopener noreferrer" target="_blank">《Neural Networks and Deep Learning》读书笔记：最简单的识别MNIST的神经网络程序(2)</a></p>
<p>✍<a href="https://www.codelast.com/?p=9085" rel="noopener noreferrer" target="_blank">《Neural Networks and Deep Learning》读书笔记：反向传播的4个基本方程(1)</a></p>
<p>✍<a href="https://www.codelast.com/?p=9951" rel="noopener noreferrer" target="_blank">用人话解释蒙特卡罗方法/Monte Carlo method(文章合集)</a>&#160;<span style="color: rgb(255, 0, 0);">♬♬♬♬♬</span></p>
<p>✍<a href="https://www.codelast.com/?p=10475" rel="noopener noreferrer" target="_blank">一个简单的TensorFlow-Serving例子</a></p>
<p>✍<a href="https://www.codelast.com/?p=10520" rel="noopener noreferrer" target="_blank">tf.tile()</a>&#8230; <a href="https://www.codelast.com/%e5%8e%9f%e5%88%9bmachine-learning%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0-%e6%96%87%e7%ab%a0%e5%90%88%e9%9b%86/" class="read-more">Read More </a></p>]]></description>
										<content:encoded><![CDATA[<p>注：带有 <span style="color:#ff0000;">♬♬♬♬♬</span>&nbsp;标志的是文章合集。</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10907" rel="noopener noreferrer" target="_blank">强化学习(Reinforcement Learning)文章合集</a>&nbsp;<span style="color: rgb(255, 0, 0);">♬♬♬♬♬</span></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=8629" rel="noopener noreferrer" target="_blank">用人话解释机器学习中的Logistic Regression（逻辑回归）</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=9211" rel="noopener noreferrer" target="_blank">如何防止softmax函数上溢出(overflow)和下溢出(underflow)</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=9754" rel="noopener noreferrer" target="_blank">ELL（Embedded Learning Library，微软嵌入式学习库）文章合集</a>&nbsp;<span style="color: rgb(255, 0, 0);">♬♬♬♬♬</span><br />
<span id="more-9137"></span><br />
<img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=9040" rel="noopener noreferrer" target="_blank">《Neural Networks and Deep Learning》读书笔记：最简单的识别MNIST的神经网络程序(1)</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=9083" rel="noopener noreferrer" target="_blank">《Neural Networks and Deep Learning》读书笔记：最简单的识别MNIST的神经网络程序(2)</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=9085" rel="noopener noreferrer" target="_blank">《Neural Networks and Deep Learning》读书笔记：反向传播的4个基本方程(1)</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=9951" rel="noopener noreferrer" target="_blank">用人话解释蒙特卡罗方法/Monte Carlo method(文章合集)</a>&nbsp;<span style="color: rgb(255, 0, 0);">♬♬♬♬♬</span></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10475" rel="noopener noreferrer" target="_blank">一个简单的TensorFlow-Serving例子</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10520" rel="noopener noreferrer" target="_blank">tf.tile() 用法举例(TensorFlow)</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10534">二维numpy数组保存到TFRecord并读取还原回来</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10565" rel="noopener noreferrer" target="_blank">如何打印出TensorFlow保存的checkpoint里的参数名</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10578" rel="noopener noreferrer" target="_blank">如何取出 tf.layers.dense 定义的全连接层的weight和bias参数值</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10950" rel="noopener noreferrer" target="_blank">PyTorch模型 .pt，.pth，.pkl 的区别</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=10953" rel="noopener noreferrer" target="_blank">PyTorch模型的两种保存方法</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=12047" rel="noopener noreferrer" target="_blank">PyTorch做inference/prediction的时候如何使用GPU</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=12698" rel="noopener noreferrer" target="_blank">调戏了一番度娘&quot;最先进&quot;的PLATO-2预训练模型之后，我还是回到了和人类交谈...</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=12856" rel="noopener noreferrer" target="_blank">《使用 fastText 做中文文本分类》文章合集</a><span style="color: rgb(255, 0, 0);">♬♬♬♬♬</span></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/270d.png" alt="✍" class="wp-smiley" style="height: 1em; max-height: 1em;" /><a href="https://www.codelast.com/?p=13912" rel="noopener noreferrer" target="_blank">怎样确认当前正在运行的TensorFlow model-serving服务加载的是哪个.pb模型</a></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:#ff0000;">➤➤</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%9bmachine-learning%e6%9c%ba%e5%99%a8%e5%ad%a6%e4%b9%a0-%e6%96%87%e7%ab%a0%e5%90%88%e9%9b%86/feed/</wfw:commentRss>
			<slash:comments>4</slash:comments>
		
		
			</item>
		<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>
