1.2 adagrad

已于 2022-09-23 22:14:43 修改
阅读量75 收藏
点赞数
分类专栏： 机器学习
于 2022-08-13 07:06:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/franny13/article/details/125766332
版权

Regression：linear model

这里用的是 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之内就可以顺利地完成了

uuuri
关注
专栏目录
AdaGrad优化器原理与代码实例讲解
AI天才研究院
08-09 715
AdaGrad优化器原理与代码实例讲解 1. 背景介绍 1.1 深度学习优化器简介 在深度学习模型的训练过程中,优化器(Optimizer)扮演着至关重要的角色。优化器通过不断调整模型参数,使得模型在训练数据上的损失函数最小化,从
AdaGrad优化器：数学模型与公式解析
AI天才研究院
08-08 596
"AdaGrad优化器：数学模型与公式解析" 1. 背景介绍 1.1 优化器在深度学习中的重要性 在深度学习中,优化器(Optimizer)扮演着至关重要的角色。它决定了模型参数如何根据损失函数的梯度
tensorflow_linear_regression_demo.py例子
01-28
官方例子，深度学习专用，机器学习专用，代码简单，一看就会(tensorflow linear regression demo)
Regression：linear model（Demo）
迷雾总会解
11-28 235
Regression：linear model 这里用的是 Adagrad ，接下来的课程会再细讲，这里只是想显示 gradient descent 实作起来没有想像的那么简单，还有很多小技巧要注意 这里采用最简单的linear model：y_data=b+w*x_data 我们要用gradient descent把b和w找出来 当然这个问题有closed-form solution，这个b和w有更简单的方法可以找出来；那我们假装不知道这件事，我们练习用gradient descent把b和w找出来
线性回归Demo
MusicDancing的博客
05-23 249
1. 相关包导入 # -*- coding: utf-8 -*- import pandas as pd import numpy as np from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LinearRegression from sklearn.metrics import me
线性回归demo
a793620101的博客
03-11 485
一个简单的线性回归的例子，可以可视化回归过程import tensorflow as tf import numpy as np import matplotlib.pyplot as pltN=500 y_point=[] x_point=[] a=0.22 b=0.62for i in range(N): x=np.random.normal(0.0,0.5) y=a*x+b+n
Adagrad优化算法：自适应学习率调整
## 1.2 Adagrad算法概述 Adagrad算法是一种自适应学习率调整的优化算法，它的核心思想是根据历史梯度信息来动态调整每个参数的学习率。这种个性化的学习率调整可以有效解决不同参数梯度变化范围差异较大的问题。 #...
优化算法：Adagrad 原理与代码实例讲解
最新发布
AI天才研究院
08-14 298
1. 背景介绍 1.1 梯度下降算法的局限性 梯度下降算法是机器学习和深度学习中常用的优化算法之一。它通过迭代地调整模型参数，以最小化损失函数。然而，传统的梯度下降算法存在一些局限性，例如： 对所有参数使用相同的学习率： 这可能导致在某
机器学习之简单线性回归demo
钱佳佳的博客
03-15 809
# -*- encoding=utf-8 -*- #简单现行回归：只有一个自变量 y=k*x+b 预测使 (y-y*)^2 最小 import numpy as np def fitSLR(x,y): n=len(x) dinominator = 0 numerator=0 for i in range(0,n): numerator += (x
LinearGradientDemo
07-17
LinearGradient线性渲染 文章解析：http://blog.csdn.net/yegucheng2618/article/details/37907149
Linear Model(Linear regression && Logistic Regression)
linlinle的博客
08-28 643
总体把握 给定d个属性描述的示例，其中为x在第i个属性上的取值，线性模型试图学得一个通过属性的线性组合来进行预测的函数,许多非线性模型(nonlinear model)可在线性模型的基础上通过引入层级结构或高维映射获得. 一.Linear regression 线性回归致力于, 均方误差是回归任务中最常用的性能度量. 基于均方误差最小化来进行模型求解的方法称为“最小二乘法”,线性回...
statsmodels.regression.linear_model.RegressionResults
博客
04-24 3476
statsmodels.regression.linear_model.RegressionResults *class statsmodels.regression.linear_model.RegressionResults(model, params, normalized_cov_params=None, scale=1.0, cov_type=‘nonrobust’, cov_kwds=...
Python 线性回归
kissazhu的博客
09-27 714
# -*- coding: utf-8 -*- """ Created on Wed Sep 20 16:46:53 2017 @author: longsheng """ import numpy as np from statsmodels import regression import statsmodels.api as sm import matplotlib.pyplot as
Statsmodels的学习(二)——Linear Regression
冬之晓
06-15 1万+
Linear Regression 基本介绍 线性回归，该标签下的函数主要处理线性模型，并且要求这些线性模型具有独立和恒等分布误差或者具有异方差或自相关的误差。 该模块允许用普通最小二乘(OLS)、加权最小二乘(WLS)、广义最小二乘(GLS)和可行的广义最小二乘(p)误差进行估计。 数学模型 这一类模型假设如下方程： Y=Xβ+μ,其中μ∼N(0,Σ)Y=Xβ+μ,其中μ...
ML：Scikit-Learn 学习笔记（4） --- Linear Regression 线性回归
MebiuW的专栏
09-01 9693
前语之前写过三篇和Scikit-Learn相关的内容，现在回来填坑了~~ 不过和之前是主要翻译官方文档的工作不同的是，从这次开始，会更加像一个技术手札，而不是翻译了：之前主要说了一个最简单的聚类方式：基于邻居的聚类，对应的，今天就聊一聊最简单的回归：线性回归。Linear Regression首先，我们要做的任务是什么呢？我也是初学者，所以就不正式的直接饮用其文档的内容了： 大致就是如
机器学习-线性回归模型python demo
杨杨杨~~的博客
06-25 613
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
线性回归模型(Linear regression model)
热门推荐
Tonywu2018的博客
10-29 1万+
绪论 在开始之前，先大致说明下机器学习中的一些大的概念及分类。 机器学习中的学习算法很多，包括线性回归、逻辑回归、随机森林、决策树、聚类、贝叶斯等等。但是这些学习算法可以归为两类，即监督学习(supervised learning)和非监督学习(unsupervised learning)；如果更加细分的话还有半监督学习。 那么监督学习和非监督学习有什么区别呢，所谓的监督学习就是学习中有训练...
线性回归 （linear regression model） 原理与代码实现
macanv的专栏
11-04 1万+
这篇博文是在总结网易公开课上ng的机器学习第二讲和周志华老师书上线性回归的个人总结。准备做一个系列笔记，希望能坚持。 代码放在文后什么是线性模型通俗一点来讲，就是我们希望用一个线性组合，来拟合我们的数据，实质上是求解输入到输出的一个线性函数的映射。当然非线性映射也是有的，比如对数线性回归。线性模型一半是监督学习。本文中讲的线性回归模型就是的。 线性模型可以干什么呢？线性模型有常见的线性回归
Struts1.2 框架学习指南
"struts1.2 学习文档" Struts1.2 是一个基于MVC（Model-View-Controller）设计模式的Java Web应用程序框架，由Apache软件基金会的Jakarta项目开发。它主要用来解决JSP Model1架构中的问题，提高了代码的组织结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值