optimtool 2.6.2__tar.gz → 2.7.1__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. {optimtool-2.6.2 → optimtool-2.7.1}/PKG-INFO +69 -45
  2. {optimtool-2.6.2 → optimtool-2.7.1}/README.md +68 -44
  3. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/__init__.py +1 -1
  4. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_version.py +1 -1
  5. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/gradient_descent.py +1 -1
  6. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/newton_quasi.py +11 -13
  7. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/nonlinear_least_square.py +145 -145
  8. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/trust_region.py +5 -5
  9. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool.egg-info/PKG-INFO +69 -45
  10. {optimtool-2.6.2 → optimtool-2.7.1}/setup.py +1 -1
  11. {optimtool-2.6.2 → optimtool-2.7.1}/LICENSE +0 -0
  12. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_convert.py +0 -0
  13. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_drive.py +0 -0
  14. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_kernel.py +0 -0
  15. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_proxim.py +0 -0
  16. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_search.py +0 -0
  17. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_typing.py +0 -0
  18. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_utils.py +0 -0
  19. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/base.py +0 -0
  20. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/constrain/__init__.py +0 -0
  21. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/constrain/equal.py +0 -0
  22. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/constrain/mixequal.py +0 -0
  23. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/constrain/unequal.py +0 -0
  24. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/example/Lasso.py +0 -0
  25. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/example/WanYuan.py +0 -0
  26. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/example/__init__.py +0 -0
  27. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/hybrid/__init__.py +0 -0
  28. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/hybrid/approt.py +0 -0
  29. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/hybrid/fista.py +0 -0
  30. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/hybrid/nesterov.py +0 -0
  31. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/__init__.py +0 -0
  32. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/newton.py +0 -0
  33. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool.egg-info/SOURCES.txt +0 -0
  34. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool.egg-info/dependency_links.txt +0 -0
  35. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool.egg-info/not-zip-safe +0 -0
  36. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool.egg-info/requires.txt +0 -0
  37. {optimtool-2.6.2 → optimtool-2.7.1}/optimtool.egg-info/top_level.txt +0 -0
  38. {optimtool-2.6.2 → optimtool-2.7.1}/setup.cfg +0 -0
{optimtool-2.6.2 → optimtool-2.7.1}/PKG-INFO RENAMED
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.1
2
2
  Name: optimtool
3
- Version: 2.6.2
3
+ Version: 2.7.1
4
4
  Summary: The fundamental package for scientific research in optimization.
5
5
  Home-page: https://github.com/linjing-lab/optimtool
6
6
  Download-URL: https://github.com/linjing-lab/optimtool/tags
@@ -70,6 +70,30 @@ pip install -e . --verbose
70
70
  ```text
71
71
  pip install optimtool --upgrade
72
72
  ```
73
+ 下载没有更改库架构的版本：
74
+ ```text
75
+ pip install optimtool==2.3.5
76
+ ```
77
+ 下载优化库架构并增加typing变量的版本：
78
+ ```text
79
+ pip install optimtool>=2.4.0
80
+ ```
81
+ 下载改进h2h函数的版本：
82
+ ```text
83
+ pip install optimtool>=2.4.2
84
+ ```
85
+ 下载增强文档表达和检测非法输入的版本：
86
+ ```text
87
+ pip install optimtool>=2.5.0rc0
88
+ ```
89
+ 下载支持hybrid算法的版本：
90
+ ```text
91
+ pip install optimtool>=2.5.0
92
+ ```
93
+ 下载更好地支持numpy的版本：
94
+ ```text
95
+ pip install optimtool>=2.6.0
96
+ ```
73
97
  ## 项目结构
74
98
 
75
99
  ```textile
@@ -125,10 +149,10 @@ ou.[方法名].[函数名]([目标函数], [参数表], [初始迭代点])
125
149
  ou.gradient_descent.[函数名]([目标函数], [参数表], [初始迭代点])
126
150
  ```
127
151
 
