PythonGuides 博客中文翻译（一百一十）

Scipy 卷积器 2d

Scipy 在模块*scipy.ndimage*中有一个方法*convolve()*，它使用提供的权重计算指定轴上的多维卷积。

下面给出了语法。

scipy.ndimage.convolve(input, weights, axis=- 1, output=None, mode='reflect', cval=0.1, origin=1)

其中参数为:

输入(数组): 输入的是数组数据。
权重(ndarray): 权重数组的维数必须等于输入数组的维数。
output(dtype，array): 用于指定作为输出返回的数组的数据类型。
mode(): 当我们想要扩展输入数组的边界时，它用来控制输入数组的边界。这些模式包括环绕、恒定、最近、镜像和反射。
cval(标量):当模式设置为常量时，它用于填充输入数组的过去的边。
origin(int):用于在给定的输入数组上放置过滤器，如果值为零，则将过滤器放在中间。如果值为正，将滤镜放在左侧，如果值为负，将滤镜放在右侧。

让我们通过下面的步骤来了解一个示例:

使用下面的 python 代码导入所需的库。

from scipy import ndimage
import numpy as np

使用下面的 Python 代码创建一个包含多个值和权重的二维数组。

array_data = np.array([(5,4,6,8),(1,0,7,4)])
weight = np.array([[0,0,1],[1,1,1]])

现在将上面创建的二维数组和权重传递给方法*convolve*。

ndimage.convolve(array_data,weights=weight,cval=0.1,mode='constant')

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Convolve 2d

阅读:剪切旋转图像

Scipy 卷积 3d

Scipy 在模块*scipy.ndimage*中有一个方法*convolve()*，用于计算多维卷积。这里，我们将使用与上一小节中使用的 3d 数组相同的方法。

下面给出了语法。

scipy.ndimage.convolve(input, weights, axis=- 1, output=None, mode='reflect', cval=0.1, origin=1)

其中参数为:

输入(数组): 输入的是数组数据。
权重(ndarray): 权重数组的维数必须等于输入数组的维数。
output(dtype，array): 用于指定作为输出返回的数组的数据类型。
mode(): 当我们想要扩展输入数组的边界时，它用来控制输入数组的边界。这些模式包括环绕、恒定、最近、镜像和反射。
cval(标量): 用于在模式设置为常量时填充输入数组的过去的边。
origin(int): 用于将过滤器放在给定的输入数组上，如果值为零则将过滤器放在中间。如果值为正，将滤镜放在左侧，如果值为负，将滤镜放在右侧。

让我们通过下面的步骤来了解一个示例:

使用下面的 python 代码导入所需的库。

from scipy import ndimage
import numpy as np

使用下面的代码创建一个包含多个值和权重的三维数组。

array_data = np.array([[[3,18], [46, 80]], [[0, 0], [62, 86]],[[86,34],[22,19]]])
weight = np.array([[[0,0,1],[1,1,1],[0,1,0]]])

现在将上面创建的三维数组和权重传递给方法*convolve*。

ndimage.convolve(array_data,weights=weight,cval=0.1,mode='constant')

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Convolve 3d

阅读:科学常数

Scipy 卷积 fft

Scipy 在模块*scipy.signal*中有一个方法*fftconvolve()*，它使用方法 FFT (快速傅立叶变换)卷积 n 维数组。

下面给出了语法。

scipy.signal.fftconvolve(in1, in2, mode='full', method='auto')

其中参数为:

in1(array_data): 用于以数组的形式输入第一个信号。
in2(array_data): 用于以数组的形式输入第二个信号，维数必须与第一个输入数组相同。
模式: 用于指定决定输出大小的字符串。模式可以是*same*、*full*和*valid*。
方法: 用于指定计算卷积的方法。方法可以是*auto*、*direct*、*fft*。

让我们通过下面的步骤来了解一个示例:

使用下面的 python 代码导入所需的库。

from scipy.signal import fftconvolve
import scipy.signal
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

生成随机噪声信号，并使用以下代码应用方法fftconvolveI()。

random_gen = np.random.default_rng()
s = random_gen.standard_normal(800)
autocorrelation = fftconvolve(s, s[::-1], mode='full')

让我们用下面的代码画出上面卷积的信号。

fig, (orig_axes, mag_axes) = plt.subplots(2, 1)
orig_axes.plot(s)
orig_axes.set_title('It is noise')
mag_axes.plot(np.arange(-len(s)+1,len(s)), autocorrelation)
mag_axes.set_title('It is autocorrelation')
fig.tight_layout()
fig.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Convolve fftconvolve

这是如何在 Python 中使用 Scipy 来使用方法*fftconvolve()*。

阅读:科学统计

Scipy 卷积高斯

Scipy 在模块*scipy.ndimage*中有一个方法*gaussian_filter*，它将高斯函数应用到多维数组中。

下面给出了语法。

scipy.ndimage.gaussian_filter(input, sigma, order=0, output=int, mode='nerest', cval=1.1, truncate=3.1)

其中参数为:

输入(数组 _ 数据): 输入的是数组数据。
∑(标量序列): 高斯核标准差。
顺序(int): 用于指定过滤器的顺序。
output(dtype，array): 用于指定作为输出返回的数组的数据类型。
mode(): 当我们想要扩展给定数组的边界时，它用来控制作为输入的该数组的边界。模式有*wrap*、*constant*、*nearest*、*mirror*和*reflect*。
cval(标量): 用于当模式设置为constant时，填充给定数组过去的边作为输入。

方法*gaussian_filter*返回 ndarray 类型的 gaussian_filter 。

让我们通过下面的步骤用一个例子来理解:
使用下面的 python 代码导入所需的库。

from scipy.ndimage import gaussian_filter
import numpy as np

使用下面的代码创建一个包含值的数组。

array_data = np.arange(100, step=4).reshape((5,5))
array_data

现在，使用下面的代码对数组数据应用高斯过滤器。

gaussian_filter(array_data, sigma=1)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Convolve Gaussian

这是如何在 Python 程序中使用 Scipy 将高斯过滤器应用于数据数组。

Scipy 沿轴卷积

这里我们将使用 Scipy 的相同方法*convolve1d()*在指定的轴上卷积给定的数组。

要了解方法*convolve()*，请参考上述小节。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy import ndimage
import numpy as np

使用下面的 python 代码创建一个包含多个值和权重的二维数组。

array_data = np.array([(4,5,8,6),(0,1,4,7)])
weight = [0,1,1]

将上面创建的二维数组和权重传递给方法*convolve*，不指定轴参数。

ndimage.convolve1d(array_data,weights=weight)

使用下面的代码，在轴等于 0 的情况下再次运行上面的代码。

ndimage.convolve1d(array_data,weights=weight,axis=0)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Convolve along axis

看看两个代码的结果，一个没有轴，另一个有轴。

阅读: Scipy 信号-有用教程

Scipy 卷积内核

权重是卷积中称为核的一组值，它作为输入在给定的数组上滑动以转换该数据。这里我们将使用我们在上面小节中学到的相同的 Scipy 方法*convolve()*。

让我们按照以下步骤通过一个示例来理解:

使用下面的 python 代码导入所需的库。

from scipy import ndimage
import numpy as np

使用下面的代码创建一个包含几个值和权重或内核的二维数组。

array_data = np.array([(1,4,8,6),(4,7,0,4)])
kernel = np.array([[1,0,1],[1,1,0]])

将上面创建的二维数组和内核传递给方法*convolve*并查看结果。

ndimage.convolve(array_data,weights=kernel)

使用下面的代码创建一个新的内核。

kernel_2 = np.array([[0,0,1],[0,1,1]])

同样，将新内核传递给一个方法，并使用下面的代码查看结果。

ndimage.convolve(array_data,weights=kernel_2)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Convolve kernel

这就是如何使用不同的内核对相同的数据实现不同的转换。

另外，请查看以下 Python SciPy 教程。

因此，在本教程中，我们学习了“ Scipy Convolve ”并涵盖了以下主题。

Scipy 卷积 3d
科学卷积 2d
Scipy 卷积 1d
快速卷积 fft
高斯卷积
敏捷的回旋步伐
沿轴卷曲
卷曲核

Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。

如何使用 Python Scipy 差分进化

原文：https://pythonguides.com/scipy-differential-evolution/

我们将学习“ Python Scipy 差分进化 ”，差分进化(DE)是一种基于种群的元启发式搜索技术，它基于进化过程迭代地改进潜在的解决方案，以优化问题。还将介绍如何使用不同的策略并行计算解决方案，主题如下。

什么是差异进化
Python 科学差分进化
如何使用不同策略的科学差分进化
如何并行执行快速差分进化
定义约束并在差异进化中使用它们
Python Scipy 差分进化界限

什么是差异进化
Python Scipy 差分进化
Python Scipy 差分进化策略
Python Scipy 差分进化并行
Python Scipy 差分进化约束
Python Scipy 差分进化界限

什么是差异进化

差分进化(DE)，一种用于进化计算的技术，寻求迭代地增强关于指定质量度量的候选解。

由于它们可以搜索很宽的潜在解空间，并且对被优化的问题很少或不做假设，这种技术经常被称为元启发式。然而，像 DE 这样的元试探法并不能确保找到理想的解决方案。

不同于传统的优化技术，如梯度下降和拟牛顿法，它们都要求优化问题是可微的，DE 不使用被优化问题的梯度，因此适用于多维实值函数。因此，差分进化可以应用于优化问题，甚至不连续，噪音，随时间变化等。

DE 使用简单的公式来组合当前的候选解，以创建新的候选解，维持候选解的群体，并保留手头的优化任务上具有最高分数或适应度的候选解。

在这种方法中，不需要梯度，因为优化问题被视为“黑箱”,它只提供给定候选解的质量度量。

潜在解决方案的群体是差分进化算法的基本变体的运行方式(称为代理)。通过组合群体中当前代理的位置，这些代理使用简单的数学公式在搜索空间中移动。
如果一个代理的新位置是一个改进，它被接受并添加到群体中；否则就是刚淘汰。人们希望，但不能保证，重复这一程序将导致最终发现一个可行的解决办法。

