使用Scipy优化梯度下降问题

已于 2023-10-06 12:13:51 修改
阅读量1.3k 收藏 3
点赞数
文章标签： 机器学习 人工智能
于 2023-10-06 12:04:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72678953/article/details/133606066
版权

目    录

问题重述

附加问题

步骤实施

1.查看Scipy官网SciPy，找到优化有关的模块（Optimize）

2.研究多种优化策略，选择最符合代码的方案进行优化

3.minimize函数参数及其返回值

4.代码展示

5.结果展示

6.进一步优化

6.1对如下函数方法进行优化

6.2基准测试

6.3 发现

测试文件附录

任务清单

问题重述

在二维平面有n个点，如何画一条直线，使得所有点到该直线距离之和最短

如果能找到，请给出其损失函数

附加问题

1.使用Scipy优化上述问题

2.主代码中不得出现任何循环语法，出现一个扣10分

步骤实施

1.查看Scipy官网SciPy，找到优化有关的模块（Optimize）

2.研究多种优化策略，选择最符合代码的方案进行优化

优化方法
名称特点应用场景
Scalar Functions Optimization用于最小化或最大化单个标量函数的，通常用于解决一维问题目标函数只返回一个标量（单个值）
Local (Multivariate) Optimization适用于多变量问题，需要梯度函数，不过会自动寻找梯度更新目标值在参数空间中找到局部最小值或最大值
Global Optimization寻找函数的全局最小值或最大值，包含多个局部最值在计算条件允许的条件下可以得到全局最优解

优化方法
序号名称使用方法适用条件
1Nelder-MeadNelder-Mead单纯形法适用于一般的非线性问题
2PowellPowell方法适合多维非约束优化的方法
3CG共轭梯度法（Conjugate Gradient）适用于二次优化问题或大规模问题
4BFGS拟牛顿BFGS算法适用于大多数非线性优化问题的常用方法，尤其是当梯度信息可用时
5Newton-CG牛顿共轭梯度法适用于大多数非线性优化问题，但相对于BFGS需要更多的内存
6L-BFGS-B限制内存BFGS算法适用于大规模问题，因为它限制了内存使用
7TNC截断牛顿法适用于大多数非线性优化问题，并且能够处理约束条件
8COBYLA约束优化适用于具有约束条件的问题
9SLSQP顺序最小二乘法适用于具有约束条件的问题，并且能够处理线性和非线性约束
10trust-constr信任区域约束优化方法适用于有约束条件的问题，并且可以处理线性和非线性约束
11dogleg信任域Dogleg方法适用于具有约束条件的问题
12trust-ncg信任区域牛顿共轭梯度法适用于约束优化问题
13trust-krylov信任区域Krylov子空间法适用于约束优化问题
14trust-exact精确信任区域方法适用于约束优化问题

 此问题我们需要求最小值，所以我们采用minimize函数，并选择常用的BFGS策略

3.minimize函数参数及其返回值

原型如下：

scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)

挑五个主要的参数讲

1.fun：需要最小化的目标函数

这个函数应该接受一个输入向量，返回一个标量（单个值），表示损失函数的值。

2.x0：起始参数的初始猜测值

通常是一个数组或列表，表示参数的初始估计。

3.args：传递给目标函数的额外参数的元组

如果目标函数需要额外的参数，可以将它们作为元组传递给args参数。

4.method：选择优化方法的字符串

这是一个可选参数，如果未指定，默认使用'Nelder-Mead'方法。可以选择其他方法，

5.jac：表示目标函数的梯度（导数）的函数

如果提供了梯度函数，通常可以加速优化过程。如果不提供，优化算法会尝试数值估计梯度。

所以我们在优化代码的时候，

可以将 calcLoseFunction函数作为fun，

而k,b两个参数打成列表作为x0，

将XData,YData组成元组传递给arg

method选择BFGS

最后jac选择不写，便于对比两者速度差异

其返回值说明如下

1.x：优化的参数值。这是一个数组，包含找到的最优参数。

2.fun：最小化目标函数的最小值（损失函数的最小值）。

3.success：一个布尔值，表示优化是否成功收敛到最小值。

4.message：一个字符串，描述优化的终止消息。

5.nit：迭代次数，表示优化算法运行的迭代次数。

6.nfev：函数调用次数，表示评估目标函数的次数。

7.njev：梯度计算次数，表示计算目标函数梯度的次数（如果提供了梯度函数）。

8.hess_inv：Hessian矩阵的逆矩阵（如果提供了Hessian信息）。

9.jac：目标函数的梯度值。

4.代码展示

import numpy #发现直接用List就行了
import random
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from commonTools import *
# random.random()
# random.randint(start,stop)
#################全局数据定义区
# 数组大小
listSize=10
# 定义学习率 取尽量小0.001
learningRate=0.0001
#定义初始直线的 斜率k 和 截距b 45° 1单位距离
# 现在设置 k=0.5 检验程序
k,b=0.5,1
initialParams=[k,b]
#定义迭代次数
bfsNums=9999
#################全局数据定义区END
# 生成随机数
def generateRandomInteger(start, end):
    # [1-100]
    return random.randint(start, end)

# 打印本次随机生成的X,Y 便于快速粘贴复现
def printXYArray(XData,YData):
    # 打印X
    print("[", ",".join([str(i) for i in XData]), "]")
    # 打印Y
    print("[", ",".join([str(i) for i in YData]), "]")

#调用公共模块进行打印 便于快速查看粘贴
def printXYData(XData,YData):
    loc=locals()
    printArray(XData,loc)
    printArray(YData,loc)
# 最小二乘法定义损失函数 并计算
#参考链接：https://blog.csdn.net/zy_505775013/article/details/88683460
# 求最小二乘法的最小值 最终结果应当是在learningRate一定情况下  这个最小的sum
def calcLoseFunction(params,XData,YData):
    k, b = params
    sum=0
    for i in range(0,listSize):
        # 使用偏离值的平方进行累和
        sum+=(YData[i]-(k*XData[i]+b))**2
    return sum

#梯度下降法
def calcGradientCorrection(b, k, XData, YData, learningRate, bfsNums):
    for i in range(0, bfsNums):
        sumk, sumb = 0, 0
        for j in range(0, listSize):
            # 定义预测值Y'
            normalNum = k * XData[j] + b
            # 计算逆梯度累和
            sumk += -(2 / listSize) * (normalNum - YData[j]) * XData[j]
            sumb += -(2 / listSize) * (normalNum - YData[j])
        # 在逆梯度的方向上进行下一步搜索
        k += learningRate * sumk
        b += learningRate * sumb
    return k, b

# 随机生成横坐标
XData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 随机生成纵坐标
YData=[XData[i]+generateRandomInteger(-10,10) for i in range(listSize) ]
# 纯随机生成 但是可视化效果不直观
# YData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 死值替换区
# XData=testArrayX
# YData=testArrayY

print("初始选取k={},b={}的情况下的损失函数值为sum={}".format(k,b,calcLoseFunction(initialParams,XData,YData)))
# 对k,b进行梯度修正
# k,b=calcGradientCorrection(b,k,XData,YData,learningRate,bfsNums)
#使用Scipy进行求解
result = minimize(calcLoseFunction, initialParams, args=(XData, YData), method='BFGS')
resultk,resultb=result.x
print("修正后：k={},b={},最小损失sum={},最小二乘法损失sums={}".format(resultk,resultb,result.fun,calcLoseFunction([resultk,resultb],XData,YData)))
print("调试数组")
printXYArray(XData,YData)

#画图
plt.plot(XData, YData, 'b.')
plt.plot(XData, resultk*numpy.array(XData)+resultb, 'r')
plt.show()
print("END")

5.结果展示

6.进一步优化

两个目标

1.优化损失函数中的for循环

2.对使用Scipy优化前后的代码进行基准测试，比较运行速度

6.1对如下函数方法进行优化
def calcLoseFunction(params,XData,YData):
    k, b = params
    sum=0
    for i in range(0,listSize):
        # 使用偏离值的平方进行累和
        sum+=(YData[i]-(k*XData[i]+b))**2
    return sum

使用numpy，优化后如下：

def calcLoseFunction(params,XData,YData):
    XData,YData=np.array(XData),np.array(YData)
    k, b = params
    sum=np.sum((YData - (k * XData + b))**2)
    return sum

无for优化后代码如下：

import numpy as np
import random
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from commonTools import *

#################全局数据定义区
# 数组大小
listSize=10
#定义初始直线的 斜率k 和 截距b 45° 1单位距离
# 现在设置 k=0.5 检验程序
k,b=0.5,1
initialParams=[k,b]
#################全局数据定义区END
# 生成随机数
def generateRandomInteger(start, end):
    return random.randint(start, end)

#调用公共模块进行打印 便于快速查看粘贴
def printXYData(XData,YData):
    loc=locals()
    printArray(XData,loc)
    printArray(YData,loc)

# 最小二乘法定义损失函数 并计算
def calcLoseFunction(params,XData,YData):
    XData,YData=np.array(XData),np.array(YData)
    k, b = params
    sum=np.sum((YData - (k * XData + b))**2)
    return sum

# 随机生成横坐标
XData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 随机生成纵坐标
YData=[XData[i]+generateRandomInteger(-10,10) for i in range(listSize) ]
# 纯随机生成 但是可视化效果不直观
# YData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 死值替换区
# XData=[ 49,74,62,54,20,14,27,74,23,50 ]
# YData=[ 47,65,56,57,21,21,32,81,27,46 ]

print("初始选取k={},b={}的情况下的损失函数值为sum={}".format(k,b,calcLoseFunction(initialParams,XData,YData)))

#使用Scipy进行求解
result = minimize(calcLoseFunction, initialParams, args=(XData, YData), method='BFGS')
resultk,resultb=result.x
print("修正后：k={},b={},最小损失sum={},最小二乘法损失sums={}".format(resultk,resultb,result.fun,calcLoseFunction([resultk,resultb],XData,YData)))
print("调试数组")
printXYData(XData,YData)

#画图
plt.plot(XData, YData, 'b.')
plt.plot(XData, resultk*np.array(XData)+resultb, 'r')
plt.show()
print("END")

其中公共模块commonTools.py 代码如下：

#########导包区

#########说明
#1.想要在公共模块区域使用变量列表 必须传进来 因为彼此的变量作用域不同


#########公共变量定义区
#这个locals应该是被引入的界面传进来，而不是从这拿
# loc=locals()

#########函数书写区
#1.获取变量名称
def getVariableName(variable,loc):
    for k,v in loc.items():
        if loc[k] is variable:
            return k

#附带的打印变量名
def printValue(object,loc):
    print("变量{}的值是{}".format(getVariableName(object,loc),object))

# 2.组装列表为字符串
def mergeInSign(dataList,sign):
    # print(str(sign).join([str(i) for i in dataList]))
    return str(sign).join([str(i) for i in dataList])

# 3.打印一个列表
def printArray(dataArray,loc):
    print("列表{}的内容是：".format(getVariableName(dataArray,loc)),\
          "[", ",".join([str(i) for i in dataArray]), "]"\
          )

原先的代码如下：

import numpy #发现直接用List就行了
import random
import matplotlib.pyplot as plt
# random.random()
# random.randint(start,stop)
#################全局数据定义区
# 数组大小
listSize=10
# 定义学习率 取尽量小0.001
learningRate=0.0001
#定义初始直线的 斜率k 和 截距b 45° 1单位距离
# 现在设置 k=0.5 检验程序
k,b=0.5,1
#定义迭代次数
bfsNums=9999
#################全局数据定义区END
# 生成随机数
def generateRandomInteger(start, end):
    # [1-100]
    return random.randint(start, end)
 
# 打印本次随机生成的X,Y 便于快速粘贴复现
def printXYArray(XData,YData):
    # 打印X
    print("[", ",".join([str(i) for i in XData]), "]")
    # 打印Y
    print("[", ",".join([str(i) for i in YData]), "]")
 
# 最小二乘法定义损失函数 并计算
#参考链接：https://blog.csdn.net/zy_505775013/article/details/88683460
# 求最小二乘法的最小值 最终结果应当是在learningRate一定情况下  这个最小的sum
def calcLoseFunction(k,b,XData,YData):
    sum=0
    for i in range(0,listSize):
        # 使用偏离值的平方进行累和
        sum+=(YData[i]-(k*XData[i]+b))**2
    return sum
 
#梯度下降法
def calcGradientCorrection(b, k, XData, YData, learningRate, bfsNums):
    for i in range(0, bfsNums):
        sumk, sumb = 0, 0
        for j in range(0, listSize):
            # 定义预测值Y'
            normalNum = k * XData[j] + b
            # 计算逆梯度累和  注意这里求偏导应当是两倍 不知道为什么写成1了
            # 求MSE的偏导
            sumk += -(2 / listSize) * (normalNum - YData[j]) * XData[j]
            sumb += -(2 / listSize) * (normalNum - YData[j])
        # 在逆梯度的方向上进行下一步搜索
        k += learningRate * sumk
        b += learningRate * sumb
    return k, b
 
# 随机生成横坐标
XData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 随机生成纵坐标
YData=[XData[i]+generateRandomInteger(-10,10) for i in range(listSize) ]
# 纯随机生成 但是可视化效果不直观
# YData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 死值替换区
# XData=testArrayX
# YData=testArrayY
 
print("初始选取k={},b={}的情况下的损失函数值为sum={}".format(k,b,calcLoseFunction(k,b,XData,YData)))
# 对k,b进行梯度修正
k,b=calcGradientCorrection(b,k,XData,YData,learningRate,bfsNums)
print("修正后：k={},b={},最小损失sum={}".format(k,b,calcLoseFunction(k,b, XData, YData)))
print("调试数组")
printXYArray(XData,YData)
 
#画图
plt.plot(XData, YData, 'b.')
plt.plot(XData, k*numpy.array(XData)+b, 'r')
plt.show()
print("END")

 到此，使用scipy并对for循环进行优化已经完成，下面我们使用程序对比优化后时间效率上有没有改进。

6.2基准测试

我们将先后代码的画图部分都注释

目录结构如下：

 test.py代码如下：

import os       #执行调用
import time     #记录时间
DEBUG=False
execFileName="old.py" if DEBUG else "new.py"

if __name__=="__main__":
    startTime = time.time()
    os.system("python {}".format(execFileName))
    endTime = time.time()
    print("文件：{}执行耗时：{}ms".format(execFileName,endTime-startTime))

DEBUG为False

DEBUG为True

额，调用minimize函数在时间上不如自己写的梯度下降。。。。。

多次随机测试后发现结果依旧如此，可能是因为scipy引入了其他策略，导致了执行时间变长

6.3 发现

使用scipy在某种程度上可能能优化执行效率，但是在部分情况下可能耗时会略长于基本实现

测试文件附录

commonTools.py

#########导包区

#########说明
#1.想要在公共模块区域使用变量列表 必须传进来 因为彼此的变量作用域不同


#########公共变量定义区
#这个locals应该是被引入的界面传进来，而不是从这拿
# loc=locals()

#########函数书写区
#1.获取变量名称
def getVariableName(variable,loc):
    for k,v in loc.items():
        if loc[k] is variable:
            return k

#附带的打印变量名
def printValue(object,loc):
    print("变量{}的值是{}".format(getVariableName(object,loc),object))

# 2.组装列表为字符串
def mergeInSign(dataList,sign):
    # print(str(sign).join([str(i) for i in dataList]))
    return str(sign).join([str(i) for i in dataList])

# 3.打印一个列表
def printArray(dataArray,loc):
    print("列表{}的内容是：".format(getVariableName(dataArray,loc)),\
          "[", ",".join([str(i) for i in dataArray]), "]"\
          )

test.py

import os       #执行调用
import time     #记录时间
DEBUG=True
execFileName="old.py" if DEBUG else "new.py"

if __name__=="__main__":
    startTime = time.time()
    os.system("python {}".format(execFileName))
    endTime = time.time()
    print("文件：{}执行耗时：{}ms".format(execFileName,endTime-startTime))

new.py

import numpy as np
import random
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from commonTools import *

#################全局数据定义区
# 数组大小
listSize=10
#定义初始直线的 斜率k 和 截距b 45° 1单位距离
# 现在设置 k=0.5 检验程序
k,b=0.5,1
initialParams=[k,b]
#################全局数据定义区END
# 生成随机数
def generateRandomInteger(start, end):
    return random.randint(start, end)

#调用公共模块进行打印 便于快速查看粘贴
def printXYData(XData,YData):
    loc=locals()
    printArray(XData,loc)
    printArray(YData,loc)

# 最小二乘法定义损失函数 并计算
def calcLoseFunction(params,XData,YData):
    XData,YData=np.array(XData),np.array(YData)
    k, b = params
    sum=np.sum((YData - (k * XData + b))**2)
    return sum

# # 随机生成横坐标
# XData=[generateRandomInteger(1,100) for i in range(listSize) ]
# # 随机生成纵坐标
# YData=[XData[i]+generateRandomInteger(-10,10) for i in range(listSize) ]
# 纯随机生成 但是可视化效果不直观
# YData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 死值替换区
XData=[ 49,74,62,54,20,14,27,74,23,50 ]
YData=[ 47,65,56,57,21,21,32,81,27,46 ]

print("初始选取k={},b={}的情况下的损失函数值为sum={}".format(k,b,calcLoseFunction(initialParams,XData,YData)))

#使用Scipy进行求解
result = minimize(calcLoseFunction, initialParams, args=(XData, YData), method='BFGS')
resultk,resultb=result.x
print("修正后：k={},b={},最小损失sum={},最小二乘法损失sums={}".format(resultk,resultb,result.fun,calcLoseFunction([resultk,resultb],XData,YData)))
print("调试数组")
printXYData(XData,YData)

#画图
# plt.plot(XData, YData, 'b.')
# plt.plot(XData, resultk*np.array(XData)+resultb, 'r')
# plt.show()
print("END")

old.py 

import numpy  # 发现直接用List就行了
import random
import matplotlib.pyplot as plt
from commonTools import *
# random.random()
# random.randint(start,stop)
#################全局数据定义区
# 数组大小
listSize = 10
# 定义学习率 取尽量小0.001
learningRate = 0.0001
# 定义初始直线的 斜率k 和 截距b 45° 1单位距离
# 现在设置 k=0.5 检验程序
k, b = 0.5, 1
# 定义迭代次数
bfsNums = 9999


#################全局数据定义区END
# 生成随机数
def generateRandomInteger(start, end):
    # [1-100]
    return random.randint(start, end)

# 打印本次随机生成的X,Y 便于快速粘贴复现
def printXYArray(XData, YData):
    # 打印X
    print("[", ",".join([str(i) for i in XData]), "]")
    # 打印Y
    print("[", ",".join([str(i) for i in YData]), "]")


# 最小二乘法定义损失函数 并计算
# 参考链接：https://blog.csdn.net/zy_505775013/article/details/88683460
# 求最小二乘法的最小值 最终结果应当是在learningRate一定情况下  这个最小的sum
def calcLoseFunction(k, b, XData, YData):
    sum = 0
    for i in range(0, listSize):
        # 使用偏离值的平方进行累和
        sum += (YData[i] - (k * XData[i] + b)) ** 2
    return sum


