博客分类：
背包问题已经是一个很经典而且讨论很广泛的算法问题了。最近学习到这一部分，打算结合自己思考和编码的过程做一个思考总结。这里主要讨论的0-1背包问题和部分背包问题解决方法背后其实隐藏了两种我们比较常见的算法解决思路，动态规划和贪婪算法。正好通过这两个问题的讨论可以好好的加深一下理解。
假设我们有n件物品，分别编号为1, 2...n。其中编号为i的物品价值为vi，它的重量为wi。为了简化问题，假定价值和重量都是整数值。现在，假设我们有一个背包，它能够承载的重量是W。现在，我们希望往包里装这些物品，使得包里装的物品价值最大化，那么我们该如何来选择装的东西呢？问题结构如下图所示：
这个问题其实根据不同的情况可以归结为不同的解决方法。假定我们这里选取的物品每个都是独立的，不能选取部分。也就是说我们要么选取某个物品，要么不能选取，不能只选取一个物品的一部分。这种情况，我们称之为0-1背包问题。而如果我们可以使用部分的物品的话，这个问题则成为部分背包(fractional knapsack)问题。下面我们针对每种情况具体分析一下。
0-1背包问题
对于这个问题，一开始确实有点不太好入手。一堆的物品，每一个都有一定的质量和价值，我们能够装入的总重量有限制，该怎么来装使得价值最大呢？对于这n个物品，每个物品我们可能会选，也可能不选，那么我们总共就可能有2^n种组合选择方式。如果我们采用这种办法来硬算的话，则整体的时间复杂度就达到指数级别的，肯定不可行。
现在我们换一种思路。既然每一种物品都有价格和重量，我们优先挑选那些单位价格最高的是否可行呢？比如在下图中，我们有3种物品，他们的重量和价格分别是10, 20, 30 kg和60, 100, 120。
那么按照单位价格来算的话，我们最先应该挑选的是价格为60的元素，选择它之后，背包还剩下50 - 10 = 40kg。再继续前面的选择，我们应该挑选价格为100的元素，这样背包里的总价值为60 + 100 = 160。所占用的重量为30, 剩下20kg。因为后面需要挑选的物品为30kg已经超出背包的容量了。我们按照这种思路能选择到的最多就是前面两个物品。如下图：
按照我们前面的期望，这样选择得到的价值应该是最大的。可是由于有一个背包重量的限制，这里只用了30kg，还有剩下20kg浪费了。这会是最优的选择吗？我们看看所有的选择情况：
很遗憾，在这几种选择情况中，我们前面的选择反而是带来价值最低的。而选择重量分别为20kg和30kg的物品带来了最大的价值。看来，我们刚才这种选择最佳单位价格的方式也行不通。
既然前面两种办法都不可行，我们再来看看有没有别的方法。我们再来看这个问题。我们需要选择n个元素中的若干个来形成最优解，假定为k个。那么对于这k个元素a1, a2, ...ak来说，它们组成的物品组合必然满足总重量&=背包重量限制，而且它们的价值必然是最大的。因为它们是我们假定的最优选择嘛，肯定价值应该是最大的。假定ak是我们按照前面顺序放入的最后一个物品。它的重量为wk，它的价值为vk。既然我们前面选择的这k个元素构成了最优选择，如果我们把这个ak物品拿走，对应于k-1个物品来说，它们所涵盖的重量范围为0-(W-wk)。假定W为背包允许承重的量。假定最终的价值是V，剩下的物品所构成的价值为V-vk。这剩下的k-1个元素是不是构成了一个这种W-wk的最优解呢？
我们可以用反证法来推导。假定拿走ak这个物品后，剩下的这些物品没有构成W-wk重量范围的最佳价值选择。那么我们肯定有另外k-1个元素，他们在W-wk重量范围内构成的价值更大。如果这样的话，我们用这k-1个物品再加上第k个，他们构成的最终W重量范围内的价值就是最优的。这岂不是和我们前面假设的k个元素构成最佳矛盾了吗？所以我们可以肯定，在这k个元素里拿掉最后那个元素，前面剩下的元素依然构成一个最佳解。
现在我们经过前面的推理已经得到了一个基本的递推关系，就是一个最优解的子解集也是最优的。可是，我们该怎么来求得这个最优解呢？我们这样来看。假定我们定义一个函数c[i, w]表示到第i个元素为止，在限制总重量为w的情况下我们所能选择到的最优解。那么这个最优解要么包含有i这个物品，要么不包含，肯定是这两种情况中的一种。如果我们选择了第i个物品，那么实际上这个最优解是c[i - 1, w-wi] + vi。而如果我们没有选择第i个物品，这个最优解是c[i-1, w]。这样，实际上对于到底要不要取第i个物品，我们只要比较这两种情况，哪个的结果值更大不就是最优的么？
在前面讨论的关系里，还有一个情况我们需要考虑的就是，我们这个最优解是基于选择物品i时总重量还是在w范围内的，如果超出了呢？我们肯定不能选择它，这就和c[i-1, w]一样。
另外，对于初始的情况呢？很明显c[0, w]里不管w是多少，肯定为0。因为它表示我们一个物品都不选择的情况。c[i, 0]也一样，当我们总重量限制为0时，肯定价值为0。
这样，基于我们前面讨论的这3个部分，我们可以得到一个如下的递推公式：
有了这个关系，我们可以更进一步的来考虑代码实现了。我们有这么一个递归的关系，其中，后面的函数结果其实是依赖于前面的结果的。我们只要按照前面求出来最基础的最优条件，然后往后面一步步递推，就可以找到结果了。
我们再来考虑一下具体实现的细节。这一组物品分别有价值和重量，我们可以定义两个数组int[] v, int[] w。v[i]表示第i个物品的价值，w[i]表示第i个物品的重量。为了表示c[i, w]，我们可以使用一个int[i][w]的矩阵。其中i的最大值为物品的数量，而w表示最大的重量限制。按照前面的递推关系，c[i][0]和c[0][w]都是0。而我们所要求的最终结果是c[n][w]。所以我们实际中创建的矩阵是(n + 1) x (w + 1)的规格。下面是该过程的一个代码参考实现：
public class DynamicKnapSack {
private int[]
private int[]
private int[][]
public DynamicKnapSack(int length, int weight, int[] vin, int[] win) {
v = new int[length + 1];
w = new int[length + 1];
c = new int[length + 1][weight + 1];
this.weight =
for(int i = 0; i & length + 1; i++) {
v[i] = vin[i];
w[i] = win[i];
public void solve() {
for(int i = 1; i & v. i++) {
for(int k = 1; k &= k++) {
if(w[i] &= k) {
if(v[i] + c[i - 1][k - w[i]] & c[i - 1][k])
c[i][k] = v[i] + c[i - 1][k - w[i]];
c[i][k] = c[i - 1][k];
c[i][k] = c[i - 1][k];
public void printResult() {
for(int i = 0; i & v. i++) {
for(int j = 0; j &= j++)
System.out.print(c[i][j] + " ");
System.out.println();
public static void main(String[] args) {
int[] v = {0, 60, 100, 120};
int[] w = {0, 10, 20, 30};
int weight = 50;
DynamicKnapSack knapsack = new DynamicKnapSack(3, weight, v, w);
knapsack.solve();
knapsack.printResult();
这部分代码里关键的就是solve方法。里面两个遍历循环，i表示从1到n的范围，对应于我们递归方法里描述的c(i, w)中到第i位。而k表示的是当前的重量限制。下面是程序运行的输出结果：
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60
0 0 0 0 0 0 0 0 0 0 60 60 60 60 60 60 60 60 60 60 100 100 100 100 100 100 100 100 100 100 160 160 160 160 160 160 160 160 160 160 160 160 160 160 160 160 160 160 160 160 160
0 0 0 0 0 0 0 0 0 0 60 60 60 60 60 60 60 60 60 60 100 100 100 100 100 100 100 100 100 100 160 160 160 160 160 160 160 160 160 160 180 180 180 180 180 180 180 180 180 180 220
最右下角的数值220就是c[1, 50]的解。
至此，我们对于这种问题的解决方法已经分析出来了。它的总体时间复杂度为O(nw) ，其中w是设定的一个重量范围，因此也可以说它的时间复杂度为O(n)。
部分背包问题
和前面使用动态规划方法解决问题不一样。因为这里是部分背包问题，我们可以采用前面讨论过的一个思路。就是每次选择最优单位价格的物品，直到达到背包重量限制要求。
以前面的示例来看，我们按照这种方式选择的物品结果应该如下图：
现在，我们从实现的角度再来考虑一下。我们这里的最优解是每次挑选性价比最高的物品。对于这一组物品来说，我们需要将他们按照性价比从最高到最低的顺序来取。我们可能需要将他们进行排序。然后再依次取出来放入背包中。假定我们已经有数组v，w，他们已经按照性价比排好序了。一个参考代码的实现如下：
public double selectMax() {
double maxValue = 0.0;
int sum = 0;
for(i = 0; i & v. i++) {
if(sum + w[i] & weight) {
sum += w[i];
maxValue += v[i];
if(i & v.length && sum & weight) {
maxValue += (double)(weight - sum) / w[i] * v[i];
return maxV
这里省略了对数组v, w的定义。关键点在于我们选择了若干了物品后要判断是否装满了背包重量。如果没有，还要从后面的里面挑选一部分。所以有一个if(i & v.length && sum & weight)的判断。
在实现后我们来看该问题这种解法的时间复杂度，因为需要将数组排序，我们的时间复杂度为O(nlgn)。
一点改进：
在前面我们挑选按照性价比排好序的物品时，排序消耗了主要的时间。在这里，我们是否真的需要去把这些物品排序呢？在某些情况下，我们只要选择一堆物品，保证他们物品重量在指定范围内。如果我们一次挑出来一批这样的物品，而且他们满足这样的条件是不是更好呢？这一种思路是借鉴快速排序里对元素进行划分的思路。主要过程如下：
1. 求每个元素的单位价值，pi = vi /wi。然后数组按照pi进行划分，这样会被分成3个部分，L, M, N。其中L & M & N。这里L表示单位价值小于某个指定值的集合，M是等于这个值的集合，而N是大于这个值的集合。
2. 我们可以首先看N的集合，因为这里都是单位价值高的集合。我们将他们的重量累加，如果WN的重量等于我们期望的值W，则N中间的结果就是我们找到的结果。
3. 如果WN的重量大于W，我们需要在N集合里做进一步划分。
4. 如果WN的重量小于W，我们需要在N的基础上再去L的集合里划分，找里面大的一部分。
这样重复步骤1到4.
这里和快速排序的思路基本上差不多，只是需要将一个分割的集合给记录下来。其时间复杂度也更好一点，为O(N)。这里就简单的描述下思路，等后续再将具体的实现代码给补上。
我们这里讨论的两种背包问题因为问题的不同其本质解决方法也不同。对于0-1背包来说，他们构成了一个最优解问题的基础。我们可以通过从最小的结果集递推出最终最优结果。他们之间构成了一个递归的关系。而对于部分背包问题来说，我们可以考虑用贪婪算法，每次选择当前看来最优的结果。最终也构成了一个最优的结果。一个小小的前提变化，问题解决的思路却大不同。里面的思想值得反复体会。
浏览 30801
浏览: 913232 次
来自: 北京
讲的很详细，感谢
while(i & a.length)
解释得通俗易懂博客分类：
以8b为例对比如下：（谁能给我补补课，说说为什么是正0负1，按照我的理解应该是正1负0更符合人类的思维，前者是进行了一次技术上的mapping了）
+1 0 000 0001
-1 1 000 0001
-1 1 111 1110
-1 1 111 1111
0 000 0001
1 111 1111
------------
10 000 0000
而如果反过来就会是这样的：
+1 1 000 0001
-1 0 000 0001
-1 0 111 1110
-1 0 111 1111
1 000 0001
0 111 1111
------------
10 000 0000
= (溢出位 8b考虑为 +0)：相关链接：
http://dev.csdn.net/develop/article/17/17680.shtm
逆向推理：
先有正数运算，再有负数，才会产生有符号运算所遇到的问题。
按照离散数学的原理，需要解决的问题有两个：
1、负0怎样才能和正0具有相同的标志；
2、其他负数如何确定各自的标志；
3、运算规律是否可行；
下面给出我的推导过程及最后的公式，我觉得 原码和反码的转换公式要比以前我看到的教程简单很多。
一、拿二位10进制为例
可得排列组合（标志）为00，01，02，03，04，05，06，07，08，09，10，11，12，13，14，15，16，17，18，19 共计2*10^1 = 20 个数，为正数1~9 、 0 、和负数10个。（因为正数和0在负数概念出现以前已经确定，所以剩下的数为负数）。
二、拿二位2进制为例
同理有标志00 01 10 11，00为+0，01为+1，推理另两个标志对应的负数。
同样的方法可以放到三位二进制 ，四位二进制等，表示为x位n进制可得到公式：
负数原码和补码的转换公式：1v = -(n^(x-1)-v)
放到8位2进制即：1v=-(2^7-v)
代入8位二进制即使
= - (2^7-0)= -128;
= -(2^7-1) = -127;
= -(2^7-2) = -126;
= -(2^7-(2^7-1)) = -1;
"-1就是减1嘛，想一想减去1应该是多少呢，不够就借位，那就是"
这句话同样体现了前提：不破坏先前的正数（包括0）的运算法则。
结：那些计算机教材写得真垃圾啊，就这么简单的问题搞锤子求反+1 ，基本上无逻辑可言。
结合离散等数学知识，这个问题是不是可以延伸到内存寻址等相关方面呢？
浏览 12748
论坛回复 /
(16 / 16772)
一 确信你是对的？OXFF 是 是-127 不是-1 -1的原码是
用16进制表示是 OX7F 是否你搞混了这几种编码 还是我没理解你的说法？二 不明白你在说什么 正数 源码 反码 补码 都是本身 你说”单字节有符号整数，正数部分的取值范围是0x00-0x7F。求补码时取反加1，对应0xFF-0x81。“不理解补码数，x的相反数，就是x求反再加1于是-1就等于 1取反再加1就是
+ 1 = -(-1)就是-1取反再加1就是
程序员一懒就用了 1 来表示 负 是说得通的
程序员一懒就用就用补码 好像没什么道理
反过来 带符号运算 不用补码可以吗？
解释下 反过来是 说 ”1表示正 0表示负“ 这种情况下 补码也是必需的
单字节有符号整数，-1的表示应该是 (0xFF)，而不是0x7F。
单字节有符号整数，正数部分的取值范围是0x00-0x7F。求补码时取反加1，对应0xFF-0x81。所以所有负数的最高位都是1。
一 确信你是对的？OXFF 是 是-127 不是-1 -1的原码是
用16进制表示是 OX7F 是否你搞混了这几种编码 还是我没理解你的说法？
二 不明白你在说什么 正数 源码 反码 补码 都是本身 你说
”单字节有符号整数，正数部分的取值范围是0x00-0x7F。求补码时取反加1，对应0xFF-0x81。“不理解
再想了下 这个问题的其实是前提错掉了 ，按照人来的思维并不是 用1来表示正 就合理了
因为符号是处在和数字不同的层面上了 ，先有了无符号运算也是理所当然，后来要引入无符号运算，
自然得多一个符号出来，原来是没有的 现在需要一个 这就是 从无到有的过程 用1来表示"有" "0"来表示无
又回到了”理所当然“的路上，符号和数字不能在同一个层面上考虑，自然也不能拿数字的含义来表示
思考正负号了。
最近看到某处有人说中国人的二进制使用比西方早了4K多年，”易有太极，是生两仪，两仪生四象，四象生八卦，八卦定极凶，吉凶生大业“,被影响了，嘿嘿
附：生命中不能承受之轻 存在即真理 不停寻找& 真理是当时只有汇编，没有C这种高级语言
想要结构化编程都很困难
只好hack这种恶心的需求。
PS：汇编中的一个if else 写出来都会死人的。。。。
jianfeng008cn
浏览: 164044 次
来自: 湖州
非常感谢 一直在找破解的
要破解的 这东西?????
非常感谢啊，顶，就一个字
哈哈，谢谢了Python中的Numpy入门教程
来源：易贤网&& 阅读：10546 次&&日期： 20:15:34
温馨提示：易贤网小编为您整理了“Python中的Numpy入门教程”,方便广大网友查阅！
这篇文章主要介绍了Python中的Numpy入门教程，着重讲解了矩阵中的数组操作,需要的朋友可以参考下1、Numpy是什么很简单，Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数。如果接触过matlab、scilab，那么numpy很好入手。在以下的代码示例中，总是先导入了numpy：代码如下:&&&importnumpyasnp&&&printnp.version.version1.6.22、多维数组多维数组的类型是：numpy.ndarray。使用numpy.array方法以list或tuple变量为参数产生一维数组：代码如下:&&&printnp.array([1,2,3,4])[1234]&&&printnp.array((1.2,2,3,4))[1.22.3.4.]&&&printtype(np.array((1.2,2,3,4)))&type'numpy.ndarray'&以list或tuple变量为元素产生二维数组：代码如下:&&&printnp.array([[1,2],[3,4]])[[12][34]]生成数组的时候，可以指定数据类型，例如numpy.int32,numpy.int16,andnumpy.float64等：代码如下:&&&printnp.array((1.2,2,3,4),dtype=np.int32)[1234]使用numpy.arange方法代码如下:&&&printnp.arange(15)[]&&&printtype(np.arange(15))&type'numpy.ndarray'&&&&printnp.arange(15).reshape(3,5)[[01234][56789][]]&&&printtype(np.arange(15).reshape(3,5))&type'numpy.ndarray'&使用numpy.linspace方法例如，在从1到3中产生9个数：代码如下:&&&printnp.linspace(1,3,9)[1.1.251.51.752.2.252.52.753.]使用numpy.zeros，numpy.ones，numpy.eye等方法可以构造特定的矩阵例如：代码如下:&&&printnp.zeros((3,4))[[0.0.0.0.][0.0.0.0.][0.0.0.0.]]&&&printnp.ones((3,4))[[1.1.1.1.][1.1.1.1.][1.1.1.1.]]&&&printnp.eye(3)[[1.0.0.][0.1.0.][0.0.1.]]创建一个三维数组：代码如下:&&&printnp.zeros((2,2,2))[[[0.0.][0.0.]][[0.0.][0.0.]]]获取数组的属性：代码如下:&&&a=np.zeros((2,2,2))&&&printa.ndim#数组的维数3&&&printa.shape#数组每一维的大小(2,2,2)&&&printa.size#数组的元素数8&&&printa.dtype#元素类型float64&&&printa.itemsize#每个元素所占的字节数8数组索引，切片，赋值示例：代码如下:&&&a=np.array([[2,3,4],[5,6,7]])&&&printa[[234][567]]&&&printa[1,2]7&&&printa[1,:][567]&&&printa[1,1:2][6]&&&a[1,:]=[8,9,10]&&&printa[[234][8910]]使用for操作元素代码如下:&&&forxinnp.linspace(1,3,3):...printx...1.02.03.0基本的数组运算先构造数组a、b：代码如下:&&&a=np.ones((2,2))&&&b=np.eye(2)&&&printa[[1.1.][1.1.]]&&&printb[[1.0.][0.1.]]数组的加减乘除：代码如下:&&&printa&2[[FalseFalse][FalseFalse]]&&&printa+b[[2.1.][1.2.]]&&&printa-b[[0.1.][1.0.]]&&&printb*2[[2.0.][0.2.]]&&&print(a*2)*(b*2)[[4.0.][0.4.]]&&&printb/(a*2)[[0.50.][0.0.5]]&&&print(a*2)**4[[16.16.][16.16.]]使用数组对象自带的方法：代码如下:&&&a.sum()4.0&&&a.sum(axis=0)#计算每一列（二维数组中类似于矩阵的列）的和array([2.,2.])&&&a.min()1.0&&&a.max()1.0使用numpy下的方法：代码如下:&&&np.sin(a)array([[0..],[0..]])&&&np.max(a)1.0&&&np.floor(a)array([[1.,1.],[1.,1.]])&&&np.exp(a)array([[2..],[2..]])&&&np.dot(a,a)##矩阵乘法array([[2.,2.],[2.,2.]])合并数组使用numpy下的vstack和hstack函数：代码如下:&&&a=np.ones((2,2))&&&b=np.eye(2)&&&printnp.vstack((a,b))[[1.1.][1.1.][1.0.][0.1.]]&&&printnp.hstack((a,b))[[1.1.1.0.][1.1.0.1.]]看一下这两个函数有没有涉及到浅拷贝这种问题：代码如下:&&&c=np.hstack((a,b))&&&printc[[1.1.1.0.][1.1.0.1.]]&&&a[1,1]=5&&&b[1,1]=5&&&printc[[1.1.1.0.][1.1.0.1.]]可以看到，a、b中元素的改变并未影响c。深拷贝数组数组对象自带了浅拷贝和深拷贝的方法，但是一般用深拷贝多一些：代码如下:&&&a=np.ones((2,2))&&&b=a&&&bisaTrue&&&c=a.copy()#深拷贝&&&cisaFalse基本的矩阵运算转置：代码如下:&&&a=np.array([[1,0],[2,3]])&&&printa[[10][23]]&&&printa.transpose()[[12][03]]迹：代码如下:&&&printnp.trace(a)4numpy.linalg模块中有很多关于矩阵运算的方法：代码如下:&&&importnumpy.linalgasnplg特征值、特征向量：代码如下:&&&printnplg.eig(a)(array([3.,1.]),array([[0.,0.],[1.,-0.]]))3、矩阵numpy也可以构造矩阵对象，这里不做讨论。
更多信息请查看
更多信息请查看
【】&&&&&【点此处查询各地各类考试咨询QQ号码及交流群】
易贤网手机网站地址：
由于各方面情况的不断调整与变化，易贤网提供的所有考试信息和咨询回复仅供参考，敬请考生以权威部门公布的正式信息和咨询为准！
相关阅读 & & &
&&&    会员注册
本站不参与评论！（）
自觉遵守：爱国、守法、自律、真实、文明的原则
尊重网上道德，遵守中华人民共和国各项有关法律法规
严禁发表危害国家安全，破坏民族团结、国家宗教政策和社会稳定，含侮辱、诽谤、教唆、淫秽等内容的评论
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
您在本站发表的评论，本站有权保留、转载、引用或者删除
参与本评论即表明您已经阅读并接受上述条款【梯度下降法】一：快速教程、Python简易实现以及对学习率的探讨
如何防止搜索时发生震荡却是一门值得深究的学问。接下来本文将分析第一个问题：学习率的大小对搜索过程的影响。全部源代码可在本人的GitHub:monitor1379中下载。 快速教程 前言啰嗦完了，接下来直接上干货：如何编写梯度下降法。代码运行环境为Python 2.7.11 + NumPy
02:04&&&[]
如何防止搜索时发生震荡却是一门值得深究的学问。 上两篇博客《【梯度下降法】一：快速教程、Python简易实现以及对学习率的探讨》与《【梯度下降法】二：冲量（momentum）的原理与Python实现》分别介绍了学习率大小对搜索过程的影响以及“冲量”的原理以及如何用“冲量”来解决收敛速度慢与收敛时发生
02:04&&&[]
如何防止搜索时发生震荡却是一门值得深究的学问。 在上篇博客《【梯度下降法】一：快速教程、Python简易实现以及对学习率的探讨》中我们简单分析了学习率大小对搜索过程的影响，发现：
学习率较小时，收敛到极值的速度较慢。 学习率较大时，容易在搜索过程中发生震荡。
因此本篇博客将简单讲解“冲量”的原理
02:04&&&[]
一、梯度下降算法理论知识
我们给出一组房子面积，卧室数目以及对应房价数据，如何从数据中找到房价y与面积x1和卧室数目x2的关系？
为了实现监督学习，我们选择采用自变量x1、x2的线性函数来评估因变量y值，得到：
这里，sita1、sita2代表自变量x1、x2的权重
12:56&&&[]
&梯度下降法在凸优化中应用非常广泛，常用于求凸函数极值。梯度是个向量，其形式为
通常是表示函数上升最快的方向！因此，我们只需要每一步往梯度方向走一小步，最终就可以到达极值点，其表现形式为：
初始点为x0， 然后往梯度的反方向移动一小步r到x1， 再次往梯度反方向移动r到x2
22:57&&&[]
梯度下降法解决的问题： 对于代价函数 J(θ0, θ1, θ2, θ3,...,θn) 去最小化 J(θ0, θ1, θ2, θ3,...,θn) 求得的参数 (θ0, θ1, θ2, θ3,...,θn) 即为 hypothesis function 的参数。 算法步骤： 1. 设置 θ0=0
23:35&&&[]
本帖最后由 zhoufanking 于
00:24:24 编辑
Python 算法 梯度下降
刚开始学习机器学习，想自己用python实现课件中的算法，加深认识。下面是我写的使用随机梯度下降计算线性回归模型参数的代码，但是得到的结果不对，请帮忙看看
14:54&&&[]
logistic回归是一种著名的二元分类问题的线性分类算法。它容易实现、易于理解，并在各类问题上有不错的效果，即使该方法的原假设与数据有违背时。 在本教程中，你将了解如何在 Python 中实现随机梯度下降的logistic回归算法。学完本教程后，你将了解：
如何使用logistic 回归模型
15:54&&&[]
随机梯度下降法，介绍其原理及推导过程，并比较 Python 简单实现和 Torch 的应用。对应课件为 L2-Linear-prediction.ipynb 。
梯度下降法（gradient descent） 为了确定神经网络模型中参数（权值）的好坏，需要先指定一个衡量标准（训练误差，损失函数
15:13&&&[]
我现在要实现产生一个m&n的矩形框，而且还需要对里面的内容能实现添加自己需要的数据。
但是现在有一个问题，实现的m&n的矩形框肯定超出了手机屏幕的显示框区域，不知道为什么他不能
完全显示，而且也不能实现上下的滚动等。
也就是希望能实现在自己设定小矩形块的大小后
-00:10&&&[]
&&& 上一章中我们简单介绍了机器学习的大概情况，今天我们开始循序渐进地学习机器学习中相关的算法。在接触经典算法之前，我们先来了解下“梯度下降”算法。一、算法背景&&& 作为一个算法演示的背景，我们还是采用上一章中提到的房屋价格和房屋大小
14:13&&&[]
AOP？原来我们早就见过 最近在学习Spring，深深地感到这个框架之所以这么流行不是没有道理的，我之前一直用的是PHP，框架用的就是codeigniter，由于其简洁轻量的特性很是让人喜爱，可是也有很多问题，然而很多问题Spring都是解决了的，比如PHP项目中CodeIgniter使用的一
17:15&&&[]