阅读:如何使用 Python Scipy Linprog

Python Scipy 差分进化

模块scipy.optimize有一个方法differential_evolution(),可以找到多元函数的全局最小值。

下面给出了语法。

scipy.optimize.differential_evolution(func, bounds, strategy='best1bin', maxiter=1000, popsize=15, tol=0.01, mutation=(0.5, 1), recombination=0.7, seed=None, callback=None, disp=False, polish=True, init='latinhypercube', atol=0, updating='immediate', workers=1, constraints=(), x0=None, *, integrality=None, vectorized=False)

其中参数为:

**func(可调用)😗*目标是最小化目标函数。必须具有 f(x，*args)的形式，其中 args 是完整解释函数所需的所有附加固定参数的元组，x 是一维数组形式的输入。n 就参数(x)而言等于 len。
**界限(序列)😗*对于变量，界限。可以用两种方法之一来指定边界:1 .Bounds 类实例。2.(min，max)对，为 x 中的每个元素指定 func 的优化参数的有限下限和上限。参数的数量 N 通过边界的总和计算得出。
**策略(字符串)😗*使用差异进化的技术。应该是下列值之一:“best1bin”、“best1exp”、“rand1exp”、“randtobest1exp”、“currenttobest1exp”、“best2exp”、“rand2exp”、“randtobest1bin”、“currenttobest1bin”、“best2bin”、“rand2bin”、“rand1bin”。
maxiter(int): 整个种群最多可以进化的代数。(maxiter + 1) * popsize * N 是可以执行的函数求值的最大次数(没有抛光)。
popsize(int): 用于确定人口总体规模的乘数。人口中有 popsize * N 人。如果 init 关键字用于提供初始填充，则忽略该术语。当使用 init='sobol '时，通过在 popsize * N 之后取 2 的下一次幂来确定群体大小。
tol(float): 当求解器达到收敛的相对容差时，NP . STD(pop)= atol+tol * NP . ABS(NP . mean(群体能量))，其中，atol 和 tol 是对应的绝对容差和相对容差。
**突变(浮点或元组)😗*诱变常数。术语“不同重量”也在文献中使用，用字母 f 表示。如果提供浮子，应使用范围[0，2]。当值以元组(min，max)的形式给出时，使用抖动。在逐代的基础上，抖动随机修改变异常数。对于世代，U[min，max]用于计算变异常数。抖动可以大大加速收敛。虽然增加变异常数会减慢收敛速度，但会扩大搜索范围。
**重组(浮点)😗*范围[0，1]应该是重组常数。这在文献中也称为交叉概率，用字母 CR 表示。增加这个值允许更多的突变体存活到下一代，但是这样做是以牺牲种群稳定性为代价的。
seed: 如果 seed 为 None(或 np.random)则使用 Numpy.random。它使用 RandomState 的单例。如果种子是整数，则创建 RandomState 的一个新实例，并用该种子作为种子。如果种子已经有一个生成器或 RandomState 实例，则使用它。对于重复最小化，请指定一个种子。
disp(bool): 在每次迭代时，打印计算后的函数。
**回调:**跟踪最小化过程的函数。目前为止最好的答案是 xk。val 表示总体收敛的分数值。当 val 大于 1 时，该功能停止。当回调返回 True 时，最小化停止(任何抛光仍在进行)。
polish(boolean): 如果为真(默认)，则在最后使用 L-BFGS-B 方法对最佳群体成员进行抛光，这可以略微增强最小化。当研究一个有限的问题时，信任-建构方法被用来代替它。
init(string，array_data): 表示执行的群体初始化的种类。应该是以下之一:“latinhypercube”、“sobol”、“halton”、“random”。
atol(float): 当达到收敛的绝对容差 NP . STD(pop)= atol+tol * NP . ABS(NP . mean(群体能量))时，其中 atol 和 tol 是对应的绝对和相对容差，问题无法解决。
**更新(延迟，立即)😗*如果“立即”，则最优解向量在整个一代中重复更新。结果，收敛可能发生得更快，因为试验向量可能受益于理想结果的持续发展。当选择该选项时，最佳解决方案向量每一代更新一次。与并行化或矢量化兼容的唯一选项是“延迟”，它可以被 workers 和矢量化关键字覆盖。
workers(int 或 map-like):如果 workers 是一个整数，则群体被分成 workers 部分并并行计算(使用多重处理)。池)。要利用所有的 CPU 内核，请提供-1。或者，提供一个类似于映射的可调用函数，比如多重处理。Pool.map 用于同时评估总体。该评估由工人(func，iterable)完成。如果工人！= 1，此选项将用 updating='deferred '替换 updating 关键字。如果工人！= 1，此选项优先于矢量化关键字。它还要求 func 是可选择的。
约束(bounds，LinearConstraint，NonLinearConstraint):除了边界 kwd 所施加的限制之外，对求解器的附加限制。采用了兰皮宁的策略。
x0(array_like 或 None):在开始时给出最小化的粗略估计。一旦群体被初始化，这个向量就代替初始(最佳)成员。即使给 init 一个初始种群，这种替换仍然会执行。Shape == x0 (N，)。
integrality(一维数组):一个布尔值，指示决策变量是否限于每个决策变量的整数值。该阵列传输到(N，)。如果任何决策变量需要积分，抛光过程不会改变它们。我们只利用落在上限和下限内的整数。如果边界之间没有整数值，将引发 ValueError。
矢量化(布尔值):给定一个 x 数组，x.shape == (N，S)，func 应该返回一个包含 shape 的数组，其中 S 是需要生成的解向量的数量，如果矢量化设置为 True。如果使用了约束，每个构建约束对象的函数都应该接受一个 x 数组，其中 x.shape == (N，S)并返回一个 shape (M，S)数组，其中 M 是约束组件的数量。工作者并行化的这种替代方案可以通过最小化来自重复函数调用的解释器开销来提高优化速度。如果工人！= 1，将不使用该关键字。updating='deferred '选项将优先于 updating 关键字。有关何时使用“矢量化”和何时使用“workers”的更多信息，请参见注释部分。

方法differential_evolution()返回res:optimize result 对象用于表示优化结果。解决方案数组 x、success、指示优化器是否成功终止的布尔指示以及解释终止原因的消息都是重要的特性。

让我们举个例子，了解一下方法differential_evolution()是如何工作的。

使用下面的 python 代码导入所需的库或方法。

from scipy import optimize

考虑 Rosenbrock 函数最小化问题。在“scipy.optimize”中，这个函数是使用下面的代码在 Rosen 中实现的。

bounds_ = [(0,1), (0, 1), (0, 1), (0, 1), (0, 1)]
result_ = optimize.differential_evolution(optimize.rosen, bounds_)
result_.x, result_.fun

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Differential Evolution

这就是如何使用 Python Scipy 的方法*differential_evolution()*对目标函数rsoen执行差分进化。

阅读: Python Scipy Lognormal + 10 个例子

Python Scipy 差分进化策略

该算法特别适合于非微分非线性目标函数，因为它在搜索过程中不使用梯度信息。

该方法通过跟踪被表示为具有实值的向量的潜在答案群体来操作。当前解决方案的修改版本用于产生新的候选解决方案，每次算法迭代时，这些新的候选解决方案替换相当大的群体块。

使用 “策略” ，形成新的候选解，所述策略包括选择向其引入突变的基础解和来自群体的额外候选解，从所述群体中确定突变的数量和种类，称为差异向量。例如，对于变异中的差异向量，策略可能选择最佳候选解作为基础和随机解。

使用以下常用术语描述差异策略:

**“DE/x/y/z”😗*其中 DE 指的是“差异进化”，x 表示将被改变的初始解。例如，“rand”代表随机，“best”代表在群体中找到的最佳解决方案。变量 y 和 z 用于表示添加到基础解的差向量的数量，例如 1，概率分布用于决定每个解在总体中是被保留还是被替换，例如分别为二项式或指数式。

由于配置“DE/best/1/bin”和“DE/best/2/bin”在广泛的目标函数上的强大性能，它们是很受欢迎的配置。

【策略】 参数是 Python Scipy 方法*differential_evolution*的一个至关重要的超参数，它规定了所执行的差分进化搜索的种类。这通常设置为***【best 1 bin】***(DE/best/1/bin)，这是一个适合大多数问题的设置。通过从群体中选择随机解决方案，将它们彼此相除，并将结果的缩放版本添加到群体中的顶部候选解决方案，它生成新的候选解决方案。

阅读: Python Scipy Butterworth 滤镜

Python Scipy 差分进化并行

该函数将并行最小化，因此要了解差分进化并行是如何工作的，请参考上面小节中解释的参数updating和workers。

让我们以与上述小节相同的示例为例，但按照以下步骤进行并行化:

使用下面的 python 代码导入所需的库或方法。

from scipy import optimize

使用下面的代码考虑 Rosenbrock 函数最小化问题。

bounds_ = [(1,3), (1, 3), (1, 3), (1, 3), (1, 3)]
result_ = optimize.differential_evolution(optimize.rosen, bounds_,updating='deferred',workers=2)
result_.x, result_.fun

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Differential Evolution Parallel

这就是如何使用 Python Scipy 的方法*differential_evolution()*和参数*workers*来执行并行差分进化。

阅读: Python Scipy 曲线拟合–详细指南

Python Scipy 差分进化约束

我们已经了解了如何计算差异进化及其参数，因此在本节中，我们将按照以下步骤进行约束最小化:

使用下面的 python 代码导入所需的库或方法。

from scipy import optimize
import numpy as np

使用下面的代码定义约束函数。

def constr_fun(x):
    return np.array(x[0] + x[1])

使用下面的代码，使用方法*NonLinearConstraint*和*Bounds*定义约束和界限或限制。

nlc_ = optimize.NonlinearConstraint(constr_fun, -np.inf, 1.8)
bounds_ = optimize.Bounds([0., 0.], [1., 2.])

现在使用下面的代码最小化约束。

result = optimize.differential_evolution(optimize.rosen, bounds_, constraints=(nlc_),
                                seed=1)