128
- | 方法头 | 解释 |
129
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
130
- | solve(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过解方程的方式来求解精确步长 |
131
- | steepest(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 使用线搜索方法求解非精确步长（默认使用wolfe线搜索） |
152
+ | 方法头 | 解释 |
153
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
154
+ | solve(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过解方程的方式来求解精确步长 |
155
+ | steepest(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 使用线搜索方法求解非精确步长（默认使用wolfe线搜索） |
132
156
  | barzilar_borwein(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="Grippo", c1: float=0.6, beta: float=0.6, M: int=20, eta: float=0.6, alpha: float=1., epsilon: float=1e-10, k: int=0) -> OutputType | 使用Grippo与ZhangHanger提出的非单调线搜索方法更新步长 |
133
157
 
134
158
  #### 牛顿法（newton）
@@ -137,11 +161,11 @@ ou.gradient_descent.[函数名]([目标函数], [参数表], [初始迭代点])
137
161
  ou.newton.[函数名]([目标函数], [参数表], [初始迭代点])
138
162
  ```
139
163
 
140
- | 方法头 | 解释 |
141
- | ----------------------------------------------------------------------------------------------- | --------------------------------- |
142
- | classic(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过直接对目标函数二阶导矩阵（海瑟矩阵）进行求逆来获取下一步的步长 |
143
- | modified(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 修正当前海瑟矩阵保证其正定性（目前只接入了一种修正方法） |
144
- | CG(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", eps: float=1e-3, epsilon: float=1e-6, k: int=0) -> OutputType | 采用牛顿-共轭梯度法求解梯度（非精确牛顿法的一种） |
164
+ | 方法头 | 解释 |
165
+ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
166
+ | classic(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过直接对目标函数二阶导矩阵（海瑟矩阵）进行求逆来获取下一步的步长 |
167
+ | modified(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 修正当前海瑟矩阵保证其正定性（目前只接入了一种修正方法） |
168
+ | CG(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", eps: float=1e-3, epsilon: float=1e-6, k: int=0) -> OutputType | 采用牛顿-共轭梯度法求解梯度（非精确牛顿法的一种） |
145
169
 
146
170
  #### 拟牛顿法（newton_quasi）
147
171
 
@@ -149,10 +173,10 @@ ou.newton.[函数名]([目标函数], [参数表], [初始迭代点])
149
173
  ou.newton_quasi.[函数名]([目标函数], [参数表], [初始迭代点])
150
174
  ```
151
175
 
152
- | 方法头 | 解释 |
153
- | -------------------------------------------------------------------------------------------- | --------------- |
154
- | bfgs(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | BFGS方法更新海瑟矩阵 |
155
- | dfp(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | DFP方法更新海瑟矩阵 |
176
+ | 方法头 | 解释 |
177
+ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- |
178
+ | bfgs(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | BFGS方法更新海瑟矩阵 |
179
+ | dfp(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | DFP方法更新海瑟矩阵 |
156
180
  | L_BFGS(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", m: int=6, epsilon: float=1e-10, k: int=0) -> OutputType | 双循环方法更新BFGS海瑟矩阵 |
157
181
 
158
182
  #### 非线性最小二乘法（nonlinear_least_square）
@@ -160,10 +184,10 @@ ou.newton_quasi.[函数名]([目标函数], [参数表], [初始迭代点])
160
184
  ```python
161
185
  ou.nonlinear_least_square.[函数名]([目标函数], [参数表], [初始迭代点])
162
186
  ```
163
- | 方法头 | 解释 |
164
- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- |
165
- | gauss_newton(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False,, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 高斯-牛顿提出的方法框架，包括OR分解等操作 |
166
- | levenberg_marquardt(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, lamk: float=1., eta: float=0.2, p1: float=0.4, p2: float=0.9, gamma1: float=0.7, gamma2: float=1.3, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | Levenberg Marquardt提出的方法框架 |
187
+ | 方法头 | 解释 |
188
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------- |
189
+ | gauss_newton(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False,, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 高斯-牛顿提出的方法框架，包括OR分解等操作 |
190
+ | levenberg_marquardt(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, lamk: float=1., eta: float=0.2, p1: float=0.4, p2: float=0.9, gamma1: float=0.7, gamma2: float=1.3, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | Levenberg Marquardt提出的方法框架 |
167
191
 
168
192
  #### 信赖域方法（trust_region）
169
193
 
@@ -171,8 +195,8 @@ ou.nonlinear_least_square.[函数名]([目标函数], [参数表], [初始迭代
171
195
  ou.trust_region.[函数名]([目标函数], [参数表], [初始迭代点])
172
196
  ```
173
197
 
174
- | 方法头 | 解释 |
175
- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
198
+ | 方法头 | 解释 |
199
+ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- |
176
200
  | steihaug_CG(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, r0: float=1., rmax: float=2., eta: float=0.2, p1: float=0.4, p2: float=0.6, gamma1: float=0.5, gamma2: float=1.5, epsk: float=1e-6, epsilon: float=1e-6, k: int=0) -> OutputType | 截断共轭梯度法在此方法中被用于搜索步长 |
177
201
 
178
202
  ### 约束优化算法（constrain）
@@ -188,9 +212,9 @@ oc.[方法名].[函数名]([目标函数], [参数表], [等式约束表], [不
188
212
  oc.equal.[函数名]([目标函数], [参数表], [等式约束表], [初始迭代点])
189
213
  ```
190
214
 
191
- | 方法头 | 解释 |
192
- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
193
- | penalty_quadratice(funcs: FuncArray, args: FuncArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=2., epsk: float=1e-4, epsilon: float=1e-4, k: int=0) -> OutputType | 增加二次罚项 |
215
+ | 方法头 | 解释 |
216
+ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
217
+ | penalty_quadratice(funcs: FuncArray, args: FuncArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=2., epsk: float=1e-4, epsilon: float=1e-6, k: int=0) -> OutputType | 增加二次罚项 |
194
218
  | lagrange_augmentede(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", lamk: float=6., sigma: float=10., p: float=2., etak: float=1e-4, epsilon: float=1e-6, k: int=0) -> OutputType | 增广拉格朗日乘子法 |
195
219
 
196
220
  #### 不等式约束（unequal）
@@ -199,9 +223,9 @@ oc.equal.[函数名]([目标函数], [参数表], [等式约束表], [初始迭
199
223
  oc.unequal.[函数名]([目标函数], [参数表], [不等式约束表], [初始迭代点])
200
224
  ```
201
225
 
202
- | 方法头 | 解释 |
203
- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------- |
204
- | penalty_quadraticu(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.4, epsk: float=1e-4, epsilon: float=1e-10, k: int=0) -> OutputType | 增加二次罚项 |
226
+ | 方法头 | 解释 |
227
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ |
228
+ | penalty_quadraticu(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.4, epsk: float=1e-4, epsilon: float=1e-6, k: int=0) -> OutputType | 增加二次罚项 |
205
229
  | lagrange_augmentedu(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", muk: float=10., sigma: float=8., alpha: float=0.2, beta: float=0.7, p: float=2., eta: float=1e-1, epsilon: float=1e-4, k: int=0) -> OutputType | 增广拉格朗日乘子法 |
206
230
 
207
231
  #### 混合等式约束（mixequal）
@@ -210,10 +234,10 @@ oc.unequal.[函数名]([目标函数], [参数表], [不等式约束表], [初
210
234
  oc.mixequal.[函数名]([目标函数], [参数表], [等式约束表], [不等式约束表], [初始迭代点])
211
235
  ```
212
236
 
213
- | 方法头 | 解释 |
214
- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
215
- | penalty_quadraticm(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | 增加二次罚项 |
216
- | penalty_L1(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=1., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | L1精确罚函数法 |
237
+ | 方法头 | 解释 |
238
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ |
239
+ | penalty_quadraticm(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | 增加二次罚项 |
240
+ | penalty_L1(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=1., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | L1精确罚函数法 |
217
241
  | lagrange_augmentedm(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", lamk: float=6., muk: float=10., sigma: float=8., alpha: float=0.5, beta: float=0.7, p: float=2., etak: float=1e-3, epsilon: float=1e-4, k: int=0) -> OutputType | 增广拉格朗日乘子法 |
218
242
 
219
243
  ### 方法的应用（example）
@@ -228,11 +252,11 @@ import optimtool.example as oe
228
252
  oe.Lasso.[函数名]([矩阵A], [矩阵b], [因子mu], [参数表], [初始迭代点])
229
253
  ```
230
254
 
231
- | 方法头 | 解释 |
232
- | ------------------------------------------------------------------------------------------------------- | ---------------- |
233
- | gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | 光滑化Lasso函数法 |
255
+ | 方法头 | 解释 |
256
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- |
257
+ | gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | 光滑化Lasso函数法 |
234
258
  | subgradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, alphak: float=2e-2, epsilon: float=1e-3, k: int=0) -> OutputType | 次梯度法Lasso避免一阶不可导 |
235
- | approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 邻近算子更新 |
259
+ | approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 邻近算子更新 |
236
260
 
237
261
  #### 曲线相切问题（WanYuan）
238
262
 
@@ -246,8 +270,8 @@ oe.WanYuan.[函数名]([直线的斜率], [直线的截距], [二次项系数],
246
270
  给定直线的斜率和截距，给定一个抛物线函数的二次项系数，一次项系数与常数项。 要求解一个给定圆心的圆，该圆同时与抛物线、直线相切，若存在可行方案，请给出切点的坐标。
247
271
  ```
248
272
 
249
- | 方法头 | 解释 |
250
- | --------------------------------------------------------------- | -------------------- |
273
+ | 方法头 | 解释 |
274
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------- |
251
275
  | solution(m: float, n: float, a: float, b: float, c: float, x3: float, y3: float, x_0: tuple, verbose: bool=False, draw: bool=False, eps: float=1e-10) -> str | 使用高斯-牛顿方法求解构造的7个残差函数 |
252
276
 
253
277
  ### 混合优化算法（hybrid）
@@ -262,8 +286,8 @@ import optimtool.hybrid as oh
262
286
  oh.approt.[函数名]([目标函数], [参数表], [初始迭代点], [正则化参数], [邻近算子名])
263
287
  ```
264
288
 
265
- | 方法头 | 解释 |
266
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
289
+ | 方法头 | 解释 |
290
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- |
267
291
  | grad(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 基于梯度方法的邻近近似 |
268
292
 
269
293
  #### FISTA算法（fista）
@@ -272,10 +296,10 @@ oh.approt.[函数名]([目标函数], [参数表], [初始迭代点], [正则化
272
296
  oh.fista.[函数名]([目标函数], [参数表], [初始迭代点], [正则化参数], [邻近算子名])
273
297
  ```
274
298
 
275
- | 方法头 | 解释 |
276
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
277
- | normal(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 两步计算一个新点 |
278
- | variant(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | normal法的等价变形 |
299
+ | 方法头 | 解释 |
300
+ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
301
+ | normal(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 两步计算一个新点 |
302
+ | variant(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | normal法的等价变形 |
279
303
  | decline(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 基于函数下降趋势的变体 |
280
304
 
281
305
  #### Nesterov算法（nesterov）
@@ -284,9 +308,9 @@ oh.fista.[函数名]([目标函数], [参数表], [初始迭代点], [正则化
284
308
  oh.nesterov.[函数名]([目标函数], [参数表], [初始迭代点], [正则化参数], [邻近算子名])
285
309
  ```
286
310
 
287
- | 方法头 | 解释 |
288
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
289
- | seckin(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 第二类Nesterov加速法 |
311
+ | 方法头 | 解释 |
312
+ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
313
+ | seckin(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 第二类Nesterov加速法 |
290
314
  | accer(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", lk: float=0.01, tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 复合优化算法的加速框架 |
291
315
 
292
316
  ## LICENSE
{optimtool-2.6.2 → optimtool-2.7.1}/README.md RENAMED
@@ -41,6 +41,30 @@ pip install -e . --verbose
41
41
  ```text
42
42
  pip install optimtool --upgrade
43
43
  ```
44
+ 下载没有更改库架构的版本：
45
+ ```text
46
+ pip install optimtool==2.3.5
47
+ ```
48
+ 下载优化库架构并增加typing变量的版本：
49
+ ```text
50
+ pip install optimtool>=2.4.0
51
+ ```
52
+ 下载改进h2h函数的版本：
53
+ ```text
54
+ pip install optimtool>=2.4.2
55
+ ```
56
+ 下载增强文档表达和检测非法输入的版本：
57
+ ```text
58
+ pip install optimtool>=2.5.0rc0
59
+ ```
60
+ 下载支持hybrid算法的版本：
61
+ ```text
62
+ pip install optimtool>=2.5.0
63
+ ```
64
+ 下载更好地支持numpy的版本：
65
+ ```text
66
+ pip install optimtool>=2.6.0
67
+ ```
44
68
  ## 项目结构
45
69
 
46
70
  ```textile
@@ -96,10 +120,10 @@ ou.[方法名].[函数名]([目标函数], [参数表], [初始迭代点])
96
120
  ou.gradient_descent.[函数名]([目标函数], [参数表], [初始迭代点])
97
121
  ```
98
122
 
99
- | 方法头 | 解释 |
100
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
101
- | solve(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过解方程的方式来求解精确步长 |
102
- | steepest(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 使用线搜索方法求解非精确步长（默认使用wolfe线搜索） |
123
+ | 方法头 | 解释 |
124
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
125
+ | solve(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过解方程的方式来求解精确步长 |
126
+ | steepest(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 使用线搜索方法求解非精确步长（默认使用wolfe线搜索） |
103
127
  | barzilar_borwein(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="Grippo", c1: float=0.6, beta: float=0.6, M: int=20, eta: float=0.6, alpha: float=1., epsilon: float=1e-10, k: int=0) -> OutputType | 使用Grippo与ZhangHanger提出的非单调线搜索方法更新步长 |
104
128
 
105
129
  #### 牛顿法（newton）
@@ -108,11 +132,11 @@ ou.gradient_descent.[函数名]([目标函数], [参数表], [初始迭代点])
108
132
  ou.newton.[函数名]([目标函数], [参数表], [初始迭代点])
109
133
  ```
110
134
 
111
- | 方法头 | 解释 |
112
- | ----------------------------------------------------------------------------------------------- | --------------------------------- |
113
- | classic(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过直接对目标函数二阶导矩阵（海瑟矩阵）进行求逆来获取下一步的步长 |
114
- | modified(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 修正当前海瑟矩阵保证其正定性（目前只接入了一种修正方法） |
115
- | CG(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", eps: float=1e-3, epsilon: float=1e-6, k: int=0) -> OutputType | 采用牛顿-共轭梯度法求解梯度（非精确牛顿法的一种） |
135
+ | 方法头 | 解释 |
136
+ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
137
+ | classic(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-10, k: int=0) -> OutputType | 通过直接对目标函数二阶导矩阵（海瑟矩阵）进行求逆来获取下一步的步长 |
138
+ | modified(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 修正当前海瑟矩阵保证其正定性（目前只接入了一种修正方法） |
139
+ | CG(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", eps: float=1e-3, epsilon: float=1e-6, k: int=0) -> OutputType | 采用牛顿-共轭梯度法求解梯度（非精确牛顿法的一种） |
116
140
 
117
141
  #### 拟牛顿法（newton_quasi）
118
142
 
@@ -120,10 +144,10 @@ ou.newton.[函数名]([目标函数], [参数表], [初始迭代点])
120
144
  ou.newton_quasi.[函数名]([目标函数], [参数表], [初始迭代点])
121
145
  ```
122
146
 
123
- | 方法头 | 解释 |
124
- | -------------------------------------------------------------------------------------------- | --------------- |
125
- | bfgs(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | BFGS方法更新海瑟矩阵 |
126
- | dfp(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | DFP方法更新海瑟矩阵 |
147
+ | 方法头 | 解释 |
148
+ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- |
149
+ | bfgs(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | BFGS方法更新海瑟矩阵 |
150
+ | dfp(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | DFP方法更新海瑟矩阵 |
127
151
  | L_BFGS(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="wolfe", m: int=6, epsilon: float=1e-10, k: int=0) -> OutputType | 双循环方法更新BFGS海瑟矩阵 |
128
152
 
129
153
  #### 非线性最小二乘法（nonlinear_least_square）
@@ -131,10 +155,10 @@ ou.newton_quasi.[函数名]([目标函数], [参数表], [初始迭代点])
131
155
  ```python
132
156
  ou.nonlinear_least_square.[函数名]([目标函数], [参数表], [初始迭代点])
133
157
  ```
134
- | 方法头 | 解释 |
135
- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- |
136
- | gauss_newton(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False,, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 高斯-牛顿提出的方法框架，包括OR分解等操作 |
137
- | levenberg_marquardt(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, lamk: float=1., eta: float=0.2, p1: float=0.4, p2: float=0.9, gamma1: float=0.7, gamma2: float=1.3, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | Levenberg Marquardt提出的方法框架 |
158
+ | 方法头 | 解释 |
159
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------- |
160
+ | gauss_newton(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False,, draw: bool=True, output_f: bool=False, method: str="wolfe", epsilon: float=1e-10, k: int=0) -> OutputType | 高斯-牛顿提出的方法框架，包括OR分解等操作 |
161
+ | levenberg_marquardt(funcr: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, lamk: float=1., eta: float=0.2, p1: float=0.4, p2: float=0.9, gamma1: float=0.7, gamma2: float=1.3, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | Levenberg Marquardt提出的方法框架 |
138
162
 
139
163
  #### 信赖域方法（trust_region）
140
164
 
@@ -142,8 +166,8 @@ ou.nonlinear_least_square.[函数名]([目标函数], [参数表], [初始迭代
142
166
  ou.trust_region.[函数名]([目标函数], [参数表], [初始迭代点])
143
167
  ```
144
168
 
145
- | 方法头 | 解释 |
146
- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
169
+ | 方法头 | 解释 |
170
+ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- |
147
171
  | steihaug_CG(funcs: FuncArray, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, r0: float=1., rmax: float=2., eta: float=0.2, p1: float=0.4, p2: float=0.6, gamma1: float=0.5, gamma2: float=1.5, epsk: float=1e-6, epsilon: float=1e-6, k: int=0) -> OutputType | 截断共轭梯度法在此方法中被用于搜索步长 |
148
172
 
149
173
  ### 约束优化算法（constrain）
@@ -159,9 +183,9 @@ oc.[方法名].[函数名]([目标函数], [参数表], [等式约束表], [不
159
183
  oc.equal.[函数名]([目标函数], [参数表], [等式约束表], [初始迭代点])
160
184
  ```
161
185
 
162
- | 方法头 | 解释 |
163
- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
164
- | penalty_quadratice(funcs: FuncArray, args: FuncArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=2., epsk: float=1e-4, epsilon: float=1e-4, k: int=0) -> OutputType | 增加二次罚项 |
186
+ | 方法头 | 解释 |
187
+ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
188
+ | penalty_quadratice(funcs: FuncArray, args: FuncArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=2., epsk: float=1e-4, epsilon: float=1e-6, k: int=0) -> OutputType | 增加二次罚项 |
165
189
  | lagrange_augmentede(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", lamk: float=6., sigma: float=10., p: float=2., etak: float=1e-4, epsilon: float=1e-6, k: int=0) -> OutputType | 增广拉格朗日乘子法 |
166
190
 
167
191
  #### 不等式约束（unequal）
@@ -170,9 +194,9 @@ oc.equal.[函数名]([目标函数], [参数表], [等式约束表], [初始迭
170
194
  oc.unequal.[函数名]([目标函数], [参数表], [不等式约束表], [初始迭代点])
171
195
  ```
172
196
 
173
- | 方法头 | 解释 |
174
- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------- |
175
- | penalty_quadraticu(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.4, epsk: float=1e-4, epsilon: float=1e-10, k: int=0) -> OutputType | 增加二次罚项 |
197
+ | 方法头 | 解释 |
198
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ |
199
+ | penalty_quadraticu(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.4, epsk: float=1e-4, epsilon: float=1e-6, k: int=0) -> OutputType | 增加二次罚项 |
176
200
  | lagrange_augmentedu(funcs: FuncArray, args: ArgArray, cons: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", muk: float=10., sigma: float=8., alpha: float=0.2, beta: float=0.7, p: float=2., eta: float=1e-1, epsilon: float=1e-4, k: int=0) -> OutputType | 增广拉格朗日乘子法 |
177
201
 
178
202
  #### 混合等式约束（mixequal）
@@ -181,10 +205,10 @@ oc.unequal.[函数名]([目标函数], [参数表], [不等式约束表], [初
181
205
  oc.mixequal.[函数名]([目标函数], [参数表], [等式约束表], [不等式约束表], [初始迭代点])
182
206
  ```
183
207
 
184
- | 方法头 | 解释 |
185
- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
186
- | penalty_quadraticm(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | 增加二次罚项 |
187
- | penalty_L1(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=1., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | L1精确罚函数法 |
208
+ | 方法头 | 解释 |
209
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ |
210
+ | penalty_quadraticm(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=10., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | 增加二次罚项 |
211
+ | penalty_L1(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", sigma: float=1., p: float=0.6, epsk: float=1e-6, epsilon: float=1e-10, k: int=0) -> OutputType | L1精确罚函数法 |
188
212
  | lagrange_augmentedm(funcs: FuncArray, args: ArgArray, cons_equal: FuncArray, cons_unequal: FuncArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, method: str="newton", lamk: float=6., muk: float=10., sigma: float=8., alpha: float=0.5, beta: float=0.7, p: float=2., etak: float=1e-3, epsilon: float=1e-4, k: int=0) -> OutputType | 增广拉格朗日乘子法 |
189
213
 
190
214
  ### 方法的应用（example）
@@ -199,11 +223,11 @@ import optimtool.example as oe
199
223
  oe.Lasso.[函数名]([矩阵A], [矩阵b], [因子mu], [参数表], [初始迭代点])
200
224
  ```
201
225
 
202
- | 方法头 | 解释 |
203
- | ------------------------------------------------------------------------------------------------------- | ---------------- |
204
- | gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | 光滑化Lasso函数法 |
226
+ | 方法头 | 解释 |
227
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- |
228
+ | gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | 光滑化Lasso函数法 |
205
229
  | subgradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, alphak: float=2e-2, epsilon: float=1e-3, k: int=0) -> OutputType | 次梯度法Lasso避免一阶不可导 |
206
- | approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 邻近算子更新 |
230
+ | approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 邻近算子更新 |
207
231
 
208
232
  #### 曲线相切问题（WanYuan）
209
233
 
@@ -217,8 +241,8 @@ oe.WanYuan.[函数名]([直线的斜率], [直线的截距], [二次项系数],
217
241
  给定直线的斜率和截距，给定一个抛物线函数的二次项系数，一次项系数与常数项。 要求解一个给定圆心的圆，该圆同时与抛物线、直线相切，若存在可行方案，请给出切点的坐标。
218
242
  ```
219
243
 
220
- | 方法头 | 解释 |
221
- | --------------------------------------------------------------- | -------------------- |
244
+ | 方法头 | 解释 |
245
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------- |
222
246
  | solution(m: float, n: float, a: float, b: float, c: float, x3: float, y3: float, x_0: tuple, verbose: bool=False, draw: bool=False, eps: float=1e-10) -> str | 使用高斯-牛顿方法求解构造的7个残差函数 |
223
247
 
224
248
  ### 混合优化算法（hybrid）
@@ -233,8 +257,8 @@ import optimtool.hybrid as oh
233
257
  oh.approt.[函数名]([目标函数], [参数表], [初始迭代点], [正则化参数], [邻近算子名])
234
258
  ```
235
259
 
236
- | 方法头 | 解释 |
237
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
260
+ | 方法头 | 解释 |
261
+ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- |
238
262
  | grad(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 基于梯度方法的邻近近似 |
239
263
 
240
264
  #### FISTA算法（fista）
@@ -243,10 +267,10 @@ oh.approt.[函数名]([目标函数], [参数表], [初始迭代点], [正则化
243
267
  oh.fista.[函数名]([目标函数], [参数表], [初始迭代点], [正则化参数], [邻近算子名])
244
268
  ```
245
269
 
246
- | 方法头 | 解释 |
247
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
248
- | normal(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 两步计算一个新点 |
249
- | variant(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | normal法的等价变形 |
270
+ | 方法头 | 解释 |
271
+ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
272
+ | normal(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 两步计算一个新点 |
273
+ | variant(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | normal法的等价变形 |
250
274
  | decline(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 基于函数下降趋势的变体 |
251
275
 
252
276
  #### Nesterov算法（nesterov）
@@ -255,9 +279,9 @@ oh.fista.[函数名]([目标函数], [参数表], [初始迭代点], [正则化
255
279
  oh.nesterov.[函数名]([目标函数], [参数表], [初始迭代点], [正则化参数], [邻近算子名])
256
280
  ```
257
281
 
258
- | 方法头 | 解释 |
259
- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
260
- | seckin(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 第二类Nesterov加速法 |
282
+ | 方法头 | 解释 |
283
+ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
284
+ | seckin(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 第二类Nesterov加速法 |
261
285
  | accer(funcs: FuncArray, args: ArgArray, x_0: PointArray, mu: float=1e-3, proxim: str="L1", lk: float=0.01, tk: float=0.02, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 复合优化算法的加速框架 |
262
286
 
263
287
  ## LICENSE
{optimtool-2.6.2 → optimtool-2.7.1}/optimtool/__init__.py RENAMED
@@ -32,4 +32,4 @@ from .base import MATPLOTLIB_VERSION
32
32
  from ._version import __version__
33
33
 
34
34
  if sys.version_info < (3, 7, 0):
35
- raise OSError(f'optimtool-2.6.2 requires Python >=3.7, but yours is {sys.version}')
35
+ raise OSError(f'optimtool-2.7.1 requires Python >=3.7, but yours is {sys.version}')
{optimtool-2.6.2 → optimtool-2.7.1}/optimtool/_version.py RENAMED
@@ -18,4 +18,4 @@
18
18
  # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19
19
  # SOFTWARE.
20
20
 
21
- __version__ = '2.6.2'
21
+ __version__ = '2.7.1'
{optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/gradient_descent.py RENAMED
@@ -168,7 +168,7 @@ def barzilar_borwein(funcs: FuncArray,
168
168
  x_0 = x_0 + delta
169
169
  yk = np.array(res.subs(dict(zip(args, x_0)))).astype(DataType) + dk
170
170
  alpha_up = delta.dot(delta.T)
171
- alpha_down = delta.dot(yk.T)
171
+ alpha_down = (delta.dot(yk.T))[0]
172
172
  if alpha_down != 0:
173
173
  alpha = alpha_up / alpha_down
174
174
  k += 1
{optimtool-2.6.2 → optimtool-2.7.1}/optimtool/unconstrain/newton_quasi.py RENAMED
@@ -65,12 +65,11 @@ def bfgs(funcs: FuncArray,
65
65
  dk = -np.linalg.inv(hessian).dot(gradient.T).reshape(1, -1)
66
66
  if np.linalg.norm(dk) >= epsilon:
67
67
  alpha = search(funcs, args, x_0, dk)
68
- delta = alpha * dk[0]
69
- x_0 += delta
70
- sk = alpha * dk
68
+ delta = alpha * dk # sk
69
+ x_0 += delta[0]
71
70
  yk = np.array(res.subs(dict(zip(args, x_0)))).astype(DataType) - np.array(res.subs(reps)).astype(DataType)
72
71
  if yk.all != 0:
73
- hessian += (yk.T).dot(yk) / sk.dot(yk.T) - (hessian.dot(sk.T)).dot((hessian.dot(sk.T)).T) / sk.dot((hessian.dot(sk.T)))
72
+ hessian += (yk.T).dot(yk) / delta.dot(yk.T) - (hessian.dot(delta.T)).dot((hessian.dot(delta.T)).T) / delta.dot((hessian.dot(delta.T)))
74
73
  k += 1
75
74
  else:
76
75
  break
@@ -117,12 +116,11 @@ def dfp(funcs: FuncArray,
117
116
  dk = -hessiani.dot(gradient.T).reshape(1, -1)
118
117
  if np.linalg.norm(dk) >= epsilon:
119
118
  alpha = search(funcs, args, x_0, dk)
120
- delta = alpha * dk[0]
121
- x_0 += delta
122
- sk = alpha * dk
119
+ delta = alpha * dk # sk
120
+ x_0 += delta[0]
123
121
  yk = np.array(res.subs(dict(zip(args, x_0)))).astype(DataType) - np.array(res.subs(reps)).astype(DataType)
124
122
  if yk.all != 0:
125
- hessiani = hessiani - (hessiani.dot(yk.T)).dot((hessiani.dot(yk.T)).T) / yk.dot(hessiani.dot(yk.T)) + (sk.T).dot(sk) / yk.dot(sk.T)
123
+ hessiani = hessiani - (hessiani.dot(yk.T)).dot((hessiani.dot(yk.T)).T) / yk.dot(hessiani.dot(yk.T)) + (delta.T).dot(delta) / yk.dot(delta.T)
126
124
  k += 1
127
125
  else:
128
126
  break
@@ -175,17 +173,17 @@ def L_BFGS(funcs: FuncArray,
175
173
  dk = -double_loop(grad, p, s, y, m, k, Hkm).reshape(1, -1)
176
174
  if np.linalg.norm(dk) >= epsilon:
177
175
  alphak = search(funcs, args, x_0, dk)
178
- x_0 = x_0 + alphak * dk[0]
176
+ delta = alphak * dk # sk
177
+ x_0 += delta[0]
179
178
  if k > m:
180
179
  s[k-m] = np.empty((1, l))
181
180
  y[k-m] = np.empty((1, l))
182
- sk = alphak * dk
183
- s.append(sk)
181
+ s.append(delta)
184
182
  yk = np.array(res.subs(dict(zip(args, x_0)))).astype(DataType) - grad
185
183
  y.append(yk)
186
- pk = 1 / yk.dot(sk.T)
184
+ pk = 1 / yk.dot(delta.T)
187
185
  p.append(pk)
188
- gammak = sk.dot(sk.T) / yk.dot(yk.T)
186
+ gammak = delta.dot(delta.T) / yk.dot(yk.T)
189
187
  gamma.append(gammak)
190
188
  k = k + 1
191
189
  else: