scipy教程
常量模块
SciPy 常量模块 constants 提供了许多内置的数学常数。
圆周率是一个数学常数，为一个圆的周长和其直径的比率，近似值约等于 3.14159，常用符号 来表示。
以下实例输出圆周率：
from scipy import constants
print(constants.pi)
3.141592653589793
from scipy import constants
print(constants.golden)
1.618033988749895
from scipy import constants
print(dir(constants))
['Avogadro', 'Boltzmann', 'Btu', 'Btu_IT', 'Btu_th', 'ConstantWarning', 'G', 'Julian_year', 'N_A', 'Planck', 'R', 'Rydberg', 'Stefan_Boltzmann', 'Wien', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '_obsolete_constants', 'absolute_import', 'acre', 'alpha', 'angstrom', 'arcmin', 'arcminute', 'arcsec', 'arcsecond', 'astronomical_unit', 'atm', 'atmosphere', 'atomic_mass', 'atto', 'au', 'bar', 'barrel', 'bbl', 'blob', 'c', 'calorie', 'calorie_IT', 'calorie_th', 'carat', 'centi', 'codata', 'constants', 'convert_temperature', 'day', 'deci', 'degree', 'degree_Fahrenheit', 'deka', 'division', 'dyn', 'dyne', 'e', 'eV', 'electron_mass', 'electron_volt', 'elementary_charge', 'epsilon_0', 'erg', 'exa', 'exbi', 'femto', 'fermi', 'find', 'fine_structure', 'fluid_ounce', 'fluid_ounce_US', 'fluid_ounce_imp', 'foot', 'g', 'gallon', 'gallon_US', 'gallon_imp', 'gas_constant', 'gibi', 'giga', 'golden', 'golden_ratio', 'grain', 'gram', 'gravitational_constant', 'h', 'hbar', 'hectare', 'hecto', 'horsepower', 'hour', 'hp', 'inch', 'k', 'kgf', 'kibi', 'kilo', 'kilogram_force', 'kmh', 'knot', 'lambda2nu', 'lb', 'lbf', 'light_year', 'liter', 'litre', 'long_ton', 'm_e', 'm_n', 'm_p', 'm_u', 'mach', 'mebi', 'mega', 'metric_ton', 'micro', 'micron', 'mil', 'mile', 'milli', 'minute', 'mmHg', 'mph', 'mu_0', 'nano', 'nautical_mile', 'neutron_mass', 'nu2lambda', 'ounce', 'oz', 'parsec', 'pebi', 'peta', 'physical_constants', 'pi', 'pico', 'point', 'pound', 'pound_force', 'precision', 'print_function', 'proton_mass', 'psi', 'pt', 'short_ton', 'sigma', 'slinch', 'slug', 'speed_of_light', 'speed_of_sound', 'stone', 'survey_foot', 'survey_mile', 'tebi', 'tera', 'test', 'ton_TNT', 'torr', 'troy_ounce', 'troy_pound', 'u', 'unit', 'value', 'week', 'yard', 'year', 'yobi', 'yotta', 'zebi', 'zepto', 'zero_Celsius', 'zetta']
单位类型
常量模块包含以下几种单位：
- 公制单位
- 二进制，以字节为单位
- 质量单位
- 角度换算
- 时间单位
- 长度单位
- 压强单位
- 体积单位
- 速度单位
- 温度单位
- 能量单位
- 功率单位
- 力学单位
from scipy import constants
print(constants.yotta) #1e+24
print(constants.zetta) #1e+21
print(constants.exa) #1e+18
print(constants.peta) #1000000000000000.0
print(constants.tera) #1000000000000.0
print(constants.giga) #1000000000.0
print(constants.mega) #1000000.0
print(constants.kilo) #1000.0
print(constants.hecto) #100.0
print(constants.deka) #10.0
print(constants.deci) #0.1
print(constants.centi) #0.01
print(constants.milli) #0.001
print(constants.micro) #1e-06
print(constants.nano) #1e-09
print(constants.pico) #1e-12
print(constants.femto) #1e-15
print(constants.atto) #1e-18
print(constants.zepto) #1e-21
1e+24
1e+21
1e+18
1000000000000000.0
1000000000000.0
1000000000.0
1000000.0
1000.0
100.0
10.0
0.1
0.01
0.001
1e-06
1e-09
1e-12
1e-15
1e-18
1e-21
二进制前缀
返回字节单位 (kibi 返回 1024)。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V12psmsZ-1660698429413)(attachment:image.png)]
from scipy import constants
print(constants.kibi) #1024
print(constants.mebi) #1048576
print(constants.gibi) #1073741824
print(constants.tebi) #1099511627776
print(constants.pebi) #1125899906842624
print(constants.exbi) #1152921504606846976
print(constants.zebi) #1180591620717411303424
print(constants.yobi) #1208925819614629174706176
1024
1048576
1073741824
1099511627776
1125899906842624
1152921504606846976
1180591620717411303424
1208925819614629174706176
质量单位
返回多少千克 kg。(gram 返回 0.001)。
from scipy import constants
print(constants.gram) #0.001
print(constants.metric_ton) #1000.0
print(constants.grain) #6.479891e-05
print(constants.lb) #0.45359236999999997
print(constants.pound) #0.45359236999999997
print(constants.oz) #0.028349523124999998
print(constants.ounce) #0.028349523124999998
print(constants.stone) #6.3502931799999995
print(constants.long_ton) #1016.0469088
print(constants.short_ton) #907.1847399999999
print(constants.troy_ounce) #0.031103476799999998
print(constants.troy_pound) #0.37324172159999996
print(constants.carat) #0.0002
print(constants.atomic_mass) #1.66053904e-27
print(constants.m_u) #1.66053904e-27
print(constants.u) #1.66053904e-27
0.001
1000.0
6.479891e-05
0.45359236999999997
0.45359236999999997
0.028349523124999998
0.028349523124999998
6.3502931799999995
1016.0469088
907.1847399999999
0.031103476799999998
0.37324172159999996
0.0002
1.66053904e-27
1.66053904e-27
1.66053904e-27
角度单位
返回弧度 (degree 返回 0.017453292519943295)。
from scipy import constants
print(constants.degree) #0.017453292519943295
print(constants.arcmin) #0.0002908882086657216
print(constants.arcminute) #0.0002908882086657216
print(constants.arcsec) #4.84813681109536e-06
print(constants.arcsecond) #4.84813681109536e-06
0.017453292519943295
0.0002908882086657216
0.0002908882086657216
4.84813681109536e-06
4.84813681109536e-06
时间单位
返回秒数(hour 返回 3600.0)。
from scipy import constants
print(constants.minute) #60.0
print(constants.hour) #3600.0
print(constants.day) #86400.0
print(constants.week) #604800.0
print(constants.year) #31536000.0
print(constants.Julian_year) #31557600.0
60.0
3600.0
86400.0
604800.0
31536000.0
31557600.0
长度单位
返回米数(nautical_mile 返回 1852.0)。
from scipy import constants
print(constants.inch) #0.0254
print(constants.foot) #0.30479999999999996
print(constants.yard) #0.9143999999999999
print(constants.mile) #1609.3439999999998
print(constants.mil) #2.5399999999999997e-05
print(constants.pt) #0.00035277777777777776
print(constants.point) #0.00035277777777777776
print(constants.survey_foot) #0.3048006096012192
print(constants.survey_mile) #1609.3472186944373
print(constants.nautical_mile) #1852.0
print(constants.fermi) #1e-15
print(constants.angstrom) #1e-10
print(constants.micron) #1e-06
print(constants.au) #149597870691.0
print(constants.astronomical_unit) #149597870691.0
print(constants.light_year) #9460730472580800.0
print(constants.parsec) #3.0856775813057292e+16
0.0254
0.30479999999999996
0.9143999999999999
1609.3439999999998
2.5399999999999997e-05
0.00035277777777777776
0.00035277777777777776
0.3048006096012192
1609.3472186944373
1852.0
1e-15
1e-10
1e-06
149597870691.0
149597870691.0
9460730472580800.0
3.0856775813057292e+16
速度单位
返回每秒多少米。(speed_of_sound 返回 340.5)
from scipy import constants
print(constants.kmh) #0.2777777777777778
print(constants.mph) #0.44703999999999994
print(constants.mach) #340.5
print(constants.speed_of_sound) #340.5
print(constants.knot) #0.5144444444444445
0.2777777777777778
0.44703999999999994
340.5
340.5
0.5144444444444445
SciPy 优化器
SciPy 的 optimize 模块提供了常用的最优化算法函数实现，我们可以直接调用这些函数完成我们的优化问题，比如查找函数的最小值或方程的根等。
NumPy 能够找到多项式和线性方程的根，但它无法找到非线性方程的根，如下所示：
x + cos(x)
因此我们可以使用 SciPy 的 optimze.root 函数，这个函数需要两个参数：
- fun - 表示方程的函数。
- x0 - 根的初始猜测。
该函数返回一个对象，其中包含有关解决方案的信息。
实际解决方案在返回对象的属性 x ，查看如下实例：
from scipy.optimize import root
from math import cos
def eqn(x):
return x + cos(x)
myroot = root(eqn, 0)
# print(myroot.x)
# 查看更多信息
print(myroot)
fjac: array([[-1.]])
fun: array([0.])
message: 'The solution converged.'
nfev: 9
qtf: array([-2.66786593e-13])
r: array([-1.67361202])
status: 1
success: True
x: array([-0.73908513])
最小化函数
函数表示一条曲线，曲线有高点和低点。
高点称为最大值。
低点称为最小值。
整条曲线中的最高点称为全局最大值，其余部分称为局部最大值。
整条曲线的最低点称为全局最小值，其余的称为局部最小值。
可以使用 scipy.optimize.minimize() 函数来最小化函数。
minimize() 函接受以下几个参数：
- fun - 要优化的函数
- x0 - 初始猜测值
- method - 要使用的方法名称，值可以是：'CG'，'BFGS'，'Newton-CG'，'L-BFGS-B'，'TNC'，'COBYLA'，，'SLSQP'。
- callback - 每次优化迭代后调用的函数。
- options - 定义其他参数的字典：
{
"disp": boolean - print detailed description
"gtol": number - the tolerance of the error
}
from scipy.optimize import minimize
def eqn(x):
return x**2 + x + 2
mymin = minimize(eqn, 0, method='BFGS')
print(mymin.x)
[-0.50000001]
scipy.optimize.minimize(
fun, #可调用的目标函数。
x0, #ndarray,初值。（n,）
args=(), #额外的参数传递给目标函数及其导数
method=None, #类型的解算器。应该是其中之一:
#‘Nelder-Mead’、‘Powell’
#‘CG’、‘BFGS’
#‘Newton-CG’、‘L-BFGS-B’
#‘TNC’、‘COBYLA’
#‘SLSQP’、‘dogleg’
#‘trust-ncg’
jac=None, #目标函数的雅可比矩阵(梯度向量)。
#仅适用于CG, BFGS, Newton-CG,
#L-BFGS-B, TNC, SLSQP, dogleg，
#trust-ncg。如果jac是一个布尔值，
#且为True，则假定fun将随目标函数返回
#梯度。如果为False，则用数值方法估计梯
#度。Jac也可以是返回目标梯度的可调用对
#象。在这种情况下，它必须接受与乐趣相同
#的论点。
hess=None,
hessp=None,#目标函数的Hessian(二阶导数矩阵)或
#目标函数的Hessian乘以任意向量p。
#仅适用于Newton-CG, dogleg,
#trust-ncg。只需要给出一个hessp或
#hess。如果提供了hess，则将忽略
#hessp。如果不提供hess和hessp，则用
#jac上的有限差分来近似Hessian积。
#hessp必须计算Hessian乘以任意向量。
bounds=None, #变量的边界(仅适用于L-BFGS-B,
#TNC和SLSQP)。(min, max)
#对x中的每个元素，定义该参数的
#边界。当在min或max方向上没有边界
#时，使用None表示其中之一。
constraints=(), #约束定义
#(仅适用于COBYLA和SLSQP)
tol=None, #终止的边界。
callback=None,
options=None)
返回值: res : OptimizeResult
#以OptimizeResult对象表示的优化结果。重要的属性有:x是解决方案数组，
#success是一个布尔标志，指示优化器是否成功退出，以及描述终止原因的消息。
scipy中的optimize子包中提供了常用的最优化算法函数实现，我们可以直接调用这些函数完成我们的优化问题。
scipy.optimize包提供了几种常用的优化算法。 该模块包含以下几个方面
-
使用各种算法(例如BFGS，Nelder-Mead单纯形，牛顿共轭梯度，COBYLA或SLSQP)的无约束和约束最小化多元标量函数(minimize())
-
全局(蛮力)优化程序(例如，anneal()，basinhopping())
-
最小二乘最小化(leastsq())和曲线拟合(curve_fit())算法
-
标量单变量函数最小化(minim_scalar())和根查找(newton())
-
使用多种算法(例如，Powell，Levenberg-Marquardt混合或Newton-Krylov等大规模方法)的多元方程系统求解
在用python实现逻辑回归和线性回归时，使用梯度下降法最小化cost function，用到了fmin_tnc()和minimize()。
一、fmin_tnc()
用于处理有约束的多元函数问题，需要提供梯度下降的参数信息，使用截断牛顿法。
- 调用：
scipy.optimize.fmin_tnc(func, x0, fprime=None, args=(), approx_grad=0, bounds=None, epsilon=1e-08, scale=None, offset=None, messages=15, maxCGit=-1, maxfun=None, eta=-1, stepmx=0, accuracy=0, fmin=0, ftol=-1, xtol=-1, pgtol=-1, rescale=-1, disp=None, callback=None)
- 最常使用的参数：
func：优化的目标函数
x0：初值
fprime：提供优化函数func的梯度函数，不然优化函数func必须返回函数值和梯度，或者设置approx_grad=True
approx_grad :如果设置为True，会给出近似梯度
args：元组，是传递给优化函数的参数
- 返回：
x ： 数组，返回的优化问题目标值
nfeval ： 整数，function evaluations的数目
在进行优化的时候，每当目标优化函数被调用一次，就算一个function evaluation。在一次迭代过程中会有多次function evaluation。这个参数不等同于迭代次数，而往往大于迭代次数。
rc ： int,Return code, see below
二、minimize()
- 调用：
scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)
- 参数：
fun ：优化的目标函数
x0 ：初值，一维数组，shape (n,)
args ： 元组，可选，额外传递给优化函数的参数
method：求解的算法，选择TNC则和fmin_tnc()类似
jac：返回梯度向量的函数
- 返回：
返回优化结果对象，x：优化问题的目标数组。success: True表示成功与否，不成功会给出失败信息。
SciPy 稀疏矩阵
稀疏矩阵（英语：sparse matrix）指的是在数值分析中绝大多数数值为零的矩阵。反之，如果大部分元素都非零，则这个矩阵是稠密的(Dense)。
在科学与工程领域中求解线性模型时经常出现大型的稀疏矩阵。
SciPy 的 scipy.sparse 模块提供了处理稀疏矩阵的函数。
我们主要使用以下两种类型的稀疏矩阵：
- CSC - 压缩稀疏列（Compressed Sparse Column），按列压缩。
- CSR - 压缩稀疏行（Compressed Sparse Row），按行压缩。
CSR 矩阵
我们可以通过向 scipy.sparse.csr_matrix() 函数传递数组来创建一个 CSR 矩阵
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse import csc_matrix
arr = np.array([0,0,0,0,0,1,1,0,2])
print(csc_matrix(arr))
(0, 5) 1
(0, 6) 1
(0, 8) 2
结果解析：
- 第一行：在矩阵第一行（索引值 0 ）第六（索引值 5 ）个位置有一个数值 1。
- 第二行：在矩阵第一行（索引值 0 ）第七（索引值 6 ）个位置有一个数值 1。
- 第三行：在矩阵第一行（索引值 0 ）第九（索引值 8 ）个位置有一个数值 2。
CSR 矩阵方法
我们可以使用 data 属性查看存储的数据（不含 0 元素）：
arr = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 2]])
print(csr_matrix(arr).data)
[1 1 2]
使用 count_nonzero() 方法计算非 0 元素的总数：
import numpy as np
from scipy.sparse import csr_matrix
arr = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 2]])
print(csr_matrix(arr).count_nonzero())
3
使用 eliminate_zeros() 方法删除矩阵中 0 元素：
import numpy as np
from scipy.sparse import csr_matrix
arr = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 2]])
mat = csr_matrix(arr)
mat.eliminate_zeros()
print(mat)
(1, 2) 1
(2, 0) 1
(2, 2) 2
使用 sum_duplicates() 方法来删除重复项:
import numpy as np
from scipy.sparse import csr_matrix
arr = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 2]])
mat = csr_matrix(arr)
mat.sum_duplicates()
print(mat)
(1, 2) 1
(2, 0) 1
(2, 2) 2
csr 转换为 csc 使用 tocsc() 方法：
import numpy as np
from scipy.sparse import csr_matrix
arr = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 2]])
newarr = csr_matrix(arr).tocsc()
print(newarr)
(2, 0) 1
(1, 2) 1
(2, 2) 2
SciPy 图结构
图结构是算法学中最强大的框架之一。
图是各种关系的节点和边的集合，节点是与对象对应的顶点，边是对象之间的连接。
SciPy 提供了 scipy.sparse.csgraph 模块来处理图结构。
邻接矩阵
邻接矩阵（Adjacency Matrix）是表示顶点之间相邻关系的矩阵。
邻接矩阵逻辑结构分为两部分：V 和 E 集合，其中，V 是顶点，E 是边，边有时会有权重，表示节点之间的连接强度。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9hmKXEes-1660698429415)(attachment:image.png)]
邻接矩阵又分为有向图邻接矩阵和无向图邻接矩阵。
无向图是双向关系，边没有方向：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7OV2wRR-1660698429416)(attachment:image.png)]
有向图时边带有方向，是单项关系：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z3aUAYiU-1660698429416)(attachment:image.png)]
注：上面两个图中的 D 节点是自环，自环是指一条边的两端为同一个节点
连接组件
查看所有连接组件使用 connected_components() 方法
import numpy as np
from scipy.sparse.csgraph import connected_components
from scipy.sparse import csr_matrix
arr = np.array([
[0, 1, 2],
[1, 0, 0],
[2, 0, 0]
])
newarr = csr_matrix(arr)
print(connected_components(newarr))
(1, array([0, 0, 0]))
Dijkstra – 最短路径算法
Dijkstra(迪杰斯特拉)最短路径算法，用于计算一个节点到其他所有节点的最短路径。
Scipy 使用 dijkstra() 方法来计算一个元素到其他元素的最短路径。
dijkstra() 方法可以设置以下几个参数：
1、return_predecessors: 布尔值，设置 True，遍历所有路径，如果不想遍历所有路径可以设置为 False。
2、indices: 元素的索引，返回该元素的所有路径。
3、limit: 路径的最大权重。
# 查找元素 1 到 2 的最短路径：
import numpy as np
from scipy.sparse.csgraph import dijkstra
from scipy.sparse import csr_matrix
arr = np.array([
[0, 1, 2],
[1, 0, 0],
[2, 0, 0]
])
newarr = csr_matrix(arr)
print(dijkstra(newarr, return_predecessors=True, indices=0))
(array([0., 1., 2.]), array([-9999, 0, 0]))
Floyd Warshall – 弗洛伊德算法
弗洛伊德算法算法是解决任意两点间的最短路径的一种算法。
Scipy 使用 floyd_warshall() 方法来查找所有元素对之间的最短路径。
# 查找所有元素对之间的最短路径径：
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
from scipy.sparse import csr_matrix
arr = np.array([
[0, 1, 2],
[1, 0, 0],
[2, 0, 0]
])
newarr = csr_matrix(arr)
print(floyd_warshall(newarr, return_predecessors=True))
(array([[0., 1., 2.],
[1., 0., 3.],
[2., 3., 0.]]), array([[-9999, 0, 0],
[ 1, -9999, 0],
[ 2, 0, -9999]]))
Bellman Ford – 贝尔曼-福特算法
贝尔曼-福特算法是解决任意两点间的最短路径的一种算法。
Scipy 使用 bellman_ford() 方法来查找所有元素对之间的最短路径，通常可以在任何图中使用，包括有向图、带负权边的图。
# 使用负权边的图查找从元素 1 到元素 2 的最短路径：
import numpy as np
from scipy.sparse.csgraph import bellman_ford
from scipy.sparse import csr_matrix
arr = np.array([
[0, -1, 2],
[1, 0, 0],
[2, 0, 0]
])
newarr = csr_matrix(arr)
print(bellman_ford(newarr, return_predecessors=True, indices=0))
(array([ 0., -1., 2.]), array([-9999, 0, 0]))
深度优先顺序
depth_first_order() 方法从一个节点返回深度优先遍历的顺序。
可以接收以下参数：
1、 图
2、图开始遍历的元素
import numpy as np
from scipy.sparse.csgraph import depth_first_order
from scipy.sparse import csr_matrix
arr = np.array([
[0, 1, 0, 1],
[1, 1, 1, 1],
[2, 1, 1, 0],
[0, 1, 0, 1]
])
newarr = csr_matrix(arr)
print(newarr)
# print(depth_first_order(newarr, 1))
(0, 1) 1
(0, 3) 1
(1, 0) 1
(1, 1) 1
(1, 2) 1
(1, 3) 1
(2, 0) 2
(2, 1) 1
(2, 2) 1
(3, 1) 1
(3, 3) 1
广度优先顺序
breadth_first_order() 方法从一个节点返回广度优先遍历的顺序。
可以接收以下参数：
1、 图
2、图开始遍历的元素
## 给定一个邻接矩阵，返回广度优先遍历的顺序：
import numpy as np
from scipy.sparse.csgraph import breadth_first_order
from scipy.sparse import csr_matrix
arr = np.array([
[0, 1, 0, 1],
[1, 1, 1, 1],
[2, 1, 1, 0],
[0, 1, 0, 1]
])
newarr = csr_matrix(arr)
print(breadth_first_order(newarr, 1))
(array([1, 0, 2, 3]), array([ 1, -9999, 1, 1]))
SciPy Matlab 数组
NumPy 提供了 Python 可读格式的数据保存方法。
SciPy 提供了与 Matlab 的交互的方法。
SciPy 的 scipy.io 模块提供了很多函数来处理 Matlab 的数组。
以 Matlab 格式导出数据
savemat() 方法可以导出 Matlab 格式的数据。
该方法参数有：
- filename - 保存数据的文件名。
- mdict - 包含数据的字典。
- do_compression - 布尔值，指定结果数据是否压缩。默认为 False。
将数组作为变量 “vec” 导出到 mat 文件：
from scipy import io
import numpy as np
arr = np.arange(10)
io.savemat('arr.mat', {"vec": arr})
导入 Matlab 格式数据
loadmat() 方法可以导入 Matlab 格式数据。
该方法参数：
- filename - 保存数据的文件名。
返回一个结构化数组，其键是变量名，对应的值是变量值。
以下实例从 mat 文件中导入数组：
from scipy import io
import numpy as np
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9,])
# 导出
io.savemat('arr.mat', {"vec": arr})
# 导入
mydata = io.loadmat('arr.mat')
print(mydata)
{'__header__': b'MATLAB 5.0 MAT-file Platform: nt, Created on: Tue Aug 16 17:10:26 2022', '__version__': '1.0', '__globals__': [], 'vec': array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])}
# 使用变量名 "vec" 只显示 matlab 数据的数组：
from scipy import io
import numpy as np
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9,])
# 导出
io.savemat('arr.mat', {"vec": arr})
# 导入
mydata = io.loadmat('arr.mat')
print(mydata['vec'])
[[0 1 2 3 4 5 6 7 8 9]]
从结果可以看出数组最初是一维的，但在提取时它增加了一个维度，变成了二维数组。
解决这个问题可以传递一个额外的参数 squeeze_me=True：
from scipy import io
import numpy as np
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9,])
# 导出
io.savemat('arr.mat', {"vec": arr})
# 导入
mydata = io.loadmat('arr.mat', squeeze_me=True)
print(mydata['vec'])
[0 1 2 3 4 5 6 7 8 9]
SciPy 插值
什么是插值？
在数学的数值分析领域中，插值（英语：interpolation）是一种通过已知的、离散的数据点，在范围内推求新数据点的过程或方法。
简单来说插值是一种在给定的点之间生成点的方法。
例如：对于两个点 1 和 2，我们可以插值并找到点 1.33 和 1.66。
插值有很多用途，在机器学习中我们经常处理数据缺失的数据，插值通常可用于替换这些值。
这种填充值的方法称为插补。
除了插补，插值经常用于我们需要平滑数据集中离散点的地方。
如何在 SciPy 中实现插值？
SciPy 提供了 scipy.interpolate 模块来处理插值。
一维插值
一维数据的插值运算可以通过方法 interp1d() 完成。
该方法接收两个参数 x 点和 y 点。
返回值是可调用函数，该函数可以用新的 x 调用并返回相应的 y，y = f(x)。
对给定的 xs 和 ys 插值，从 2.1、2.2… 到 2.9：
注意：新的 xs 应该与旧的 xs 处于相同的范围内，这意味着我们不能使用大于 10 或小于 0 的值调用 interp_func()。
from scipy.interpolate import interp1d
import numpy as np
xs = np.arange(10)
ys = 2*xs + 1
interp_func = interp1d(xs, ys)
newarr = interp_func(np.arange(2.1, 8, 0.1))
print(newarr)
[ 5.2 5.4 5.6 5.8 6. 6.2 6.4 6.6 6.8 7. 7.2 7.4 7.6 7.8
8. 8.2 8.4 8.6 8.8 9. 9.2 9.4 9.6 9.8 10. 10.2 10.4 10.6
10.8 11. 11.2 11.4 11.6 11.8 12. 12.2 12.4 12.6 12.8 13. 13.2 13.4
13.6 13.8 14. 14.2 14.4 14.6 14.8 15. 15.2 15.4 15.6 15.8 16. 16.2
16.4 16.6 16.8]
单变量插值
在一维插值中，点是针对单个曲线拟合的，而在样条插值中，点是针对使用多项式分段定义的函数拟合的。
单变量插值使用 UnivariateSpline() 函数，该函数接受 xs 和 ys 并生成一个可调用函数，该函数可以用新的 xs 调用。
分段函数，就是对于自变量 x 的不同的取值范围，有着不同的解析式的函数。
为非线性点找到 2.1、2.2…2.9 的单变量样条插值：
from scipy.interpolate import UnivariateSpline
import numpy as np
xs = np.arange(10)
ys = xs**2 + np.sin(xs) + 1
interp_func = UnivariateSpline(xs, ys)
newarr = interp_func(np.arange(2.1, 3, 0.1))
print(newarr)
[5.62826474 6.03987348 6.47131994 6.92265019 7.3939103 7.88514634
8.39640439 8.92773053 9.47917082]
7454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