# 梯度下降法
def calcGradientCorrection(b, k, XData, YData, learningRate, bfsNums):
    for i in range(0, bfsNums):
        sumk, sumb = 0, 0
        for j in range(0, listSize):
            # 定义预测值Y'
            normalNum = k * XData[j] + b
            # 计算逆梯度累和  注意这里求偏导应当是两倍 不知道为什么写成1了
            # 求MSE的偏导
            sumk += -(2 / listSize) * (normalNum - YData[j]) * XData[j]
            sumb += -(2 / listSize) * (normalNum - YData[j])
        # 在逆梯度的方向上进行下一步搜索
        k += learningRate * sumk
        b += learningRate * sumb
    return k, b


# 随机生成横坐标
XData = [generateRandomInteger(1, 100) for i in range(listSize)]
# 随机生成纵坐标
YData = [XData[i] + generateRandomInteger(-10, 10) for i in range(listSize)]
# 纯随机生成 但是可视化效果不直观
# YData=[generateRandomInteger(1,100) for i in range(listSize) ]
# 死值替换区
# XData=[ 49,74,62,54,20,14,27,74,23,50 ]
# YData=[ 47,65,56,57,21,21,32,81,27,46 ]

print("初始选取k={},b={}的情况下的损失函数值为sum={}".format(k, b, calcLoseFunction(k, b, XData, YData)))
# 对k,b进行梯度修正
k, b = calcGradientCorrection(b, k, XData, YData, learningRate, bfsNums)
print("修正后：k={},b={},最小损失sum={}".format(k, b, calcLoseFunction(k, b, XData, YData)))
print("调试数组")
printXYArray(XData, YData)

# 画图
# plt.plot(XData, YData, 'b.')
# plt.plot(XData, k * numpy.array(XData) + b, 'r')
# plt.show()
print("END")

任务清单

1.算法程序不使用任何for循环（已完成）

2.使用scipy对原先的代码进行优化（已完成）

3.对优化前后代码进行基准测试（已完成）