result.x, result.fun

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Differential Evolution Constraints

这就是如何通过 Python Scipy 的方法*differential_evolution()*使用约束。

阅读: Python Scipy 加载 Mat 文件

Python Scipy 差分进化界限

Python Scipy 的方法*differential_evolution()*接受一个参数*bounds*。有两种方法来定义边界:1 .界限类实例号。2.对于 x 中的每个元素，使用(min，max)对来提供 func 的优化参数的有限下限和上限。边界总数用于计算参数计数 n。

让我们以上面小节中使用的相同示例为例，通过以下步骤来理解参数界限是如何工作的:

使用下面的 python 代码导入所需的库或方法。

from scipy import optimize
import numpy as np

使用下面的代码定义约束函数。

def constr_fun(x):
    return np.array(x[0] + x[1])

使用下面的代码，使用方法*NonLinearConstraint*和*Bounds*定义约束和界限或限制。

nlc_ = optimize.NonlinearConstraint(constr_fun, -np.inf, 1.8)
bounds_ = optimize.Bounds([0., 0.], [1., 2.])

在上面的代码中界限被定义为Bounds([0., 0.], [1., 2.])。

现在使用下面的代码最小化约束。

result = optimize.differential_evolution(optimize.rosen, bounds_, constraints=(nlc_),
                                seed=1)
result.x, result.fun

现在，使用下面的代码更改界限的值。

nlc_ = optimize.NonlinearConstraint(constr_fun, -np.inf, 1.8)
bounds_ = optimize.Bounds([2., 0.], [1., 2.])

使用下面的代码计算不同边界的最小化约束。

result = optimize.differential_evolution(optimize.rosen, bounds_, constraints=(nlc_),
                                seed=1)
result.x, result.fun

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Differential Evolution Bounds

这就是如何定义边界并在*differential_evolution()* Python Scipy 中使用它们。

您可能也喜欢阅读下面的 Python Scipy 教程。

我们已经学习了如何使用差分进化找到最优解，并并行执行差分进化以使过程更快，还学习了如何使用差分进化的约束和界限。

什么是差异进化
Python 科学差分进化
如何使用不同策略的科学差分进化
如何并行执行快速差分进化
定义约束并在差异进化中使用它们
Python Scipy 差分进化界限

Python 科学距离矩阵

原文：https://pythonguides.com/scipy-distance-matrix/

在本 Python 教程中，我们将学习“ Python Scipy 距离矩阵”，其中我们将使用不同的距离方法(如欧几里德、曼哈顿等)计算矩阵或数组之间的距离，并涵盖以下主题。

Python 科学距离矩阵
Python 科学距离矩阵 Cdist
Python Scipy 距离矩阵 Pdist
Python 科学距离矩阵欧几里得
Python Scipy 距离矩阵城市街区
Python Scipy 距离矩阵聚类
Python Scipy 距离矩阵定向 Hausdorff
Python Scipy 距离矩阵余弦
Python 科学距离相关矩阵

另外，查看 Python SciPy 的最新教程: Python Scipy Stats Kurtosis

Python Scipy 距离矩阵
Python Scipy 距离矩阵 Cdist
Python 科学距离矩阵 Pdist
Python Scipy 距离矩阵欧几里德
Python Scipy 距离矩阵 Cityblock
Python Scipy 距离矩阵聚类
Python Scipy 距离矩阵定向 Hausdorff
Python Scipy 距离矩阵余弦
Python Scipy 距离相关矩阵

Python Scipy 距离矩阵

成对计算的矩阵向量之间的距离包含在距离矩阵中。我们可以使用由*scipy.spatial*模块提供的*distance_matrix()*方法来计算距离矩阵。在大多数情况下，矩阵具有二维数组的形状，矩阵行充当矩阵的向量(一维数组)。

下面给出了语法。

scipy.spatial.distance_matrix(x, y, threshold=1000000, p=2)

其中参数为:

