目录

梯度上升算法：

代码：

随机梯度上升算法：

代码：

实验：

做图代码：

疑问：

1.梯度上升算法不适应大的数据集，改用随机梯度上升更合适。

2.改进过的随机梯度算法，w vs epoch曲线出现波动。

代码实现时遇到的问题

1.对随机的理解，随机过的样本不再参与随机？

 2.数组越界

实验结果： 

---

Logistic回归实现二分类：http://t.csdnimg.cn/eEEjF

学习资料：Peter Harrington 机器学习实战

梯度上升算法：

如下，每更新一次权重需要计算所有样本（train_X）和权重乘积的sigmoid值。

对于m行n列特征矩阵和n行权重，迭代次数epoch,计算复杂度为O(n*m*epoch)，w迭代次数为epoch.

代码：

def grad(train_X,train_y):
    # 100*3
    m,n = len(train_X[:,0]),len(train_X[0])
    #3x1 
    weight=np.ones((n,1))
    #迭代系数
    epoch=500
    for i in range(epoch):
        # mxn nx1 ->m*1
        y_=sigmoid(np.dot(train_X,weight))
        # m*1
        loss = train_y -y_
        a = 0.01
        # 3*1 
        weight = weight - np.dot(a*train_X.transpose(),loss)
    return weight

随机梯度上升算法：

每计算一次样本更新一次权重。

代码：

def grad(train_X,train_y):
    # 100*3
    m,n = len(train_X[:,0]),len(train_X[0])
    #3x1 
    weight=np.ones((n,1))
    # 每个样本更新权重一次，故使用m
    for i in range(m):
        # mxn nx1 ->m*1
        # y_=sigmoid(np.dot(train_X,weight))
        # 1xn nx1 -->1x1
        #(3,)表示只有一个维度，在这个维度上有三个数字
        y_=sigmoid(sum(np.dot(train_X[i].reshape(1,n),weight)))
        # 1x1
        loss = train_y[i] -y_
        a = 0.01
        # nx1 1xn 1x1 nx1 1x1
        weight = weight + a*np.dot(train_X[i].transpose().reshape(n,1),loss.reshape(1,1))
    return weight

使用这种方法实现的分类效果相较之前效果变差了，应该是w迭代次数不够，为了查看何时收敛，查看w和epoch的变化关系图。

梯度上升	随机梯度上升

实验：

使用随机梯度算法：研究w和epoch的关系，epoch表示迭代数据集的次数.

分别为权重为w[0]，w[1]，w[2]。

可以看出w0收敛很快，w1和w2需要更多时间才能实现收敛.

 

 

发现w大概到epoch=200处收敛，设置遍历数据集200次得到新图像基本和梯度算法基本一致：

做图代码：

def grad(train_X,train_y):
    # 100*3
    m,n = len(train_X[:,0]),len(train_X[0])
    #3x1 
    weight=np.ones((n,1))
    #迭代系数
    epoch=500
    w=[]
    # lineArr.append(float(currLine[i]))
    #100x100次
    for j in range(epoch):
        for i in range(m):
            # mxn nx1 ->m*1
            # y_=sigmoid(np.dot(train_X,weight))
            # 1xn nx1 -->1x1
            #(3,)表示只有一个维度，在这个维度上有三个数字
            y_=sigmoid(sum(np.dot(train_X[i].reshape(1,n),weight)))
            # 1x1
            loss = train_y[i] -y_
            a = 0.01
            # nx1 1xn 1x1 nx1 1x1
            weight = weight + a*np.dot(train_X[i].transpose().reshape(n,1),loss.reshape(1,1))
        w.append(weight)
    w0=[row[0] for row in w]
    w1=[row[1] for row in w]
    w2=[row[2] for row in w]
    epochlist =list(range(1,epoch+1,1))
    plt.plot(epochlist,w0)    

    plt.xlabel('gradw')
    plt.ylabel('epoch')
    plt.legend()
    plt.title("w[0] vs epoch")
    plt.show()

    plt.plot(epochlist,w1)    

    plt.xlabel('gradw')
    plt.ylabel('epoch')
    plt.legend()
    plt.title("w[1] vs epoch")
    plt.show()

    plt.plot(epochlist,w2)    

    plt.xlabel('gradw')
    plt.ylabel('epoch')
    plt.legend()
    plt.title("w[2] vs epoch")
    plt.show()
    return weight

疑问：

1.梯度上升算法不适应大的数据集，改用随机梯度上升更合适。

书中提到：数据量大的话不太方便，所以想到每计算一次样本更新一次权重,也就是随机梯度上升算法。但是计算每个样本迭代的权重，再遍历全部样本，不就是把矩阵乘法拆开算吗，我不理解，感觉没有提升运算效率的作用。

2.改进过的随机梯度算法，w vs epoch曲线出现波动。

我感觉这个第一个随机梯度上升法完全没有体现随机性，随机应该随机抽取训练集的的子集来更新回归系数吧。

 书里有提到随机梯度算法的改进：

2.1.学习率随着迭代次数增加应该减小，能缓解高频波动。（不过我的实验在第一个梯度上升没有出现高频波动，改进后反而出现了。）

2.2.随机抽取样本进行类别预测，loss计算和更新权重。

randIndex是0-len(dataIndex)的随机值；去掉dataIndex[randIndex]的值

但是这个randIndex和dataIndex为什么这么写，不太理解.

def grad(train_X,train_y):
    m,n = len(train_X[:,0]),len(train_X[0])

    weight=np.ones((n,1))
    epoch=50
    w=[]
    for j in range(epoch):
        #[0,1,2,,,m-1]对应train_X的索引
        dataIndex = list(range(m))
        for i in range(m):
            #随着迭代次数增加，减小学习率
            alpha = 4/(1.0+j+i)+0.0001 
            #在dataIndex中取随机样本的索引
            
            randIndex = int(random.uniform(0,len(dataIndex)))
           
            y_=sigmoid(sum(np.dot(train_X[randIndex].reshape(1,n),weight)))
            loss = train_y[i] -y_
            weight = weight + alpha*np.dot(train_X[i].transpose().reshape(n,1),loss.reshape(1,1))
            #去掉计算过的样本
            del(dataIndex[randIndex])
       
    return weight

代码实现时遇到的问题

1.对随机的理解，随机过的样本不再参与随机？

从dataIndex中随机取值，作为随机数；去掉dataIndex中被选过的值，即随机过的样本不再参与随机了。

randIndex = random.choice(dataIndex)
dataIndex.remove(randIndex)

 2.数组越界

代码错误：取0-len(dataIndex)的值作为索引，拿到randIndex的随机值；但是去掉索引为randIndex对应的值

dataIndex=[0,1,2,,,80] len=81 假设去掉了dataIndex[79]=79,

dataIndex=[0,1,2,,,78,80] len=80 取79 randIndex=dataIndex[79]=80 去掉randIndex[80]数组越界

就可能出现越界：

randIndex = dataIndex[int(random.uniform(0,len(dataIndex)))]
del(dataIndex[randIndex])

实验结果： 

w和epoch关系：

w1，w2收敛速度更慢了，w0的波动非常明显，感觉效果比改进前还差，这算法我学不明白。