JSU_曾是此间年少
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
拓展进阶：Python 中 Scipy 的优化与拟合
theskylife的博客
12-16 1927
在我们的Python科学计算之旅中，我们已经学习了Scipy库的基础功能，涉及数学运算、数据处理、统计分析等方面。然而，在实际的数据分析和科学研究中，我们经常面临着需要进一步优化算法和拟合数据的需求。本文将深入研究Scipy中的优化与拟合功能，探讨如何在实际问题中应用这些高级功能。
梯度下降-最小二乘-scipy使用
qq_41103204的博客
04-12 1914
目录1 概念2 区别3 scipy.optimize的使用 1 概念 最小二乘法：最小二乘法（又称最小平方法，Least squares）是一种数学优化技术。它通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。最小二乘法还可用于曲线拟合。其他一些优化问题也可通过最小化能量或最大化熵用最小二乘法来表达。 ...
【Python优化算法篇】用于优化问题的scipy.optimize
ZZQ_UESTC的博客
02-19 1161
Scipy优化，涵盖了一些基本的优化概念和使用方法。是对一些参考的整理。
神经网络梯度下降法python代码_学习率衰减加冲量优化的梯度下降法Python实现方案...
weixin_36059505的博客
02-05 504
应用场景优化算法经常被使用在各种组合优化问题中。我们可以假定待优化的函数对象\(f(x)\)是一个黑盒，我们可以给这个黑盒输入一些参数\(x_0, x_1, ...\)，然后这个黑盒会给我们返回其计算得到的函数值\(f(x_0), f(x_1), ...\)。我们的最终目的是得到这个黑盒函数的最优输入参数\(x_i\)，使得\(f(x_i)=min\{f(x)\}\)。那么我们就会想到，通过不断的...
梯度下降法介绍及python实现
tansuo17的博客
01-19 806
梯度下降（Gradient Descent）算法是机器学习中使用非常广泛的优化算法。当前流行的机器学习库或者深度学习库都会包括梯度下降算法的不同变种实现。本文主要以线性回归算法损失函数求极小值来说明如何使用梯度下降算法并给出python实现。若有不正确的地方，希望读者能指出。 梯度下降梯度下降原理：将函数比作一座山，我们站在某个山坡上，往四周看，从哪个方向向下走一小步，能够下降的最快。在线性回归算
Scipy教程 - 优化和拟合库scipy.optimize
热门推荐
皮皮blog
04-09 9万+
http://blog.csdn.net/pipisorry/article/details/51106570 最优化函数库Optimization 优化是找到最小值或等式的数值解的问题。scipy.optimization子模块提供了函数最小值(标量或多维)、曲线拟合和寻找等式的根的有用算法。 from scipy import optimize 皮皮blog
基于Python实现的梯度下降算法.zip
最新发布
05-11
梯度下降算法是一种在机器学习和优化问题中广泛使用的迭代方法，用于寻找函数的局部最小值。它通过不断地沿着函数梯度的反方向移动来逐步逼近极小值点。在这个基于Python实现的压缩包文件中，我们可以期待找到一系列...
基于Python共轭梯度法与最速下降法之间的对比
09-17
在优化领域，共轭梯度法（Conjugate Gradient Method）和最速下降法（Steepest Descent Method）是两种广泛使用的迭代方法，尤其在解决大型线性系统和无约束优化问题时。这两种方法都是解决二次规划问题的有效工具，...
scipy安装包
05-19
Scipy的优化模块包含了一整套算法，如梯度下降、牛顿法、拟牛顿法，以及线性和非线性最小化问题的解决方案。这使得科学家和工程师能够优化模型参数或解决最优化问题。 3. **积分模块**：该模块提供了数值积分的方法...
共轭梯度法与BFGS法Python实现
04-06
它通过近似Hessian矩阵（二阶导数矩阵）来改进梯度下降的方向。BFGS算法在每一步迭代中更新这个近似Hessian，使其越来越接近实际的Hessian，从而提高迭代效率。BFGS的一个关键特性是它能够保持正定性，确保搜索方向...
Mastering Scipy
11-27
4. **优化问题**：探索局部和全局优化算法，如梯度下降、牛顿法、遗传算法等，用于函数极值或参数估计。 5. **信号处理**：学习滤波、频谱分析、小波分析等信号处理技术，处理时序数据和声音信号。 6. **统计分析*...
Python中优化模块scipy.optimize的优化算法介绍
Pandas120的博客
01-16 1457
如果你有一个特殊的优化问题，你可以使用对象来自定义问题的求解。# 自定义目标函数# 自定义优化问题custom_problem.fun = custom_objective_function # 目标函数custom_problem.x = [1, 1] # 初始猜测# 执行优化# 打印结果在上述例子中，我们自定义了一个对象，并指定了目标函数和初始猜测，然后使用minimize函数进行求解。Scipy的优化模块提供了丰富的功能，适用于各种优化问题。
【Scipy】scipy.optimize.minimize
烦成航的博客
04-01 796
【代码】【Scipy】scipy.optimize.minimize。
scipy minimize当目标函数需要参数、当约束条件特别特别多时
tyfwin的博客
01-15 9786
from scipy.optimize import minimize 求解 官方说明文档 简单开一下开头 官方下面有例子会让人容易明白 注意我们的目的是：为了求出让fun函数最小的最优解x 当遇见目标函数fun带了很多外来参数的时候 以及约束很多很多假设有100个的时候，怎么实现呢 1、优化函数带参数 但是当fun函数是带参数的时候怎么办呢，参数当然可以是一个数，也可能是数组矩阵等。 比如说我们可以随便定义一个目标函数： def fun(x,...
SciPy 优化
吴吃辣
10-22 1499
章节SciPy 介绍 SciPy 安装 SciPy 基础功能 SciPy 特殊函数 SciPy k均值聚类 SciPy 常量 SciPy fftpack(傅里叶变换) SciPy 积分 SciPy 插值 SciPy 输入输出 SciPy 线性代数 SciPy 图像处理 SciPy 优化 SciPy 信号处理 SciPy 统计 优化是指在某些约束条件下，求解目标函数最优解的过程。机器学习、人工智...
python解非线性规划问题讲析_非线性规划（scipy.optimize.minimize）
weixin_35826751的博客
01-30 5610
1、minimize() 函数介绍在 python 里用非线性规划求极值，最常用的就是 scipy.optimize.minimize()。[官方介绍点这里](Constrained minimization of multivariate scalar functions)使用格式是：scipy.optimize.minimize(fun, x0, args=(), method=None, j...
python实例 优化目标函数_python scipy optimize.minimize用法及代码示例
weixin_39997253的博客
12-12 4901
最小化一个或多个变量的标量函数。参数：fun：callable目标函数要最小化。fun(x, *args) -> float其中x是具有(n，)形状的一维数组，而args是完全指定函数所需的固定参数的元组。x0：ndarray, shape (n,)初步猜测。大小为(n，)的实数元素的数组，其中‘n’是自变量的数量。args：tuple, 可选参数额外的参数传递给目标函数及其派生函数(fun...
python实现次梯度(subgradient)和近端梯度下降法 (proximal gradient descent)方法求解L1正则化
fangfanglovezhou的博客
01-28 4589
l1范数最小化 考虑函数，显然其在零点不可微，其对应的的次微分为： 注意，的取值为一个区间。 两个重要定理： 1）一个凸函数，当且仅当，为全局最小值，即为最小值点； 2）为函数（不一定是凸函数）的最小值点，当且仅当在该点可次微分且。 考虑最简单的一种情况，目标函数为： 对应的次微分为： 进一步可以表示为： 故，若，最小值点为： 若，最小值点为： 若，最小值点为： 简而言之，最优解，通常被称为软阈值（soft threshold）算子。 subgradient...
【Python学习笔记】13：用梯度下降法求解最优值问题
LauZyHou的笔记
05-21 6445
用梯度下降法求解最优值问题 梯度是函数在某点沿每个坐标的偏导数构成的向量，它反映了函数沿着哪个方向增加得最快。因此要求解一个二元函数的极小值，只要沿着梯度的反方向走，直到函数值的变化满足精度即可。 这里打表存储了途径的每个点，最后在图上绘制出来以反映路径。 import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import ...
numpy实现梯度下降
07-27
要使用NumPy实现梯度下降，首先需要定义一个损失函数和其对参数的梯度。然后，可以使用循环迭代的方式更新参数，直到达到收敛条件为止。 以下是一个使用NumPy实现梯度下降的示例代码： ```python import numpy as np # 定义损失函数 def loss_function(X, y, theta): m = len(y) h = X.dot(theta) return np.sum((h - y) ** 2) / (2 * m) # 定义梯度函数 def gradient(X, y, theta): m = len(y) h = X.dot(theta) return X.T.dot(h - y) / m # 定义梯度下降函数 def gradient_descent(X, y, theta, learning_rate, iterations): m = len(y) loss_history = [] for i in range(iterations): grad = gradient(X, y, theta) theta = theta - learning_rate * grad loss = loss_function(X, y, theta) loss_history.append(loss) return theta, loss_history # 生成随机数据 np.random.seed(0) X = 2 * np.random.rand(100, 1) y = 4 + 3 * X + np.random.randn(100, 1) # 添加偏置项 X_b = np.c_[np.ones((100, 1)), X] # 初始化参数 theta_initial = np.random.randn(2, 1) # 设置学习率和迭代次数 learning_rate = 0.01 iterations = 1000 # 运行梯度下降算法 theta_optimized, loss_history = gradient_descent(X_b, y, theta_initial, learning_rate, iterations) print("Optimized theta:", theta_optimized) ``` 在上面的示例代码中，我们首先定义了一个简单的线性回归问题，然后使用梯度下降算法来拟合参数。最终输出了优化后的参数theta。 请注意，上述示例代码仅用于演示梯度下降算法的实现过程，并不是最优化的实现方式。实际应用中，可以使用更高效的优化算法，如批量梯度下降、随机梯度下降或者使用优化库（如SciPy）中的函数来完成参数优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JSU_曾是此间年少

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值