x(array_data(m，k): 有 M 个向量的 K 维矩阵。
y(array_data(n，k)): N 乘向量的 K 维矩阵。
threshold(positive int): 如果 M * N * K 大于阈值，则该算法使用 Python 循环而不是大型临时数组。
p(float): 应该应用哪个闵可夫斯基 p 范数。

方法*distance_matrix()*返回一个矩阵，该矩阵测量 x 中的每个向量和 y 中的每个 ndarray 类型的向量之间的间距。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy import spatial
import numpy as np

使用下面的代码创建矩阵。

x_mat = np.array([[2,3],[1,2],[3,3]])
y_mat = np.array([[1,2],[2,0],[5,0]])

使用下面的代码计算距离矩阵。

d_matrix = spatial.distance_matrix(x_mat,y_mat,p=2)

使用下面的代码查看距离矩阵。

print(d_matrix)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix

这就是如何使用模块 Python *scipy.spatial*的方法*distance_matrix()*计算距离矩阵。

也可阅读: Python Scipy 指数

Python Scipy 距离矩阵 Cdist

Python Scipy 在模块*scipy.spatial.distance*中包含了一个方法*cdist()*，该方法计算两个输入集合之间的距离。

下面给出了语法。

scipy.spatial.distance.cdist(XA, XB, metric='cosine')

其中参数为:

**XA(array _ data)😗*n 维中的原始 m [B] 观察值的数组，每个测量 m [B] 乘 n
**XB(array _ data)😗*n 维中的原始 m [B] 观察值的数组，每个测量 m [B] 乘 n
metric(callabel，str): 要应用的距离单位。距离函数可以是"堪培拉"、“布雷柯蒂斯”、“切比雪夫”、“相关”、“城市街区”、“余弦”、“欧几里得”、“骰子”、“汉明”、“库尔辛斯基”、“简森山农”、“库尔辛斯基”、“匹配”、“马哈拉诺比斯”、“明科夫斯基”、“罗素劳”、“罗格斯坦本”、“修克列迪安”。

方法 cdist() 返回的结果是大小为 m [A] 乘 m [B] 的距离矩阵。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.spatial.distance import cdist

使用下面的代码创建数据。

coord_data = [(25.056, -75.7226),
          (25.7411, -79.1197),
          (25.2897, -79.2294),
          (25.6716, -79.3378)]

在四个二维坐标之间，计算它们的欧几里得距离。

cdist(coord_data,coord_data,'euclidean')

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Cdist

这就是如何使用 Python Scipy 的方法*cdist()*来计算两个输入集合的每一对之间的距离。

阅读: Python Scipy 卡方测试

Python 科学距离矩阵 Pdist

Python Scipy 在模块*scipy.spatial.distance*中包含一个方法*pdist()*,用于计算 n 维空间中观测值之间的成对距离。

下面给出了语法。

scipy.spatial.distance.pdist(X, metric='minkowski)

其中参数为:

**X(array _ data)😗*n 维中 m 个唯一观测值的数组，m 乘 n 排列。
metric(callabel，str): 要应用的距离单位。距离函数可以是"堪培拉"、“布雷柯蒂斯”、“切比雪夫”、“相关”、“城市街区”、“余弦”、“欧几里得”、“骰子”、“汉明”、“库尔辛斯基”、“简森山农”、“库尔辛斯基”、“匹配”、“马哈拉诺比斯”、“明科夫斯基”、“罗素劳”、“罗格斯坦本”、“修克列迪安”。

方法pdist()返回 ndarray 类型的 Y(这是压缩的距离矩阵 Y) 。

让我们按照以下步骤，通过插图来理解:

使用下面的 python 代码导入所需的库。

from scipy.spatial.distance import pdist

使用下面的代码创建数据。

data = [(25.056, -75.7226),
          (25.7411, -79.1197),
          (25.2897, -79.2294),
          (25.6716, -79.3378)]

使用欧几里德距离(2-范数)作为点之间的距离度量来计算 m 点之间的距离。在矩阵数据中，点被排列成 m 个 n 维行向量。

pdist(data,'euclidean')

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

该指南使用 Python Scipy 的*pdist()*计算 n 维空间中观测值之间的成对距离

阅读: Scipy 寻找峰值–有用教程

Python Scipy 距离矩阵欧几里德

Python Scipy 在模块*scipy.spatial.distance*中包含了一个方法*euclidean()*，用于计算两个一维数组之间的欧几里德距离。

下面给出了语法。

scipy.spatial.distance.euclidean(u, v, w=None)

其中参数为:

u(array_data): 输入矩阵或数组。
v(array_data): 输入矩阵或数组。
w(array_data): 每个值在 u 和 v 中的权重，当默认选择无时，每个值的权重为 1。

方法*euclidean()*返回 double 类型的 euclidean(这是两个向量 u 和 v 的欧几里德距离) 。

让我们按照下面的步骤做一些例子:

导入方法*euclidean()*并使用下面的 python 代码计算距离。

from scipy.spatial.distance import euclidean
euclidean([2, 1, 0], [1, 1, 2])

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Euclidean

看上面的输出，给定数组的欧氏距离是 2.236。

这就是如何使用 Python Scipy 的方法*euclidean()*计算欧几里德距离。

阅读: Python Scipy 特辑

Python Scipy 距离矩阵 Cityblock

Python Scipy 模块*scipy.spatial.distance*包含一个计算曼哈顿距离(也称为城市街区距离)的方法*cityblock()*。

下面给出了语法。

scipy.spatial.distance.cityblock(u, v, w=None)

其中参数为:

u(array_data): 输入矩阵或数组。
v(array_data): 输入矩阵或数组。
w(array_data): 每个值在 u 和 v 中的权重，默认选择无时，每个值的权重为 1。

方法*cityblokc()*返回 double 类型的 (这是两个向量 u 和 v 的曼哈顿(cityblock)距离) 。

让我们按照下面的步骤做一些例子:

导入方法*cityblok()*并使用下面的 python 代码计算曼哈顿的距离。

from scipy.spatial.distance import cityblock
cityblock([1, 0, 2], [2, 1, 2])

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Cityblock

看看上面的输出，给定数组的 cityblock(曼哈顿)距离是 2。

这就是如何使用 Python Scipy 的方法*cityblock()*计算城市街区距离。

阅读: Python Scipy Matrix +示例

Python Scipy 距离矩阵聚类

Python Scipy 模块*scipy.spatial.hierarchy*包含一个方法*linkage()*,该方法使用分层或凝聚方法对数据进行聚类。但是 “什么是层次聚类？”

一种称为分层聚类的算法，通常被称为分层聚类分析，根据对象的相似程度将对象划分为多个聚类。结果是一个集群的集合，每个集群都不同于其他集群，但都有大体相似的东西。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Clustering

下面给出了语法。

scipy.cluster.hierarchy.linkage(y, method='complete', optimal_ordering=False, metric='euclidean')

其中参数为:

y(ndarray): 一个压缩的距离矩阵。距离矩阵的上部三角形包含在称为压缩距离矩阵的平面阵列中。Pdist 返回这个表单作为结果。一个 m 乘 n 的数组也可以用来传递一组 n 维的 m 个观察向量。在压缩距离矩阵中不能有任何 nan 或 INF，所有元素必须是有限的。
方法(str，function): 要使用的适当的联动算法。
**optimal _ ordering(boolean)😗*如果为真，连接矩阵将被重新排列，以使后续叶之间的距离尽可能短。当数据被可视化时，这导致了更容易理解的树结构。默认为 False，因为该算法可能会降低性能，尤其是对于大型数据集。
度量(str): 如果 y 是观测向量的集合，那么使用这个距离度量；否则，忽略它。有关可接受的距离测量列表，请参考 pdist 功能。此外，还提供自定义距离功能。

方法 linkage() 返回 ndarray 类型的 z(链接矩阵用于对层次分组进行编码) 。

使用下面的 python 代码导入所需的库。

from scipy.cluster.hierarchy import linkage, dendrogram
import matplotlib.pyplot as plt

使用下面的代码创建我们想要执行聚类的数据。

data = [[i] for i in [1, 7, 1, 5, 2, 8, 8, 1]]

将上面创建的数据传递给带有 ward 的方法*linkage()*,使用下面的代码计算聚类。

res = linkage(data, 'ward')

使用下面的代码绘制上述结果的树状图。

fig = plt.figure(figsize=(5, 5))
dendo = dendrogram(res)

在上面的代码中，我们已经将方法***linkage(data,'ward')***的结果传递给方法*dendrogram(res)*来显示获得聚类的树状图。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Clustering

这就是如何使用 Python Scipy 的方法*linkage()*计算距离矩阵聚类。

阅读:Scipy Stats Zscore+Examples

Python Scipy 距离矩阵定向 Hausdorff

Python Scipy 模块*scipy.spatial.distance*包含一个方法*directed_hausdorff()*,用于查找两个二维数组之间的有向 hausdorff 距离。

下面给出了语法。

scipy.spatial.distance.directed_hausdorff(u, v, seed=2)

其中参数为:

u(array_data，(M，N)): 输入矩阵或数组。
v(array_data，(ON)): 输入矩阵或数组。
seed(int): 默认值 0 通过随机重新排列 u 和 v 的值来确保可重复性。

方法*directed_hausdorff()*分别返回 double、int 和 int 类型的 d(数组 u 和 v 的有向豪斯多夫距离) 、 index_1(构成豪斯多夫对的 u 中的点的索引) 和 index_2(构成豪斯多夫对的 v 中的点的索引) 。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.spatial import distance
import numpy as np

使用下面的代码创建两个二维数组。

u_arr = np.array([(2.0, 0.0),
              (0.0, 2.0),
              (-2.0, 0.0),
              (0.0, -2.0)])
v_arr = np.array([(1.0, 0.0),
              (0.0, 1.0),
              (-1.0, 0.0),
              (0.0, -2.0)])

使用下面的代码计算上面创建的数组的有向豪斯多夫距离。

distance.directed_hausdorff(u_arr, v_arr)[0]

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Directed Hausdorff

看看上面的输出，给定数组之间的有向 Hausdorff 距离是 1。

这就是如何使用 Python Scipy 的方法*directed_hausdorff()*计算有向 Hausdorff 距离。

阅读: Scipy 卷积-完整指南

Python Scipy 距离矩阵余弦

Python Scipy 模块*scipy.spatial.distance*包含一个方法*cosine()*,用于识别一维数组的余弦距离。

假设 u 和 v 的余弦距离为:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Cosine

下面给出了语法。

scipy.spatial.distance.cosine(u, v, w=None)

其中参数为:

u(array_data): 输入矩阵或数组。
v(array_data): 输入矩阵或数组。
w(array_data): 每个值在 u 和 v 中的权重，当默认选择无时，每个值的权重为 1。

方法*cosine()*返回 double 类型的 cosine(这是 u 和 v 彼此之间的余弦距离) 。

让我们以下面的步骤为例:

导入方法*cosine()*并使用下面的 python 代码计算距离。

from scipy.spatial.distance import cosine
cosine([0, 1, 1], [1, 0, 1])

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Matrix Cosine

看上面的输出，给定数组的余弦距离是 0.5。

这就是如何使用 Python Scipy 的方法*cosine()*计算余弦距离。

阅读: Scipy Integrate +示例

Python Scipy 距离相关矩阵

Python Scipy 在模块*scipy.spatial.distance*中有一个方法*correlation()*,用于识别两个一维数组中间的相关距离。

假设 u 和 v 的相关距离为:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Correlation Matrix

下面给出了语法。

scipy.spatial.distance.correlation(u, v, w, centered = False)

u(array_data): 输入矩阵或数组。
v(array_data): 输入矩阵或数组。
w(array_data): 每个值在 u 和 v 中的权重，当默认选择无时，每个值的权重为 1。
**居中(布尔)😗*如果准确，u 和 v 会在中间。默认情况下为 True。

方法*correlation()*返回 double 类型的*correlation*(这是一维数组 u 和 v 在相关性方面的分离)。

让我们以下面的步骤为例:

导入方法*correlation()*并使用下面的 python 代码计算距离。

from scipy.spatial.distance import correlation
correlation([0, 1, 1], [1, 0, 1])

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Python Scipy Distance Correlation Matrix

看上面的输出，给定数组的相关距离是 1.5。

这就是如何使用 Python Scipy 的方法*correlation()*计算相关距离。

您可能也喜欢阅读下面的 Python Scipy 教程。

因此，在本教程中，我们已经了解了“Python Scipy 距离矩阵”并涵盖了以下主题。

Python 科学距离矩阵
Python 科学距离矩阵 Cdist
Python Scipy 距离矩阵 Pdist
Python 科学距离矩阵欧几里得
Python Scipy 距离矩阵城市街区
Python Scipy 距离矩阵聚类
Python Scipy 距离矩阵定向 Hausdorff
Python Scipy 距离矩阵余弦
Python 科学距离相关矩阵

Scipy 查找峰值–有用的教程

原文：https://pythonguides.com/scipy-find-peaks/

在这个 Python 教程中，我们将学习“ Scipy Find Peaks ”并借助各种例子讨论它的可用性。此外，涵盖以下主题。

科学发现峰值
科学发现了突出的顶峰
Scipy 查找峰值 cwt
科学发现高峰和低谷
科学发现峰值最小值
Scipy 发现峰宽

另外，查看最新的 Python Scipy 教程: Python Scipy 曲线拟合

科学发现高峰
科学发现山峰突起
Scipy 查找峰值 cwt
Scipy 发现峰宽
科学发现高峰和低谷
科学发现峰值最小值

科学发现高峰

Python Scipy 在模块*scipy.signal*中有一个方法*find_peaks()*，它根据给定的峰值属性返回所有的峰值。峰值不仅仅是电信号的峰值，数学函数中的最大值和最小值也被认为是峰值。

下面给出了语法。

scipy.signal.find_peaks(x, height=1, prominence=4,  distance=2, width=2, threshold=1, rel_height=0.5, wlen=1, )

其中参数为:

x(序列): 用于接受需要寻找峰值的信号。
height (sequence，ndarray，number): 可能是一个整数，也可能是一个数组，用来设置待识别峰的最小高度。
threshold(sequence，ndarray，number): 一个峰值和它的邻居之间所需的垂直距离被称为阈值，当我们不想从噪声中挑出峰值时，它在噪声函数的情况下是非常有益的。
距离(数): 是相邻山峰之间所需的最小水平距离(数)。在峰值周期已知的情况下，这是非常有价值的。
日珥(sequence，ndarray，number): 用于提供峰值日珥。
宽度(sequence，ndarray，number): 用于提供峰值的宽度。
wlen(int): 它用于计算日珥峰值。
rel_height(int): 用于计算峰高。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.signal import find_peaks
from scipy.misc import electrocardiogram
import matplotlib.pyplot as plt
%matplotlib inline

使用以下代码生成心电图。

value = electrocardiogram()[1000:5000]

现在使用下面的代码。

peak, _ = find_peaks(value, height=0)
plt.plot(value)
plt.plot(peak, value[peak], "*")
plt.plot(np.zeros_like(value), "--", color="green")
plt.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Find Peaks

这就是如何使用 Python SciPy 的方法*find_peaks()*找到信号的峰值。

科学发现山峰突起

Python SciPy 有一个方法*peak_prominence()*,该方法计算峰值与其最低轮廓线之间的垂直距离，并与信号的周围基线进行比较。

下面给出了语法。

scipy.signal.peak_prominences(x, wlen=None, peaks)

其中参数为:

x(序列): 用于接受需要寻找峰值的信号。
wlen(int): 它用于指定采样窗口长度。
***峰值(序列)😗**x 中的峰值指数

方法*peak_prominence()*返回 ndarray 类型的*prominences*(每个峰值)和 left-right bases 。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
%matplotlib inline

使用下面的代码生成一个信号。

array_data = np.linspace(0, 5 * np.pi, 1100)
sig = np.sin(array_data) + 0.5 * np.sin(1.7 * array_data)

使用以下代码确定所有峰的显著性。

sig_peaks, _ = signal.find_peaks(sig)
promin = signal.peak_prominences(sig, sig_peaks)[0]
promin

现在使用下面的代码计算并绘制每个峰的轮廓线的高度。

contur_height = sig[sig_peaks] - promin
plt.plot(sig)
plt.plot(sig_peaks, sig[sig_peaks], "*")
plt.vlines(x=sig_peaks, ymin=contur_height, ymax=sig[sig_peaks])
plt.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Find Peaks Prominence

这就是如何使用 Python SciPy 的方法*peak_prominences()*找到峰的日珥。

阅读:Scipy Sparse–有用的教程

Scipy 查找峰值 cwt

Python SciPy 有一个方法*find_peaks_cwt()*，它使用*Wavelet transformation*在一维数组中寻找峰值。但是 “什么是小波变换？” 使用一对滤波器将 N 个样本的信号分解成低频带和高频带。每个频带都是两倍欠采样，每个频带有 N/2 个样本。

下面给出了语法。

scipy.signal.find_peaks_cwt(vector, wavelet=None, widths, max_distances=None, window_size=None, gap_thresh=None, min_snr=0, min_length=None, noise_perc=9)

其中参数为:

vector(ndarray): 在一维数组中寻找波峰。
小波(可调用): 取两个参数后，必须返回一个一维数组与向量进行卷积。第一个参数指定输出小波数组中的点数，而第二个参数指定小波的尺度。
widths(): 要计算 CWT 矩阵，请使用单一宽度或一维宽度数组。
最大距离(ndarray): 仅当第[n]行的相对最大值在第[n+1]行的相对最大值的最大距离[n]内时，脊线在每一行都是连通的。
***window _ size(int)😗**要计算噪底，指定窗口的大小。
***gap _ thresh(float)😗**如果在最大距离内没有找到相对最大值，就会有间隙。如果超过 gap_thresh 点而没有新的相对最大值，脊线终止。
min_snr(浮点): 最小信噪比。
min_length(int): 一条脊线的最小长度必须是可接受的。
***noise _ PERC(float)😗**本底噪声是使用低于其噪声被考虑的数据点的百分比来计算的。

方法*find_peaks_cwt()*返回 te peak_indices 。

让我们通过下面的步骤来了解一个示例:

使用下面的 python 代码导入所需的库。

from scipy.signal import find_peaks_cwt
import numpy as np

使用下面的代码，使用方法*np.sin()*生成数组元素并在该数组上应用函数 sin。

x_data = np.arange(0, np.pi, 0.06)
sin_data = np.sin(x_data)

使用以下代码计算峰值指数或峰值。

peak_indices = signal.find_peaks_cwt(sin_data, np.arange(2,11))
peak_indices, x_data[peak_indices], sin_data[peak_indices]

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Find Peaks cwt

这就是如何使用 Python SciPy 的方法*find_peaks_cwt*找到峰值。

Scipy 发现峰宽

Python SciPy 有一个方法*peak_widths()*可以确定每个信号峰值的宽度。

下面给出了语法。

scipy.signal.peak_widths(x, rel_height=0.3, peaks, wlen=None, prominence_data=None)

其中参数为:

x(序列): 它用来接受信号。
wlen(int): 它用于指定采样窗口长度。
***峰值(序列)😗**x 中的峰值指数
***rel _ height(float)😗**选择峰宽的相对高度，以其突出度的百分比表示。峰的宽度在其最低轮廓线处计算为 1.0，日珥高度的一半计算为 0.5。
***prominence _ data(tuple)😗**当用相同的参数 x 和 peaks 调用时，一个 3 数组的元组匹配 peak prominences 的结果。

方法*peak_widths()*返回 widths(样品峰宽) ， widths_height(用于计算宽度的轮廓线的高度。)**``right_ips, left_ips(各评价高度的水平线左右交点的插补位置) 。

让我们按照以下步骤来看一个例子:

使用下面的 python 代码导入所需的库。

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
%matplotlib inline

使用下面的代码生成一个信号。

array_data = np.linspace(0, 5 * np.pi, 1100)
sig = np.sin(array_data) + 0.5 * np.sin(1.7 * array_data)

使用以下代码确定所有峰的宽度。

sig_peaks, _ = signal.find_peaks(sig)
promin = signal.peak_prominences(sig, sig_peaks)[0]
promin

使用以下代码绘制信号、峰值和等高线的宽度。

plt.plot(sig)
plt.plot(sig_peaks, sig[sig_peaks], "*")
plt.hlines(*half_peak_res[1:], color="C4")
plt.hlines(*full_peak_res[1:], color="C5")
plt.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Finds Peak Width

这就是如何使用 Python SciPy 的方法*peak_widths()*计算峰宽。

阅读:Python Scipy FFT【11 个有用的例子】

科学发现高峰和低谷

在 Python SciPy 中，没有内置的方法来查找信号的波峰和波谷，这里我们将使用模块scipy.signal中的方法*argrelextrema()*手动执行这项任务。

要找到信号流的波峰和波谷，请执行以下步骤:

使用下面的 python 代码导入所需的库。

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')
from scipy.signal import argrelextrema
%matplotlib inline

使用下面的代码生成数据。

x_data = np.arange(start = 0, stop = 30, step = 1, dtype='int')
y_data = np.random.random(30)*5

使用下面的代码计算峰值。

peaks_ind = argrelextrema(y_data, np.greater)
peaks_ind = peaks_ind[0]

使用下面的代码计算山谷。

valleys_ind = argrelextrema(y_data, np.less)
valleys_ind = valleys_ind[0]

用我们使用下面的代码生成的峰值和谷值数据绘制图表。

(fig, ax) = plt.subplots()
ax.plot(x_data, y_data)

x_peak = peaks_ind
y_peak = y_data[peaks_ind]
ax.plot(x_peak, y_peak, marker='*', linestyle='dashed', color='orange', label="peaks")

x_valley = valleys_ind
y_valley = y_data[valleys_ind]
ax.plot(x_valley, y_valley, marker='*', linestyle='dashed', color='blue', label="Valleys")

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Find Peaks and Valleys

这就是如何在 Python SciPy 中找到信号的波峰和波谷。

阅读:Scipy Linalg–实用指南

科学发现峰值最小值

我们已经学习了如何使用 Python Scipy 库的方法*find_peaks()*找到信号的峰值或最大值。但在这一部分，我们将找到给定信号的最小值或谷值。

要找到信号或给定数据的最小值，请遵循以下步骤:

使用下面的 python 代码导入所需的库。

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')
from scipy.signal import argrelextrema

按照下面的代码，使用随机数据创建一个信号。

array_data = np.arange(start = 0, stop = 40, step = 1, dtype='int')
y_array_data = np.random.random(40)*5

使用下面的代码计算信号的最小值。

minima_ind = argrelextrema(y_array_data, np.less)
minima_ind = minima_ind[0]
minima_ind

用下面的代码在图上标出计算出的最小值。

(fig, ax) = plt.subplots()
ax.plot(array_data, y_array_data)

x_minima = minima_ind
y_minima = y_array_data[minima_ind]
ax.plot(x_minima, y_minima, marker='*', linestyle='dashed', color='green', label="Minima")

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Find Peaks Minima

这就是如何使用 Python SciPy 的方法*argrelextrema()*找到信号或数据的最小值。

另外，看看更多的 Python Scipy 教程。

因此，在本教程中，我们学习了“ Scipy Find Peaks ”并涵盖了以下主题。

科学发现峰值
科学发现了突出的顶峰
Scipy 查找峰值 cwt
科学发现高峰和低谷
科学发现峰值最小值
Scipy 发现峰宽

Scipy Integrate +示例

原文：https://pythonguides.com/scipy-integrate/

在这个 Python 教程中，我们将学习“ Scipy Integrate ”，在这里我们将学习如何使用集成方法来解决集成问题。此外，我们还将讨论以下主题。

Scipy 集成
科学整合辛普森
立体整体梯形
Scipy 集成四路
Scipy 集成 Odeint
Scipy 集成求解 _Ivp
积体积体芯片

科学整合
Scipy integrated trap zoid
科学整合辛普森
Scipy 集成四通道
Scipy Integrate Odeint
Scipy Integrate Solve_Ivp
Scipy 积分累计

科学整合

Scipy 子模块*scipy.integrate*包含了许多解决 Python 中积分或微分方程相关问题的方法。它有一个预定义的函数和方法来解决积分或微分方程数学问题。

要了解这个子模块中可用的集成技术，请使用下面的代码。

from scipy import integrate
print(help(integrate))

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy integrate

在上面的输出中，当我们滚动浏览时，它显示了本模块中所有的积分或微分技术、方法和函数。

阅读:科学统计-完整指南

Scipy integrated trap zoid

*TrapeZoid*规则是一种积分技术，通过将总面积分成一个更小的梯形来计算曲线下的面积。它基于指定的轴集成给定的函数*y(x)*。

下面给出了在 Python 中使用它的语法。

scipy.integrate.trapezoid(y, x=None, dx=1.0, axis=- 1)

其中参数为:

y(array_data): 表示我们要积分作为输入的数组。
x(array_data): 用于指定与 y 值相关的采样点。
dx(标量): 用于指定不使用*x*时采样点之间的间距。
轴(int): 它定义了我们要在哪个轴上执行积分。

方法*trapezoid()*返回 float 类型的值*trapz*，该值是近似的整数值。

让我们以 Python 中的以下步骤为例:

导入所需的库。

from scipy.integrate import trapezoid

创建代表*y*数据的数组值，并将其传递给方法。

trapezoid([5,8,10])

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Integrate Trapzoid

通过应用梯形法则，输出显示积分值*15.5* 。

科学整合辛普森

Scipy 有一个计算积分近似值的方法*simpson()*。此方法存在于子模块*scipy.integrate*中。

下面给出了在 Python 中使用它的语法。

scipy.integrate.simpson(y, x=None, dx=1.0, axis=- 1, even='avg')

其中参数为:

y(array_data): 表示我们要积分作为输入的数组。
x(array_data): 用于指定与 y 值相关的采样点。
dx(标量): 用于指定不使用*x*时采样点之间的间距。
轴(int): 它定义了我们要在哪个轴上执行积分。
偶数(字符串): 用于指定两个结果平均值的梯形法则，第一个和最后一个区间。

让我们以下面的步骤为例:

导入所需的模块，如以下代码所示。

import numpy as np
from scipy.integrate import simpson

使用下面的代码创建一个数据和样本点的数组。

array_data = np.arange(5,15)
sample_pnt = np.arange(5,15)

使用下面的 Python 代码，通过方法*simpson()*计算积分。

simpson(array_data,sample_pnt)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Integrate Simpson

输出显示数组的积分值，给定的采样点为85.5T3。

阅读: Scipy 旋转图像+示例

Scipy 集成四通道

Scipy 在子模块*scipy.integrate*中有一个方法*quad()*，它计算 Python 中从无限区间 a 到 b 的给定函数的定积分。

下面给出了语法。

scipy.integrate.quad(func, a, b, args=(), full_output=0)

其中参数为:

func(函数): 用于指定用于积分计算的函数。该函数可以是下列形式之一。

双功能(双 y)
double func(double y，void *user_data)
double func(int m，double *yy)
double func(int m，double *yy，void *user_data)

(浮点): 用于指定积分的下限。
b(浮点): 用于指定积分的上限。
args(tuple): 如果我们想给一个函数传递额外的参数，那么就使用这个参数。
***full _ output(int)😗**非零值用于获取集成信息的字典。

该方法返回三个重要结果*y*整数值，*abserr*绝对误差的估计值，infodict包含附加信息的字典。

让我们以下面的步骤为例:

使用下面的 Python 代码导入所需的库。

from scipy.integrate import quad

使用 lambda 函数创建一个函数，并定义间隔，如下面的代码所示。

n3 = lambda n: n**3
a = 0
b = 5

现在使用下面的代码计算函数的积分。

quad(n3, a, b)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Integrate Quad

输出显示函数n³(n 的 3 次方)的定积分值为*156.25000*。

阅读:Scipy Sparse–有用的教程

Scipy Integrate Odeint

Scipy 子模块*scipy.integrate*包含了整合常微分方程的方法*odeint()*。

下面给出了在 Python 中使用它的语法。

scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, printmessg=0)

其中参数为:

func: 它计算函数 y 在 t 的导数
y0(数组): 用于为 y 提供初始条件
t(数组): 它是一系列时间点
args: 用来给函数 y 提供额外的参数
Dfun: 用于一个函数的梯度。
***col _ deriv(boolean)😗**对于真值*Dfun*定义导数向下到列，否则为假时跨越到行。
***print messg(boolean)😗**用于打印汇聚报文。

该函数包含许多参数，但上面我们只解释了常见的参数。

方法*odient()*返回两个值y,它们是包含每个时间 t 的 y 值的数组，以及用于附加输出信息的*infodict*。

让我们以下面的步骤为例:

导入所需的库。

from scipy.integrate import odeint
import matplotlib.pyplot as plt
import numpy as np

使用下面的代码定义等式。

def diff_model(y,t):
    k = 0.5
    dydt = -k * y
    return dydt

使用下面的代码创建一个初始条件。

y0 = 3

使用下面的代码创建一系列时间点。

t = np.linspace(0,15)

通过使用下面的代码提供参数来求解创建的方程。

y = odeint(diff_model,y0,t)

现在用下面的代码画出解决方案。

plt.plot(t,y)
plt.xlabel('time')
plt.ylabel('y(t)')
plt.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Integrate Odeint

这就是如何积分常微分方程。

阅读:科学常数

Scipy Integrate Solve_Ivp

Scipy 有一个方法*solve_ivp()*，它根据提供的初始值整合一个常微分方程系统。

下面给出了在 Python 中使用它的语法。

scipy.integrate.solve_ivp(fun, t_span, y0, method='BDF', t_eval=None, dense_output=False, events=None, vectorized=True, args=None)

其中参数为:

fun(可调用): 它在系统的右手边。调用函数的签名是 fun(x，z ),其中 x 表示标量，z 是以两种方式表示形状的数组。
t_span(二元组浮点): 表示从 T0 到 T1 积分的区间。
***y0(array _ data like shape(n))😗**用于指定初始状态。
方法(string 或 odsolver): 用于指定使用哪种积分方法，如 RK45、Radau、RK23、DOP853、BDF、LSODA。
***t _ eval(array _ data)😗**用于指定存储计算出的解的时间。
***dense _ output(boolean)😗**用于指定我们是否要计算连续解。
事件(可调用): 用于跟踪事件。
矢量化(布尔): 用于指定我们是否要以矢量化的方式实现函数。
args(tuple): 传递多余的参数。

该函数返回包含许多值的 bunch 对象，但它有两个重要的值，即 y 和 t。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.integrate import solve_ivp

使用下面的代码创建一个指数衰减函数。

def exp_decay(t, y): return -1.0 * y

现在使用下面的代码对指数衰减函数应用方法*solve_ivp()*。

solution = solve_ivp(exp_decay, [5, 15], [4, 6, 10])

检查存储在解决方案中的*t*值。

solution.t

检查存储在解决方案中的*y*值。

solution.y

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Integrate Solve_Ivp

这就是如何根据提供的初值积分一个常微分方程组。

Scipy 积分累计

*cumtrapez*该规则是一种积分技术，借助梯形规则对给定函数 y(x)进行累积积分。

下面给出了语法。

scipy.integrate.cumtrapz(y, x=None, dx=1.0, axis=- 1, intial=None)

其中参数为:

y(array_data): 表示我们要积分作为输入的数组。
x(array_data): 用于指定与 y 值相关的采样点。
dx(标量): 用于指定不使用*x*时采样点之间的间距。
轴(int): 它定义了我们要在哪个轴上执行积分。
初始值(标量): 用来给函数提供初始值。

方法*trapezoid()*返回 ndarray 类型的值*res*。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.integrate import cumtrapz
import numpy as np

使用下面的代码创建变量***【sample _ pts】***作为样本点，创建变量 y ³ 用于积分。

sample_pts = np.arange(5, 30)
y_func = np.power(sample_pts, 3)

使用下面的代码对函数使用方法*cumtrapz()*。

cumtrapz(y_func,sample_pts)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Integrate CumTrapz

这就是如何用方法*cumtrapz()*积分给定函数。

另外，看看更多的 SciPy 教程。

在本教程中，我们已经了解了" Scipy Integrate "并且我们还讨论了以下主题。

Scipy 集成
科学整合辛普森
立体整体梯形
Scipy 集成四路
Scipy 集成 Odeint
Scipy 集成求解 _Ivp
积体积体芯片

scipy Linalg–有用的指南

原文：https://pythonguides.com/scipy-linalg/

在这个 Python 教程中，我们将学习“ Scipy Linalg ”。在这里我们将学习如何解决线性代数问题。此外，我们还将讨论以下主题。

Scipy Linalg
Scipy Linalg(科学怪人)
西比·林格尔
Scipy Linalg Lu
Scipy Linalg Svd.
Scipy Linalg Solve
Scipy Linalg Qr
Scipy Linalg Inverse
Scipy Linalg Norm
西皮·里纳尔格·乔莱斯基

Scipy Linalg
西比林藻卵
草履虫八号】T1
Scipy Linalg Lu
Scipy Linalg Svd
Scipy Linalg Solve
Scipy Linalg Qr
Scipy Linalg inverse
Scipy Linalg Norm
斯皮·里纳尔格·乔莱斯基

Scipy Linalg

Python Scipy 中的*scipy.linalg*模块用于解决线性代数问题。我们可以使用这个库来解决方程、矩阵、特征值和特殊的矩阵问题等。

它有多种解决线性代数问题的方法。*linalg*库中的所有方法被分成以下几个部分:

特征值问题
矩阵函数
基础
分解
草图和随机投影
低级例程
矩阵方程求解器
特殊矩阵

在接下来的小节中，我们将学习模块*scipy.linalg*最常见的方法。

西比林藻卵

Python Scipy 在模块*scipy.linalg*中有一个方法*eig()*来处理常见的特征值问题。

下面给出了语法。

scipy.linalg.eig(a, b=None, right=False, left=True, overwrite_a=True, overwrite_b=True, check_finite=False, homogeneous_eigvals=True)

其中参数为:

a(array_data): 提供实矩阵或复矩阵作为计算特征向量和特征值的输入。
b(array_data): 输入右侧矩阵。
右(布尔): 计算并得到右特征向量。
左(布尔): 计算并得到左特征向量。
覆盖 _a(布尔): 覆盖*a*。
覆盖 _b(布尔): 覆盖*b*。
***check _ finite(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。
【齐次 _ 特征值(布尔): 获取齐次坐标中的特征值

方法*eig()*返回复数 ndarray 或 double 类型的 w(特征值) 、 vr(规范化的右向量) 和 vl(规范化的左向量)

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

import numpy as np
from scipy.linalg import eig

使用下面的代码创建一个矩阵形式的数据数组。

mat_data = np.array([[-1.,0],[0.2,1]])

使用以下代码将创建的矩阵数据传递给方法eig()。

eig(mat_data)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Eig

这就是如何使用 Python Scipy 的方法*eig()*计算特征值和特征向量。

阅读: Scipy 卷积器

草履虫八号】T1

Python Scipy 在模块*scipy.linalg*中有一个方法*eigh()*来处理实对称或厄米矩阵的标准普通特征值问题。

下面给出了语法。

scipy.linalg.eigh(a, b=None, eigvals_only=True, lower=False, overwrite_a=True, overwrite_b=True, turbo=False, eigvals=None, type=1, check_finite=False, subset_by_index=None, subset_by_value=None, driver=None)

其中参数为:

a(array_data): 提供实矩阵或复矩阵作为计算特征向量和特征值的输入。
b(array_data): 输入右侧矩阵。
lower(bool): 相关数组的数据是从 a 的下三角还是上三角中选取的
***egvals _ only(boolean)😗**只计算特征值，不计算特征向量。默认情况下，两者都是经过计算的。
覆盖 _a(布尔): 覆盖*a*。
覆盖 _b(布尔): 覆盖*b*。
***check _ finite(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。
***subset _ by _ index(iterable)😗**使用可迭代的二元定义开始和结束特征值索引。
***subset _ by _ value(iterable)😗**用一个可迭代的二元来定义半区间只求特征值。

方法*eigh()*以 ndarray 类型的递增大小返回 w(选定的特征值) 。

让我们按照下面的步骤举例:

使用下面的 python 代码导入所需的库。

import numpy as np
from scipy.linalg import eigh

使用下面的代码创建一个矩阵形式的数据数组。

matrix_data = np.array([[5, 3, 6, 1], [5, 1, 3, 0], [2, 6, 5, 1], [1, 5, 2, 2]])

使用以下代码将创建的矩阵数据传递给方法*eigh()*。

eigh(matrix_data)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Eigh

这就是如何使用 Python Scipy 的方法*eigh()*计算特征值。

阅读: Scipy Ndimage Rotate

Scipy Linalg Lu

Python Scipy 在模块*scipy.linalg*中有一个方法*lu()*来计算矩阵的旋转 Lu 分解。

下面给出了语法。

scipy.linalg.lu(a, permute_l=True, check_finite=False, overwrite_a=True,)

其中参数为:

a(数组 _ 数据): 对数组进行分解。
permute_l(布尔): 做乘法
覆盖 _a(布尔): 覆盖a。
***check _ finit(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。

方法返回 p(置换矩阵) ， l(下三角) ， ***u(上三角)*permute_l equal to false*， pl(置换 L 矩阵) ， ***u(上三角) **`permute_l equal to true`````

让我们通过下面的步骤来了解一个示例:

使用下面的 python 代码导入所需的库。

import numpy as np
from scipy.linalg import lu

使用下面的代码创建一个数据数组。

array_data = np.array([[8, 7, 2, 5], [2, 8, 5, 2], [6, 6, 5, 7], [4, 5, 8, 4]])

使用下面的代码将创建的数据数组传递给方法*lu()*。

permute_mat,lower_tri,upper_tri = lu(array_data)

print('Permutation matrix',permute_mat)
print('Lower triangular',lower_tri)
print('Upper triangular',upper_tri)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Lu

查看输出，结果是*Permutaton matrix*、*Lower triangular*和*Upper triangular*。

这就是如何使用*lu() for Lu decomposition of a* 矩阵的方法。

阅读: Scipy 正态分布

Scipy Linalg Svd

Python Scipy 在模块*scipy.linalg*中有一个方法*svd()*用于奇异分解值。

下面给出了语法。

scipy.linalg.svd(a, compute_uv=False, full_matrices=False, overwrite_a=True, check_finite=False, lapack_driver='gesdd')

其中参数为:

a(array_data): 是用于分解的矩阵。
compute_uv(布尔): 计算除 s 之外的 v 和 uh
full _ matrix(布尔): 对于真值，v 和 uh 的形状为(M，M) (N，N)，对于假值，形状为(M，K)和(K，N)。
覆盖 _a(布尔): 覆盖a。
***check _ finite(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。
lapack_driver(gesvd，gesdd): 使用更高效的通用矩形方法或分治方法。

方法*svd()*返回 ndarray 类型的 U(酉矩阵的左奇异向量) ， s(奇异值) 和 vh(酉矩阵的右奇异向量) 。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from numpy.random import default_rng
from scipy.linalg import svd

使用随机生成器 default_rng 通过下面的代码生成一个数据数组。

random_numgen = default_rng()
m, n = 12, 8
array_data = random_numgen.standard_normal((m, n)) + 1.j*random_numgen.standard_normal((m, n))

使用下面的代码对数据数组执行 svd。

U, s, Vh = svd(array_data)
print("left singular vectors of Unitary matrix",U.shape)
print("singular values",s)
print("right singular vectors of Unitary matrix",Vh.shape)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Svd

这就是如何使用方法*svd()*对数组进行奇异分解。

阅读: Scipy Stats Zscore

Scipy Linalg Solve

Python Scipy 在模块*scipy.linalg*中有一个方法*solve()*来处理与线性方程相关的问题，例如*ax = b*，这意味着这个方程是为方阵*a*的值*x*求解的。

下面给出了语法。

scipy.linalg.solve(a, b, overwrite_a=True, lower=True, debug=None, overwrite_b=True, sym_pos=True, assume_a='gen', check_finite=False, transposed=True)

其中参数为:

(array _ data):接受方形数据作为输入。
b(array_data):输入数据的右边。
lower(bool): 相关数组的数据是从 a 的下三角还是上三角中选取的
覆盖 _a(布尔): 覆盖 a
覆盖 _b(布尔): 覆盖*b*。
****check _ finite(boolean)😗*检查提供的作为输入的矩阵是否有有限个数字。
****sym _ post(boolean)😗*而不是*sym_pos*使用参数*assume_a = pos*，因为*sym_pos*已经折旧。该参数认为参数*a*提供的值是非对称正定的。
它应该包含什么 值在上面的参数中有解释。
转置(布尔): 如果为真，则a转置，如*a*T x = b*。

*方法solve返回 ndarray 类型的 x(这是一个解数组) 和发生的错误。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.linalg import solve
import numpy as np

给定 x 和 y 的值，找出 z 的值，首先，使用下面的代码创建 x 和 y 的数据数组。

x = np.array([[4, 3, 0], [2, -2, 0], [1, 0, 5]])
y = np.array([1, 3, -4])

使用下面的代码求解 z 的 x 和 y。

solve(x,y)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Solve

这就是如何用*solve()*的方法解决线性方程问题。

读取:敏感信号

Scipy Linalg Qr

我们将讨论矩阵的 QR 分解或 QR 分解。QR 分解是矩阵的分解，例如“A”分解成“A=QR”，其中 R 是上三角矩阵，Q 是正交的。我们用 Python SciPy 方法*scipy.linalg.qr()*函数分解矩阵。

下面给出了语法。

scipy.linalg.qr(a, overwrite_a=True, lwork=None, mode='full', pivoting=True, check_finite=False)

其中参数为:

a(array_data): 输入我们要分解的矩阵。
覆盖 _a(布尔): 覆盖a。
***check _ finite(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。
lwork(int): 工作数组的大小，lwork >= a.shape[1]。如果未指定或指定了-1，则确定最佳大小。
模式: 确定将同时返回 Q 和 R ('full '，这是默认值)，仅返回 R ('r ')，或者同时返回 Q 和 R，但按经济规模计算。
旋转(布尔): 旋转是否应该包含在因子分解中以进行等级揭示 qr 分解。如果旋转，如上所述进行分解*A P = Q R*，但是选择 P，使得 R 的对角线不增加。

该方法返回 ndarray 或 float 或 int 类型的 Q(其形状为 M，M) ，R(M，N 的形状) 和***P(N 的形状)*** 。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

import numpy as np
from scipy.linalg import qr

创建一个随机数生成器的对象，并使用下面的代码从正态分布中生成一个样本。

random_gen = np.random.default_rng()
data = random_gen.standard_normal((7, 5))
data

对数据执行qr并使用以下代码检查形状。

shape_q, shape_r = qr(data)
print('Shape of q',shape_q.shape)
print('Shape of r',shape_r.shape)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Qr

这就是如何使用 Python Scipy 的方法*qr()*进行 QR 分解。

Scipy Linalg inverse

Python SciPy 在模块*sicpy.linalg*中包含一个方法*inv()*,用于确定矩阵的逆矩阵。

下面给出了语法。

scipy.linalg.inv(a, overwrite_a=True, check_finite=False)

其中参数为:

a(array_data): 输入我们要求逆的矩阵。
覆盖 _a(布尔): 覆盖a。
***check _ finite(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。

方法*inv()*返回 inv(矩阵的逆) 。

让我们以下面的步骤为例:

使用下面的代码导入所需的库。

from scipy.linalg import inv
import numpy as np

创建一个矩阵，并用下面的代码求逆。

mat = np.array([[2., 1.], [4., 3.]])
inv(mat)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Inverse

这就是如何使用 Python SciPy 的方法*inv()*对给定矩阵求逆。

阅读:Scipy Sparse–有用的教程

Scipy Linalg Norm

Python SciPy 有一个从 8 种不同形式返回矩阵范数的方法norm()。

下面给出了语法。

scipy.linalg.norm(a, axis=None, ord=None, check_finite=True,  keepdims=True)

其中参数为:

a(array_data): 输入的数组除非 ord 为 None，否则 axis 必须为 None，a 必须为 1 维或 2 维，如果 axis 和 ord 都为 None，则返回 a.ravel 2-norm。
轴(2 元组的 int，int): 如果轴是整数，则指定要计算向量范数的轴。如果轴是二元组，则指定保存二维矩阵的轴，并计算这些矩阵的矩阵范数。
ord(int，inf): 用于提供定额订单。
***check _ finite(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。
keepdims(布尔): 如果设置为真，则被赋范的轴作为尺寸为 1 的尺寸留在结果中。

方法*norm()*返回给定矩阵的范数。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.linalg import norm
import numpy as np

创建一个矩阵形式的数据数组，将使用下面的代码计算其范数。

array_data = np.arange(8) - 3.0
array_data

使用下面的代码计算上面创建的矩阵或数据数组的范数。

norm(array_data)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Norm

这就是如何使用 Python SciPy 的方法*norm()*计算给定矩阵的范数。

斯皮·里纳尔格·乔莱斯基

Python SciPy 有一个方法*cholesky()*，它返回埃尔米特正定矩阵 A 的乔莱斯基分解*A=LL or A=UU*。

下面给出了语法。

scipy.linalg.cholesky(a, lower=True, overwrite_a=True, check_finite=False)

其中参数为:

a(数组 _ 数据): 对数组进行分解。
**lower(bool):**相关数组的数据是从 a 的下三角还是上三角中选取的
覆盖 _a(布尔): 覆盖a。
***check _ finite(boolean)😗**检查提供的作为输入的矩阵是否有有限个数字。

方法*cholesky()*返回 ndarray 类型的c(上三角形或下三角形的 Cholesky 因子)。

让我们以下面的步骤为例:

使用下面的 python 代码导入所需的库。

from scipy.linalg import cholesky
import numpy as np

使用下面的代码创建一个矩阵。

m = np.array([[2,-1j],[2j,2]])

使用下面的代码计算矩阵的 Cholesky。

cholesky(m,lower = True)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Linalg Cholesky

这是如何使用 Python SciPy 的方法*cholesky()*计算给定矩阵的 Cholesky。

另外，看看更多的 Scipy 教程。

因此，在本教程中，我们已经了解了" Scipy Linalg "并涵盖了以下主题。

Scipy Linalg
Scipy Linalg(科学怪人)
scipy linalg 号文件。
Scipy Linalg Lu
Scipy Linalg Svd.
Scipy Linalg Solve
Scipy Linalg Qr
Scipy Linalg Inverse
Scipy Linalg Norm
西皮·里纳尔格·乔莱斯基

enjoysharepoint.com/*

Scipy 杂项+示例

原文：https://pythonguides.com/scipy-misc/

在这个 Python 教程中，我们将学习“ Scipy Misc 并讨论与之相关的多个例子。此外，我们将讨论以下主题。

Scipy Misc
Scipy 杂项信息
Scipy Misc imsave
Scipy Misc toimage
Scipy 杂项衍生物
Scipy Misc imresize
Scipy 杂项梳
Scipy 杂项上升
Scipy 杂项脸
Scipy 杂项因子

Scipy Misc
科学杂项信息
Scipy Misc imsave
Scipy Misc toimage
科学杂项导数
Scipy Misc imresize
Scipy 杂项梳
科学杂项上升
Scipy Misc face
科学杂项阶乘

Scipy Misc

在 Scipy 中有一个模块*scipy.misc*也就是*Miscellaneous routines*，它有不同的不属于任何特定模块的实用程序或方法。

它有五种不同用途的五种方法，如下所示。

***【central _ diff _ weights()😗**求给定中心导数的 Np-点的权重。
face(): 返回浣熊脸，大小为 1024 x 768。
ascent(): 它返回大小为 512 x 512 的 8 位灰度位深度，这是用于演示目的的派生图像。
【心电图(): 用于加载心电图作为一维信号。
导数(): 返回给定函数在某一点的第 n 阶导数。

在本教程的后面，我们将分别学习上述方法。

另外，检查:科学常数

科学杂项信息

Scipy 版本 1.2.0 中删除了用于从文件中读取图像的 Scipy 方法*imread()*。该方法存在于另一个名为*imageio*的库中。所以在这里我们将安装这个库并读取一个图像。

下面给出了语法。

imageio.imread(file_path)

其中*file_path*是我们想要读取的图像的路径。

打开一个新的 Jupiter 笔记本或使用 cmd 在计算机上安装库，如下所示步骤:

!pip install imageio

使用下面的代码导入库。

import imageio
import matplotlib.pyplot as plt
%matplotlib inline

使用imread()方法读取图像。

image = imageio.imread('keith_tanner.jpg')

上面的代码包含从指定路径读取图像并返回该图像的 ndarray 的方法*imread()*。

现在使用下面的代码，使用子模块*matplotlib.pyplot*的方法*imshow()*查看图像。

plt.figure(figsize=(5,5))
plt.imshow(image) 
plt.axis('off')
plt.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc imread

这是如何使用方法imread读取图像。

阅读: Scipy 优化

Scipy Misc imsave

用于将图像从数组保存到文件的 Scipy 方法*imsave()*已从 Scipy 版本 1.2.0 中删除。存在于另一个库*imageio*中的方法imwrite()被用来代替那个方法。

下面给出了语法。

imageio.imwrite(uri,array_data,format)

其中参数为:

uri(string): 是我们要保存的文件的名称。
array_data: 它是一幅图像的数组值。
格式(字符串): 用于指定我们要读取的图像的格式。

让我们以下面的步骤为例:

使用下面的代码导入所需的库。

import numpy as np
import imageio

使用元组创建行和列，如下面的代码所示。

row, col = (10,10)

使用定义的行和列创建数组。

array_data = np.zeros((row,col))

使用下面的代码创建一个图像。

 image = imageio.imwrite('creating_img.png',array_data)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc imsave

上面的代码用零值创建了 64 字节的图像。

阅读: Scipy 稀疏

Scipy Misc toimage

Scipy 版本 1.2.0 中删除了用于从数组创建映像的 Scipy 方法*toread()*。存在于另一个库*PIL*中的方法*PIL.mage.fromarray()*被用来代替那个方法。

下面给出了语法。

image.fromarray(obj)

其中参数为:

obj: 它是一个包含图像值的数组。

让我们通过一个使用以下步骤的示例来理解:

首先，安装库PIL因为这里我们要在 Jupyter 笔记本中安装库。

!pip install Pillow

使用下面的代码导入所需的库。

from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

打开任何图像并将其转换为数组。

img = Image.open("severin_candrian.jpg")
array = np.array(img)

使用下面的代码从上面的数组创建一个 PIL 图像。

pilimage=Image.fromarray(array)

使用下面的代码查看图像。

plt.figure(figsize=(5,5))
plt.imshow(pilimage) 
plt.axis('off')
plt.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc toimage

这是如何从一个给定的数组创建一个图像。

阅读:剪切旋转图像

科学杂项导数

Scipy 模块*misc*包含一个方法*derivative()*,用于查找给定函数在某一点的 n 阶导数。

下面给出了语法。

scipy.misc.derivative(func, x0, dx=1.0, n=1, args=(), order=3)

其中参数为:

func: 就是我们要求其 n 阶导数的函数。
x0(浮点): 用于指定求导的点。
dx(浮点): 用来指定间距。
n(int): 用于指定导数的阶。
args(tuple): 它用来提供自变量。
***(int)😗**用来指定要使用的点数。

让我们以下面的代码为例。

from scipy.misc import derivative
def fun(x):
    return x`4 + x`3
derivative(fun, 1.0, dx=1e-7)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc derivative

阅读: Scipy Integrate +示例

Scipy Misc imresize

模块*scipy.misc*中的方法*imresize()*在 Scipy 版中已被弃用。这里我们可以用库枕的方法*resize()*来代替方法*imresize()*。

下面给出了语法。

image.resize(size)

其中参数*size*获取我们想要调整大小的图像的像素大小。

让我们以下面的步骤为例:

使用下面的代码导入库*pillow*的模块*image*。

import PIL.Image as img
import matplotlib.pyplot as plt

使用下面的代码打开任何我们想要调整大小的图像。

imz = img.open('lesly_derksen.jpg')

使用下面的代码查看和检查图像的大小。

plt.imshow(imz)
imz.size

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc imresize

为图像定义新的大小，如下面的代码所示。

new_size = (300,300)

让我们使用下面的代码来减小图像的大小。

imz1= imz.resize(new_size)

现在使用下面的代码来查看缩小后的图像。

plt.imshow(imz1)
imz1.size

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc imresize example

阅读: Scipy 信号-有用教程

Scipy 杂项梳

模块*scipy.misc*中的方法*comb()*在 Scipy 版中已被弃用。该方法已经转移到另一个名为*scipy.special*的模块中。这个方法是用来求 k 时刻取的 n 个东西的组合数的。

下面给出了语法。

scipy.special.comb(N, k, exact=False, repetition=False)

其中参数为:

N(ndarray 或 int): 用来指定事物的数量。
K(ndarray 或 int): 用于指定取的元素个数。
exact(boolean): 当其为真时，使用长整数算法计算正确的解，否则以浮点计算近似解。
重复(bool): 如果为真，那么它计算有重复的组合数。

让我们以下面的代码为例。

from scipy.special import comb
k_time = np.array([6, 7])
n_things = np.array([15, 15])
comb(n_things, k_time, exact=False)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc comb

阅读: Scipy 卷积-完整指南

科学杂项上升

Scipy 模块 misc 包含另一个方法*ascent()*来获取大小为 512×512 的派生图像的 8 位灰度位深度。

下面给出了语法。

scipy.misc.ascent()

出于演示目的，该方法返回*ascent*类型的 ndarray 图像。

让我们以下面的代码为例。

import scipy.misc as f
import matplotlib.pyplot as plt

asc = f.ascent()
plt.imshow(asc)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc ascent

Scipy Misc face

Scipy 模块 misc 包含另一个方法face()来获得大小为 1024×768 的彩色浣熊脸。

下面给出了语法。

scipy.misc.face(gray=False)

其中参数为:

gray(布尔): 为真时返回 8 位灰度图像，否则返回彩色图像。

让我们按照下面的步骤举个例子。

导入必要的文件。

import scipy.misc as f
import matplotlib.pyplot as plt

使用下面的代码生成浣熊脸。

racoon_face = f.face()

使用下面的代码显示生成的图像。

plt.imshow(racoon_face)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc face

科学杂项阶乘

模块*scipy.misc*中的方法*factorial()*在 Scipy 版中已被弃用。该方法已经转移到另一个名为*scipy.special*的模块中。此方法用于查找数组中包含的一个数字或所有元素的阶乘。

下面给出了语法。

scipy.special.factorial(n, exact=False)

其中参数为:

n(int 或 array): 是我们要求其阶乘的数字或数字数组。

exact(boolean): 当其为真时，使用长整数算法计算正确的解，否则以浮点计算近似解。

让我们举一个例子，用下面的步骤计算一个数组中所有元素的阶乘。

使用下面的代码导入所需的库。

from scipy.special import factorial
import numpy as np

使用下面的方法创建一个数组并将其传递给方法*factorial()*。

array = np.array([5, 6, 7])
factorial(array, exact=False)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Scipy Misc factorial

因此，在本教程中，我们已经了解了" Scipy Misc "并涵盖了以下主题。

Scipy Misc
Scipy 杂项信息
Scipy Misc imsave
Scipy Misc toimage
Scipy 杂项衍生物
Scipy Misc imresize
Scipy 杂项梳
Scipy 杂项上升
Scipy 杂项脸
Scipy 杂项因子