精华内容
下载资源
问答
  • Adagrad

    千次阅读 2018-07-11 00:20:59
    Adagrad算法能够在训练中自动的对学习率进行调整,对于出现频率较低参数采用较大的α更新;相反,对于出现频率较高的参数采用较小的α更新。 因此,Adagrad非常适合处理稀疏数据。 Adagrad在每轮训练中对每个参数...
    • 在一般的梯度下降法中,对于每一个参数的训练都使用了相同的学习率α。Adagrad算法能够在训练中自动的对学习率进行调整,对于出现频率较低参数采用较大的α更新;相反,对于出现频率较高的参数采用较小的α更新
    • 因此,Adagrad非常适合处理稀疏数据
    • Adagrad在每轮训练中对每个参数θi的学习率进行更新(将每一个参数的每一次迭代的梯度取平方累加再开方,用基础学习率除以这个数),参数更新公式如下:

            

    • Gt为对角矩阵,每个对角线位置i,i为对应参数θi从第1轮到第t轮梯度的平方和。ϵ是平滑项,用于避免分母为0。
    • Adagrad的缺点是在训练的中后期,分母上梯度平方的累加将会越来越大,从而梯度趋近于0,使得训练提前结束。
    展开全文
  • 代码实现: #Adagrad v_w += tf.square(grads[0]) #求二阶动量v_w,从开始到现在梯度的平方和 v_b += tf.square(grads[1]) #求二阶动量v_b,从开始到现在梯度的平方和 w1.assign_sub(learning_rate * grads[0] ...

     tensorflow中Adagrad优化器运用

    Adagrad优化器引用API:tensorflow.keras.optimizers.Adagrad

     代码实现:

    #Adagrad

    v_w += tf.square(grads[0]) #求二阶动量v_w,从开始到现在梯度的平方和

    v_b += tf.square(grads[1]) #求二阶动量v_b,从开始到现在梯度的平方和

    w1.assign_sub(learning_rate * grads[0] / tf.sqrt(v_w)) #进行参数w1更新

    b1.assign_sub(learning_rate * grads[1] / tf.sqrt(v_b)) #进行参数b1更新

     Adagrad优化器实现iris数据集分类: 

    #导入模块
    import tensorflow as tf #导入tensorflow模块
    
    from sklearn import datasets #导入sklearn中的datasets模块,方便下载内置的iris数据集
    
    from matplotlib import pyplot as plt #导入matplotlib中的pyplot,待会画图
    
    import numpy as np #导入numpy模块做数学运算
    
    import time #导入时间模块,用来计时
    
    #导入数据
    x_data = datasets.load_iris().data #导入iris数据集的特征
    
    y_data = datasets.load_iris().target #导入iris数据集的标签
    
    #随机打乱顺序,使训练更具准确性
    np.random.seed(120)#调用numpy中的random方法里的seed方法,赋值120,使输入特征和标签能够一一对应
    
    np.random.shuffle(x_data) #调用numpy中的random方法里的shuffle方法,将训练集x_data里的特征值乱序
    
    np.random.seed(120)#调用numpy中的random方法里的seed方法,赋值120,使输入特征和标签能够一一对应
    
    np.random.shuffle(y_data) #调用numpy中的random方法里的shuffle方法,将测试集y_data里的标签乱序
    
    tf.random.set_seed(120)#调用tensorflow中的random方法里的set_seed方法,赋值120
    
    #划分数据集
    x_train = x_data[:-30] #将iris数据集(特征,共150行,此时已打乱)前120行作为训练集x_train
    
    y_train = y_data[:-30] #将iris数据集(标签,共150行,此时已打乱)前120行作为训练集y_train
    
    x_test = x_data[-30:] #将iris数据集(特征,共150行,此时已打乱)最后30行作为测试集x_test
    
    y_test = y_data[-30:] #将iris数据集(标签,共150行,此时已打乱)最后30行作为测试集y_test
    
    #转换特征值的数据类型,使之与后面数据运算时数据类型一致
    x_train = tf.cast(x_train, dtype = tf.float32) #调用tensorflow中的cast方法,将x_train中的特征值类型转换为float32
    
    x_test = tf.cast(x_test, dtype = tf.float32) #调用tensorflow中的cast方法,将x_test中的特征值类型转换为float32
    
    #用from_tensor_slices方法将特征值和标签值配对
    train_data_batch = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)#将训练集的特征x_train和标签y_train配对,用batch方法将120个训练数据分成32个为一组的批次
    
    test_data_batch = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)#将测试集的特征x_test和标签y_test配对,用batch方法将30个训练数据分成32个为一组的批次
    
    #用truncated_normal方法构建神经网络,并用Variable方法标记可训练数据
    w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev = 0.1, seed = 1))#用truncated_normal方法,构建4个输入特征,3个分类的神经网络结构,标准差为0.1的正态分布,随机种子为1
    
    b1 = tf.Variable(tf.random.truncated_normal([3], stddev = 0.1, seed = 1))#用truncated_normal方法,因为b1和w1的分类维度要一样,所以是3,标准差为0.1的正态分布,随机种子为1
    
    #设置变量
    learnRate = 0.1 #学习率为0.1
    
    train_loss_results = [] #将每轮的loss记录在此列表中,为后面画loss曲线时提供数据
    
    test_accuracy = [] #将每轮的精度accuracy记录在此列表中,为后面画精度accuracy曲线提供数据
    
    epoch = 500 #循环500轮
    
    loss_all = 0 #每轮分4个step,loss_all记录4个step生成的4个loss的和
    
    #############################################################
    #SGDM优化器参数设置
    # m_w, m_b = 0, 0 #初始化一阶动量m_w, m_b为0
    #
    # beta = 0.9 #设置超参数为0.9
    #############################################################
    #############################################################
    #Adagrad优化器参数设置
    v_w, v_b = 0, 0 #初始化二阶动量v_w, v_b
    #############################################################
    
    #训练部分
    now_time = time.time() #用时间戳记录训练起始时间now_time
    
    for epoch in range(epoch): #遍历数据集,每个epoch循环一次数据集
        for step, (x_train, y_train) in enumerate(train_data_batch): #遍历batch,每个step循环一次batch
            with tf.GradientTape() as tape: #用上下文管理器记录梯度信息
                y = tf.matmul(x_train, w1) + b1 #神经网络乘加运算,用tensorflow中的matmul方法将训练特征值x_train和w1参数进行矩阵相乘
                y = tf.nn.softmax(y) #用tensorflow中的softmax方法将神经网络乘加运算后得到的输出符合正态分布,输出和为1,可以在之后用来与独热码相减求loss
                y_one_hot = tf.one_hot(y_train, depth = 3) #用tensorflow中的one_hot方法将训练标签y_train转换为独热码格式,因为y输出为3,所以深度为3,方便接下来计算loss的和
                loss = tf.reduce_mean(tf.square(y_one_hot - y)) #用tensorflow中的reduce_mean方法求平均值,用tensorflow中的square方法求平方,这里用均方误差求损失函数loss
                loss_all += loss.numpy() #将每个step计算出的loss累加,后面可以用来求loss平均值,
    
            #计算loss对各个参数的梯度
            loss_gradient = tape.gradient(loss, [w1, b1])#用tensorflow中的GradientTape方法中的gradient方法求loss对各个参数w1,b1的梯度gradient
    
            #############################################################
            # Adagrad优化器,进行梯度更新
            v_w += tf.square(loss_gradient[0]) #求二阶动量v_w,从开始到此刻梯度的平方和
            v_b += tf.square(loss_gradient[1]) #求二阶动量v_b,从开始到此刻梯度的平方和
            w1.assign_sub(learnRate * loss_gradient[0] /tf.sqrt(v_w)) #对参数w1进行更新
            b1.assign_sub(learnRate * loss_gradient[1] / tf.sqrt(v_b)) #对参数b1进行更新
    
            #############################################################
            #############################################################
            #SGDM优化器,进行梯度更新
            # m_w = beta * m_w + (1 - beta) * loss_gradient[0] #求一阶动量m_w
            # m_b = beta * m_b + (1 - beta) * loss_gradient[1] #求一阶动量m_b
            # w1.assign_sub(learnRate * m_w) #对参数w1进行更新
            # b1.assign_sub(learnRate * m_b) #对参数b1进行更新
            #############################################################
    
            #############################################################
    
            # 梯度更新,使用了SGD(无monentum)优化器
            # w1.assign_sub(
            #     learnRate * loss_gradient[0])  # 用assign_sub方法进行自减,实现参数w1的自动更新,等价于w1 = w1 - learn_Rate * loss_gradient[0]
            # b1.assign_sub(
            #     learnRate * loss_gradient[1])  # 用assign_sub方法进行自减,实现参数b1的自动更新,等价于b = b - learn_Rate * loss_gradient[1]
    
            #############################################################
    
    
        # 每个epoch,打印loss信息
        print("epoch: {}, loss: {}".format(epoch,loss_all / 4))  # 每个epoch,打印loss信息,有4个step,所以总loss_all要除以4,求得每次step的平均loss
        train_loss_results.append(loss_all / 4)  # 用append方法将4个step的loss求平均值记录在train_loss_results中
        loss_all = 0  # loss_all归零,为下一个epoch的求loss做准备
    
        # 测试部分
        total_correct = 0  # total_correct为预测对的样本个数,初始化为0
        total_test_number = 0  # total_number为测试的总样本数,初始化为0
    
        for x_test, y_test in test_data_batch:  # 遍历训练集的特征值和标签值
            # 用更新后的参数进行预测
            y = tf.matmul(x_test, w1) + b1  # 用tensorflow中的matmul方法来进行乘加运算,再加上b1得到前向传播的结果
            y = tf.nn.softmax(y)  # 用tensorflow中的softmax方法将神经网络乘加运算后得到的前向传播的结果符合正态分布,输出和为1,可以在之后用来与独热码相减求loss
            predict = tf.argmax(y, axis=1)  # 用tensorflow中的argmax方法,返回y中最大值的索引,即预测的标签分类,axis表示按列求值
            predict = tf.cast(predict, dtype=y_test.dtype)  # 将predict的类型转换为测试集标签y_test的数据类型
            correct = tf.cast(tf.equal(predict, y_test),
                              dtype=tf.int32)  # 用tensorflow中的equal方法判断,若分类正确,则值为1,否则为0,并用tensorflow中的cast方法将bool类型转化为int32类型
            correct = tf.reduce_sum(correct)  # 用tensorflow中的reduce_sum方法将每个batch的correct数加起来
            total_correct += int(correct)  # 将所有batch中的correct数转化为int类型,并加起来
            total_test_number += x_test.shape[0]  # 用shape方法返回测试集特征x_test的行数,也就是测试的总样本数
    
        accuracy = total_correct / total_test_number  # 总的准确率
        test_accuracy.append(accuracy)  # 测试集的准确率添加到列表中来,方便记录
        print("test_accuracy:", accuracy)  # 打印测试集精度准确率
        print("-------------------------------------------------")  # 为每个epoch进行分隔,方便查看
    
    total_time = time.time() - now_time #用时间戳记录总训练时间total_time
    
    print("total_time:", total_time) #打印总训练时间total_time
    
    # 绘制loss曲线
    plt.title('Loss Function Curve')  # 用matplotlib中的title方法标出图片标题
    plt.xlabel("Epoch")  # 用matplotlib中的xlabel方法标出x轴变量名称
    plt.ylabel("Loss")  # 用matplotlib中的ylabel方法标出y轴变量名称
    plt.plot(train_loss_results, label="$Loss$")  # 用matplotlib中的plot方法逐点画出训练集损失值结果train_loss_results值并连线,连线的标签为Loss
    plt.legend()  # 用matplotlib中的legend方法画出曲线图标
    plt.show()  # 用matplotlib中的show方法画出图像
    
    # 绘制accuracy曲线
    plt.title("Accuracy Curve")  # 用matplotlib中的title方法标出图片标题
    plt.xlabel("Epoch")  # 用matplotlib中的xlabel方法标出x轴变量名称
    plt.ylabel("Accuracy")  # 用matplotlib中的ylabel方法标出y轴变量名称
    plt.plot(test_accuracy, label="$Accuracy$")  ##用matplotlib中的plot方法逐点画出测试集精准度test_accuracy值并连线,连线的标签为Accuracy
    plt.legend()  # 用matplotlib中的legend方法画出曲线图标
    plt.show()  # 用matplotlib中的show方法画出图像
    
    
    
    
    

    结果为:

    E:\Anaconda3\envs\TF2\python.exe C:/Users/Administrator/PycharmProjects/untitled8/iris数据集分类.py
    epoch: 0, loss: 0.25049660354852676
    test_accuracy: 0.7
    -------------------------------------------------
    epoch: 1, loss: 0.18857580423355103
    test_accuracy: 0.8333333333333334
    -------------------------------------------------
    epoch: 2, loss: 0.16274410113692284
    test_accuracy: 0.7666666666666667
    -------------------------------------------------
    epoch: 3, loss: 0.1484200768172741
    test_accuracy: 0.7
    -------------------------------------------------
    省略.......
    -------------------------------------------------
    epoch: 498, loss: 0.026541241444647312
    test_accuracy: 1.0
    -------------------------------------------------
    epoch: 499, loss: 0.02652033162303269
    test_accuracy: 1.0
    -------------------------------------------------
    total_time: 14.092564582824707

     

     

    展开全文
  • 这里用的是 Adagrad ,接下来的课程会再细讲,这里只是想显示 gradient descent 实作起来没有想像的那么简单,还有很多小技巧要注意 这里采用最简单的linear model:y_data=b+w*x_data 我们要用gradient descent把b...

    Regression:linear model

    如果本文对你有帮助,请给我的github打个star叭,上面附有全系列目录和内容!
    更多优质内容欢迎关注我的微信公众号“Sakura的知识库”:
    在这里插入图片描述

    这里用的是 Adagrad ,接下来的课程会再细讲,这里只是想显示 gradient descent 实作起来没有想像的那么简单,还有很多小技巧要注意

    这里采用最简单的linear model:y_data=b+w*x_data

    我们要用gradient descent把b和w找出来

    当然这个问题有closed-form solution,这个b和w有更简单的方法可以找出来;那我们假装不知道这件事,我们练习用gradient descent把b和w找出来

    数据准备:

    # 假设x_data和y_data都有10笔,分别代表宝可梦进化前后的cp值
    x_data=[338.,333.,328.,207.,226.,25.,179.,60.,208.,606.]
    y_data=[640.,633.,619.,393.,428.,27.,193.,66.,226.,1591.]
    # 这里采用最简单的linear model:y_data=b+w*x_data
    # 我们要用gradient descent把b和w找出来
    

    计算梯度微分的函数getGrad()

    # 计算梯度微分的函数getGrad()
    def getGrad(b,w):
        # initial b_grad and w_grad
        b_grad=0.0
        w_grad=0.0
        for i in range(10):
            b_grad+=(-2.0)*(y_data[i]-(b+w*x_data[i]))
            w_grad+=(-2.0*x_data[i])*(y_data[i]-(b+w*x_data[i]))
        return (b_grad,w_grad)
    

    1、自己写的版本

    当两个微分值b_grad和w_grad都为0时,gradient descent停止,b和w的值就是我们要找的最终参数

    # 这是我自己写的版本,事实证明结果很糟糕。。。
    # y_data=b+w*x_data
    # 首先,这里没有用到高次项,仅是一个简单的linear model,因此不需要regularization版本的loss function
    # 我们只需要随机初始化一个b和w,然后用b_grad和w_grad记录下每一次iteration的微分值;不断循环更新b和w直至两个微分值b_grad和w_grad都为0,此时gradient descent停止,b和w的值就是我们要找的最终参数
    
    b=-120 # initial b
    w=-4 # initial w
    lr=0.00001 # learning rate
    b_grad=0.0
    w_grad=0.0
    (b_grad,w_grad)=getGrad(b,w)
    
    while(abs(b_grad)>0.00001 or abs(w_grad)>0.00001):
        #print("b: "+str(b)+"\t\t\t w: "+str(w)+"\n"+"b_grad: "+str(b_grad)+"\t\t\t w_grad: "+str(w_grad)+"\n")
        b-=lr*b_grad
        w-=lr*w_grad
        (b_grad,w_grad)=getGrad(b,w)
    
    print("the function will be y_data="+str(b)+"+"+str(w)+"*x_data")
    
    error=0.0
    for i in range(10):
        error+=abs(y_data[i]-(b+w*x_data[i]))
    average_error=error/10
    print("the average error is "+str(average_error))
    
    the function will be y_data=-inf+nan*x_data
    the average error is nan
    

    上面的数据输出处于隐藏状态,点击即可显示

    2、这里使用李宏毅老师的demo尝试

    引入需要的库

    import matplotlib
    import matplotlib.pyplot as plt
    matplotlib.use('Agg')
    %matplotlib inline 
    import random as random
    import numpy as np
    import csv
    

    准备好b、w、loss的图像数据

    # 生成一组b和w的数据图,方便给gradient descent的过程做标记
    x = np.arange(-200,-100,1) # bias
    y = np.arange(-5,5,0.1) # weight
    Z = np.zeros((len(x),len(y))) # color
    X,Y = np.meshgrid(x,y)
    for i in range(len(x)):
        for j in range(len(y)):
            b = x[i]
            w = y[j]
            
            # Z[j][i]存储的是loss
            Z[j][i] = 0
            for n in range(len(x_data)):
                Z[j][i] = Z[j][i] + (y_data[n] - (b + w * x_data[n]))**2
            Z[j][i] = Z[j][i]/len(x_data)
    

    规定迭代次数和learning rate,进行第一次尝试

    距离最优解还有一段距离

    # y_data = b + w * x_data
    b = -120 # initial b
    w = -4 # initial w
    lr = 0.0000001 # learning rate
    iteration = 100000 # 这里直接规定了迭代次数,而不是一直运行到b_grad和w_grad都为0(事实证明这样做不太可行)
    
    # store initial values for plotting,我们想要最终把数据描绘在图上,因此存储过程数据
    b_history = [b]
    w_history = [w]
    
    # iterations
    for i in range(iteration):
        
        # get new b_grad and w_grad
        b_grad,w_grad=getGrad(b,w)
        
        # update b and w
        b -= lr * b_grad
        w -= lr * w_grad
        
        #store parameters for plotting
        b_history.append(b)
        w_history.append(w)
    
    # plot the figure
    plt.contourf(x,y,Z,50,alpha=0.5,cmap=plt.get_cmap('jet'))
    plt.plot([-188.4],[2.67],'x',ms=12,markeredgewidth=3,color='orange')
    plt.plot(b_history,w_history,'o-',ms=3,lw=1.5,color='black')
    plt.xlim(-200,-100)
    plt.ylim(-5,5)
    plt.xlabel(r'$b$',fontsize=16)
    plt.ylabel(r'$w$',fontsize=16)
    plt.show()
    

    把learning rate增大10倍尝试

    发现经过100000次的update以后,我们的参数相比之前与最终目标更接近了,但是这里有一个剧烈的震荡现象发生

    # 上图中,gradient descent最终停止的地方里最优解还差很远,
    # 由于我们是规定了iteration次数的,因此原因应该是learning rate不够大,这里把它放大10倍
    
    # y_data = b + w * x_data
    b = -120 # initial b
    w = -4 # initial w
    lr = 0.000001 # learning rate 放大10倍
    iteration = 100000 # 这里直接规定了迭代次数,而不是一直运行到b_grad和w_grad都为0(事实证明这样做不太可行)
    
    # store initial values for plotting,我们想要最终把数据描绘在图上,因此存储过程数据
    b_history = [b]
    w_history = [w]
    
    # iterations
    for i in range(iteration):
        
        # get new b_grad and w_grad
        b_grad,w_grad=getGrad(b,w)
        
        # update b and w
        b -= lr * b_grad
        w -= lr * w_grad
        
        #store parameters for plotting
        b_history.append(b)
        w_history.append(w)
    
    # plot the figure
    plt.contourf(x,y,Z,50,alpha=0.5,cmap=plt.get_cmap('jet'))
    plt.plot([-188.4],[2.67],'x',ms=12,markeredgewidth=3,color='orange')
    plt.plot(b_history,w_history,'o-',ms=3,lw=1.5,color='black')
    plt.xlim(-200,-100)
    plt.ylim(-5,5)
    plt.xlabel(r'$b$',fontsize=16)
    plt.ylabel(r'$w$',fontsize=16)
    plt.show()
    

    把learning rate再增大10倍

    发现此时learning rate太大了,参数一update,就远远超出图中标注的范围了

    所以我们会发现一个很严重的问题,如果learning rate变小一点,他距离最佳解还是会具有一段距离;但是如果learning rate放大,它就会直接超出范围了

    # 上图中,gradient descent最终停止的地方里最优解还是有一点远,
    # 由于我们是规定了iteration次数的,因此原因应该是learning rate还是不够大,这里再把它放大10倍
    
    # y_data = b + w * x_data
    b = -120 # initial b
    w = -4 # initial w
    lr = 0.00001 # learning rate 放大10倍
    iteration = 100000 # 这里直接规定了迭代次数,而不是一直运行到b_grad和w_grad都为0(事实证明这样做不太可行)
    
    # store initial values for plotting,我们想要最终把数据描绘在图上,因此存储过程数据
    b_history = [b]
    w_history = [w]
    
    # iterations
    for i in range(iteration):
        
        # get new b_grad and w_grad
        b_grad,w_grad=getGrad(b,w)
        
        # update b and w
        b -= lr * b_grad
        w -= lr * w_grad
        
        #store parameters for plotting
        b_history.append(b)
        w_history.append(w)
    
    # plot the figure
    plt.contourf(x,y,Z,50,alpha=0.5,cmap=plt.get_cmap('jet'))
    plt.plot([-188.4],[2.67],'x',ms=12,markeredgewidth=3,color='orange')
    plt.plot(b_history,w_history,'o-',ms=3,lw=1.5,color='black')
    plt.xlim(-200,-100)
    plt.ylim(-5,5)
    plt.xlabel(r'$b$',fontsize=16)
    plt.ylabel(r'$w$',fontsize=16)
    plt.show()
    

    这个问题明明很简单,可是只有两个参数b和w,gradient descent搞半天都搞不定,那以后做neural network有数百万个参数的时候,要怎么办呢
    这个就是一室不治何以国家为的概念

    于是这里就要放大招了!!!——Adagrad

    我们给b和w客制化的learning rate,让它们两个的learning rate不一样

    # 这里给b和w不同的learning rate 
    
    # y_data = b + w * x_data
    b = -120 # initial b
    w = -4 # initial w
    lr = 1 # learning rate 放大10倍
    iteration = 100000 # 这里直接规定了迭代次数,而不是一直运行到b_grad和w_grad都为0(事实证明这样做不太可行)
    
    # store initial values for plotting,我们想要最终把数据描绘在图上,因此存储过程数据
    b_history = [b]
    w_history = [w]
    
    lr_b = 0
    lr_w = 0
    
    # iterations
    for i in range(iteration):
        
        # get new b_grad and w_grad
        b_grad,w_grad=getGrad(b,w)
        
        # get the different learning rate for b and w
        lr_b = lr_b + b_grad ** 2
        lr_w = lr_w + w_grad ** 2
        
        # 这一招叫做adagrad,之后会详加解释
        # update b and w with new learning rate
        b -= lr / np.sqrt(lr_b) * b_grad
        w -= lr / np.sqrt(lr_w) * w_grad
        
        #store parameters for plotting
        b_history.append(b)
        w_history.append(w)
        
        # output the b w b_grad w_grad
        # print("b: "+str(b)+"\t\t\t w: "+str(w)+"\n"+"b_grad: "+str(b_grad)+"\t\t w_grad: "+str(w_grad)+"\n")
        
    # output the final function and its error
    print("the function will be y_data="+str(b)+"+"+str(w)+"*x_data")
    error=0.0
    for i in range(10):
        print("error "+str(i)+" is: "+str(np.abs(y_data[i]-(b+w*x_data[i])))+" ")
        error+=np.abs(y_data[i]-(b+w*x_data[i]))
    average_error=error/10
    print("the average error is "+str(average_error))
    
    # plot the figure
    plt.contourf(x,y,Z,50,alpha=0.5,cmap=plt.get_cmap('jet'))
    plt.plot([-188.4],[2.67],'x',ms=12,markeredgewidth=3,color='orange')
    plt.plot(b_history,w_history,'o-',ms=3,lw=1.5,color='black')
    plt.xlim(-200,-100)
    plt.ylim(-5,5)
    plt.xlabel(r'$b$',fontsize=16)
    plt.ylabel(r'$w$',fontsize=16)
    plt.show()
    
    the function will be y_data=-188.3668387495323+2.6692640713379903*x_data
    error 0 is: 73.84441736270833 
    error 1 is: 67.4980970060185 
    error 2 is: 68.15177664932844 
    error 3 is: 28.8291759825683 
    error 4 is: 13.113158627146447 
    error 5 is: 148.63523696608252 
    error 6 is: 96.43143001996799 
    error 7 is: 94.21099446925288 
    error 8 is: 140.84008808876973 
    error 9 is: 161.7928115187101 
    the average error is 89.33471866905532
    

    有了新的learning rate以后,从初始值到终点,我们在100000次iteration之内就可以顺利地完成了

    “GitAds”/

    展开全文
  • 目录说明配置环境此节说明代码 说明 本博客代码来自开源项目:《动手学深度学习》(PyTorch版) 并且在博主学习的理解上对代码进行了大量注释,方便理解各个函数的原理和用途 配置环境 使用环境:python3.8 平台:...

    说明

    本博客代码来自开源项目:《动手学深度学习》(PyTorch版)
    并且在博主学习的理解上对代码进行了大量注释,方便理解各个函数的原理和用途

    配置环境

    使用环境:python3.8
    平台:Windows10
    IDE:PyCharm

    此节说明

    此节对应书本上7.5节
    此节功能为:AdaGrad算法
    由于次节相对容易理解,代码注释量较少

    代码

    # 本书链接https://tangshusen.me/Dive-into-DL-PyTorch/#/
    # 7.5 AdaGrad算法
    # 注释:黄文俊
    # E-mail:hurri_cane@qq.com
    
    from matplotlib import pyplot as plt
    import numpy as np
    import torch
    import math
    import sys
    sys.path.append("..")
    import d2lzh_pytorch as d2l
    
    
    # AdaGrad算法,它根据自变量在每个维度的梯度值的大小来调整各个维度上的学习率,从而避免统一的学习率难以适应所有维度的问题
    # 如果目标函数有关自变量中某个元素的偏导数一直都较大,那么该元素的学习率将下降较快
    
    def adagrad_2d(x1, x2, s1, s2):
        g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6  # 前两项为自变量梯度
        s1 += g1 ** 2
        s2 += g2 ** 2
        x1 -= eta / math.sqrt(s1 + eps) * g1
        x2 -= eta / math.sqrt(s2 + eps) * g2
        return x1, x2, s1, s2
    
    def f_2d(x1, x2):
        return 0.1 * x1 ** 2 + 2 * x2 ** 2
    
    eta = 0.4
    d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))
    
    plt.show()
    
    eta = 2
    d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))
    plt.show()
    
    # 7.5.3 从零开始实现
    features, labels = d2l.get_data_ch7()
    
    def init_adagrad_states():
        s_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
        s_b = torch.zeros(1, dtype=torch.float32)
        return (s_w, s_b)
    
    def adagrad(params, states, hyperparams):
        eps = 1e-6
        for p, s in zip(params, states):
            s.data += (p.grad.data**2)
            p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)
    
    d2l.train_ch7(adagrad, init_adagrad_states(), {'lr': 0.1}, features, labels)
    plt.show()
    
    # 简洁实现
    d2l.train_pytorch_ch7(torch.optim.Adagrad, {'lr': 0.1}, features, labels)
    plt.show()
    
    print("*"*50)
    
    展开全文
  • 有一篇不错的blog描述梯度下降的方法。...adagrad_solver.cpp: #include #include "caffe/sgd_solvers.hpp" namespace caffe { #ifndef CPU_ONLY template void adagrad_update_gpu(int N, Dtype*
  • 文章目录梯度下降(Gradient Descent )带动量的梯度下降(Gradient Descent + Momentum)Nesterov MomentumAdaGradRMSPropAdam 梯度下降(Gradient Descent ) x:=x−α⋅dxx := x-\alpha \cdot {\rm{d}}xx:=x−...
  • 下面是改进后的梯度下降(修改后半段代码): # 版本2-优化模型使得b,w的learning rate不一样(adagrad方法) b = -120 w = -4 # learning rate(步长) # 改进四 lr = 1 iteration = 100000 b_history = [b] w_history...
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、...
  • eps项是避免adagrad的分母为0而加的''' dim=18*9+1 w=np.zeros([dim,1]) x=np.concatenate((np.ones([12*471,1]),x),axis=1).astype(float) learning_rate=100 iter_time=1000 adagrad=np.zeros([dim,1]) eps=0....
  • ADaGrad算法的理解

    2021-04-06 20:59:22
    AdaGrad算法 作用:独立地适应模型的每个参数:具有较大偏导的参数相应有一个较大的学习率,而具有小偏导的参数则对应一个较小的学习率 通过下面公式调整学习率 这里的学习率其实没有被更新而是每次应用时被缩放 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,763
精华内容 1,905
关键字:

adagrad代码