使用 scipy.linalg 在 Python 中使用线性系统

Yuchuan 发表于 2021/08/19 15:08:28 2021/08/19
【摘要】 在本教程中,您学习了如何: 将线性代数概念应用到实际问题中scipy.linalg 使用 Python 和 NumPy处理向量和矩阵 使用线性系统模拟实际问题 使用求解线性系统 scipy.linalg

目录

线性代数广泛应用于各种学科,一旦您使用向量线性方程等概念组织信息,您就可以用它来解决许多问题。在 Python 中,与该主题相关的大多数例程都在 中实现scipy.linalg,它提供了非常快速的线性代数功能。

尤其是,线性系统在模拟各种现实世界问题中发挥着重要作用,并scipy.linalg提供了以有效方式研究和解决这些问题的工具。

在本教程中,您将学习如何:

  • 线性代数概念应用到实际问题中scipy.linalg
  • 使用 Python 和 NumPy处理向量矩阵
  • 使用线性系统模拟实际问题
  • 如何使用线性系统求解 scipy.linalg

让我们开始吧!

入门 scipy.linalg

SciPy是一个用于科学计算的开源 Python 库,包括用于科学和工程中常见任务的几个模块,例如线性代数优化积分插值信号处理。它是SciPy 堆栈的一部分,其中包括其他几个用于科学计算的包,例如NumPyMatplotlibSymPyIPythonpandas

线性代数是数学的一个分支,涉及线性方程及其使用向量矩阵的表示。它是用于多个工程领域的基础学科,也是深入了解机器学习的先决条件。

scipy.linalg包括用于处理线性代数问题的多种工具,包括用于执行矩阵计算的函数,例如行列式、逆矩阵、特征值、特征向量奇异值分解

在本教程中,您将使用 from 的一些函数scipy.linalg来解决涉及线性系统的实际问题。为了使用scipy.linalg,您必须安装和设置 SciPy 库,您可以使用Anaconda Python 发行版和conda包和环境管理系统来完成。

注意:要了解有关 Anaconda 和 conda 的更多信息,请查看在 Windows 上设置 Python 进行机器学习

首先,创建一个 conda 环境并激活它:

$ conda create --name linalg
$ conda activate linalg

激活 conda 环境后,您的提示将显示其名称linalg. 然后你可以在环境中安装必要的包:

(linalg) $ conda install scipy jupyter

执行此命令后,系统应该需要一段时间才能确定依赖项并继续安装。

注意:除了 SciPy,您还将使用Jupyter Notebook在交互式环境中运行代码。这样做不是强制性的,但它有助于处理数值和科学应用程序。

有关使用 Jupyter Notebooks 的复习,请查看Jupyter Notebook:简介

如果您更喜欢使用不同的 Python 发行版和pip包管理器来阅读本文,请展开下面的可折叠部分以了解如何设置您的环境。

设置环境使用 pip显示隐藏

在打开 Jupyter Notebook 之前,您需要注册 condalinalg环境,以便您可以使用它作为内核来创建 Notebook。为此,在linalg激活环境的情况下,运行以下命令:

(linalg) $ python -m ipykernel install --user --name linalg

现在您可以通过运行以下命令打开 Jupyter Notebook:

$ jupyter notebook

在浏览器中加载Jupyter后,通过点击创建一个新的笔记本电脑→ linalg,如下图所示:

Jupyter 笔记本

内的笔记本电脑,你可以测试是否安装成功通过导入scipy包:

>>>
In [1]: import scipy

现在您已经完成了环境的设置,您将看到如何在 Python 中使用向量和矩阵,这是使用scipy.linalg线性代数应用程序的基础。

使用 NumPy 处理向量和矩阵

矢量是用来表示物理量同时具有大小和方向的数学实体。它是解决工程和机器学习问题的基本工具,就像矩阵一样,用于表示向量变换等应用程序。

NumPy是Python 中处理矩阵和向量最常用的库,用于处理scipy.linalg线性代数应用程序。在本节中,您将了解使用它创建矩阵和向量并对其执行操作的基础知识。

要开始处理矩阵和向量,您需要在 Jupyter Notebook 中做的第一件事是导入numpy. 通常的方法是使用别名np

>>>
In [2]: import numpy as np

为了表示矩阵和向量,NumPy 使用一种称为ndarray.

要创建ndarray对象,您可以使用np.array(),它需要一个类似数组的对象,例如列表或嵌套列表。

例如,假设您需要创建以下矩阵:

使用 NumPy 表示的矩阵

要使用 NumPy 创建它,您可以使用np.array(),提供一个包含矩阵每一行元素的嵌套列表:

>>>
In [3]: A = np.array([[1, 2], [3, 4], [5, 6]])
   ...: A
Out[3]:
array([[1, 2],
       [3, 4],
       [5, 6]])

您可能会注意到,NumPy 提供了矩阵的可视化表示,您可以在其中识别其列和行。

值得注意的是,NumPy 数组的元素必须是相同类型的。您可以使用以下方法检查 NumPy 数组的类型.dtype

>>>
In [4]: A.dtype
Out[4]:
dtype('int64')

由于 的所有元素A都是整数,因此数组是用 type 创建的int64。如果元素之一是float,则将使用 type 创建数组float64

In [5]: A = np.array([[1.0, 2], [3, 4], [5, 6]])
   ...: A
Out[5]:
array([[1., 2.],
       [3., 4.],
       [5., 6.]])

In [6]: A.dtype
Out[6]:
dtype('float64')

要检查ndarray对象的尺寸,您可以使用.shape. 例如,要检查 的尺寸A,您可以使用A.shape

>>>
In [7]: A.shape
Out[7]:
(3, 2)

正如预期的那样,A矩阵的维度是3×2因为A有三行和两列。

在处理涉及矩阵的问题时,您通常需要使用转置操作,它交换矩阵的列和行。

要转置由ndarray对象表示的向量或矩阵,您可以使用.transpose().T。例如,你可以得到的转AA.T

In [8]: A.T
Out[8]:
array([[1., 3., 5.],
       [2., 4., 6.]])

通过换位,列A变成了行,A.T行变成了列。

要创建向量,您可以使用np.array(),提供包含向量元素的列表:

>>>
In [9]: v = np.array([1, 2, 3])
   ...: v
Out[9]:
array([1, 2, 3])

要检查向量的维度,您可以.shape像以前一样使用:

>>>
In [10]: v.shape
Out[10]:
(3,)

请注意,此向量的形状是(3,)and not (3, 1)or (1, 3)。这是一个 NumPy 功能,适用于那些习惯使用MATLAB 的人。在 NumPy 中,可以创建一维数组,例如v,这在执行矩阵和向量之间的操作时可能会导致问题。例如,转置操作对一维数组没有影响。

每当您向 提供类似一维数组的参数时np.array(),生成的数组将是一维数组。要创建二维数组,您必须提供类似二维数组的参数,例如嵌套列表:

>>>
In [11]: v = np.array([[1, 2, 3]])
   ...: v.shape
Out[11]:
(1, 3)

在上述例子中,尺寸v1× 3,其对应于一个两维的线矢量的尺寸。要创建列向量,您可以使用嵌套列表:

>>>
In [12]: v = np.array([[1], [2], [3]])
   ...: v.shape
Out[12]:
(3, 1)

在这种情况下,尺寸v3× 1,其对应于一个两维列向量的尺寸。

使用嵌套列表创建向量可能很费力,尤其是对于使用最多的列向量。作为替代方案,您可以创建一个一维向量,为 提供一个平面列表np.array,并用于.reshape()更改ndarray对象的维度:

In [13]: v = np.array([1, 2, 3]).reshape(3, 1)
   ...: v.shape
Out[13]:
(3, 1)

在上面的示例中,您使用从.reshape()形状(3, 1)为 的一维向量获取形状的列向量(3,)。值得一提的是,.reshape()期望新数组的元素数与原数组的元素数兼容。换句话说,具有新形状的数组中的元素数必须等于原始数组中的元素数。

在这个例子中,你也可以在.reshape()不明确定义数组行数的情况下使用:

>>>
In [14]: v = np.array([1, 2, 3]).reshape(-1, 1)
   ...: v.shape
Out[14]:
(3, 1)

在这里,-1您提供的参数.reshape()表示新数组只有一列所需的行数,如第二个参数所指定。在这种情况下,由于原始数组具有三个元素,因此新数组的行数将为3

在实际应用中,您经常需要创建零、一或随机元素的矩阵。为此,NumPy 提供了一些方便的函数,接下来您将看到这些函数。

使用便捷函数创建数组

NumPy 还提供了一些方便的函数来创建数组。例如,要创建一个填充零的数组,您可以使用np.zeros()

>>>
In [15]: A = np.zeros((3, 2))
   ...: A
Out[15]:
array([[0., 0.],
       [0., 0.],
       [0., 0.]])

作为它的第一个参数,np.zeros()需要一个元组来指示您要创建的数组的形状,它返回一个类型为 的数组float64

同样,要创建填充数组,您可以使用np.ones()

>>>
In [16]: A = np.ones((2, 3))
   ...: A
Out[16]:
array([[1., 1., 1.],
       [1., 1., 1.]])

值得注意的是,np.ones()它还返回一个类型为 的数组float64

要创建具有随机元素的数组,您可以使用np.random.rand()

In [17]: A = np.random.rand(3, 2)
   ...: A
Out[17]:
array([[0.8206045 , 0.54470809],
       [0.9490381 , 0.05677859],
       [0.71148476, 0.4709059 ]])

np.random.rand()返回一个包含从0到 的随机元素的数组1,取自均匀分布。请注意,与np.zeros()and不同np.ones()np.random.rand()它不期望元组作为其参数。

同样,要从均值和单位方差为零的正态分布中获取随机元素的数组,您可以使用np.random.randn()

>>>
In [18]: A = np.random.randn(3, 2)
   ...: A
Out[18]:
array([[-1.20019512, -1.78337814],
       [-0.22135221, -0.38805899],
       [ 0.17620202, -2.05176764]])

现在您已经创建了数组,您将看到如何使用它们执行操作。

对 NumPy 数组执行操作

在数组上使用加法 ( +)、减法 ( -)、乘法 ( *)、除法 ( /) 和指数 ( **) 运算符的常见 Python 运算始终按元素执行。如果操作数之一是标量,则将在标量和数组的每个元素之间执行操作。

例如,为了创建填充元素的矩阵等于10,则可以使用np.ones()由和乘法的输出10使用*

>>>
In [19]: A = 10 * np.ones((2, 2))
   ...: A
Out[19]:
array([[10., 10.],
       [10., 10.]])

如果两个操作数都是相同形状的数组,则将在数组的对应元素之间执行操作:

>>>
In [20]: A = 10 * np.ones((2, 2))
   ...: B = np.array([[2, 2], [5, 5]])
   ...: C = A * B
   ...: C
Out[20]:
array([[20., 20.],
       [50., 50.]])

在这里,您将 matrixA的每个元素乘以 matrix的相应元素B

要根据线性代数规则执行矩阵乘法,您可以使用np.dot()

>>>
In [21]: A = np.array([[1, 2], [3, 4]])
   ...: v = np.array([[5], [6]])
   ...: x = np.dot(A, v)
   ...: x
Out[21]:
array([[17],
       [39]])

在这里,您乘以一个 2 × 2 矩阵A,该矩阵由一个名为的 2 × 1 向量命名v

您可以使用@运算符获得相同的结果,从PEP 465 和 Python 3.5 开始, NumPy 和本机 Python 都支持该运算符:

>>>
In [22]: A = np.array([[1, 2], [3, 4]])
   ...: v = np.array([[5], [6]])
   ...: x = A @ v
   ...: x
Out[22]:
array([[17],
       [39]])

除了处理矩阵和向量的基本操作外,NumPy 还提供了一些特定的函数来处理numpy.linalg. 但是,对于这些应用程序,它scipy.linalg具有一些优势,您将在下面看到。

比较scipy.linalgnumpy.linalg

NumPy 在numpy.linalg模块中包含一些用于处理线性代数应用程序的工具。但是,除非您不想将 SciPy 作为依赖项添加到项目中,否则通常最好使用scipy.linalg,原因如下:

  • 由于在解释官方文档scipy.linalg包含了所有的功能numpy.linalg再加上一些额外的高级功能,不包括在numpy.linalg

  • scipy.linalg编译时始终支持BLASLAPACK,这些库包括用于以优化方式执行数值运算的例程。对于numpy.linalg,BLAS 和 LAPACK 的使用是可选的。因此,根据您安装 NumPy 的方式,scipy.linalg函数可能比numpy.linalg.

总之,考虑到科学和技术应用一般没有关于限制的依赖,它通常是一个好主意,安装SciPy的和使用scipy.linalg代替numpy.linalg

在下一节中,您将使用scipy.linalg工具来处理线性系统。您将首先通过一个简单的示例了解基础知识,然后将这些概念应用于实际问题。

使用scipy.linalg.solve()求解线性系统

线性系统可以成为解决几个实际和重要问题的有用工具,包括与车辆交通、平衡化学方程式、电路和多项式插值相关的问题

在本节中,您将学习如何使用scipy.linalg.solve()来求解线性系统。但是在开始编写代码之前,了解基础知识很重要。

了解线性系统

线性系统,或者更精确地说,线性方程系统,是一组直线与一组变量方程。以下是与变量x ₁、x ₂ 和x ₃相关的线性系统示例:

线性系统示例

这里有涉及三个变量的三个方程。为了有一个线性系统,值ķ ₁... ķ ₉和b ₁... b ₃必须是常数。

当只有两个或三个方程和变量时,可以手动执行计算、组合方程并找到变量的值。但是,对于四个或更多变量,手动求解线性系统需要相当长的时间,并且经常会出错。

实际应用通常涉及大量变量,这使得手动求解线性系统是不可行的。幸运的是,有一些工具可以完成这项艰巨的工作,例如scipy.linalg.solve().

使用 scipy.linalg.solve()

SciPy 提供scipy.linalg.solve()快速且可靠的方式求解线性系统。要了解它是如何工作的,请考虑以下系统:

线性系统

为了使用scipy.linalg.solve(),您首先需要将线性系统写为矩阵乘积,如下面的等式所示:

使用矩阵和向量表示的线性系统

请注意,您将在计算矩阵乘积后得出系统的原始方程。scipy.linalg.solve()期望求解的输入是 matrixA和 vector b,您可以使用 NumPy 数组定义它们。这样,您可以使用以下代码解决系统问题:

>>>
 1In [1]: import numpy as np
 2   ...: from scipy.linalg import solve
 3
 4In [2]: A = np.array(
 5   ...:    [
 6   ...:        [3, 2],
 7   ...:        [2, -1],
 8   ...:    ]
 9   ...: )
10
11In [3]: b = np.array([12, 1]).reshape((2, 1))
12
13In [4]: x = solve(A, b)
14   ...: x
15Out[4]:
16array([[2.],
17       [3.]])

以下是正在发生的事情的细分:

  • 第 1 行和第 2 行导入 NumPynp以及solve()from scipy.linalg
  • 第 4 到 9 行使用名为 的 NumPy 数组创建系数矩阵A
  • 第 11 行使用名为 的 NumPy 数组创建独立项向量b。要使其成为具有两行的列向量,请使用.reshape((2, 1)).
  • 第 13 行和第 14 行调用solve()求解由A和表征的线性系统b,结果存储在 中x,并打印出来。请注意solve(),即使原始数组的所有元素都是整数,也会返回带有浮点分量的解。

如果将原始方程中的x ₁=2 和x ₂=3替换,则可以验证这是系统的解。

现在您已经了解了使用的基础知识scipy.linalg.solve(),是时候了解线性系统的实际应用了。

解决实际问题:Building a Meal Plan

通常使用线性系统解决的一类问题是当您需要找到获得某种混合物所需的组件比例时。下面,您将使用这个想法来制定膳食计划,混合不同的食物以获得均衡的饮食。

为此,请考虑均衡饮食应包括以下内容:

  • 170单位维生素A
  • 180单位维生素B
  • 140单位维生素C
  • 180 单位维生素 D
  • 350 单位维生素 E

你的任务是找出每种不同食物的数量,以获得指定数量的维生素。在下表中,您可以根据每种维生素的单位分析 1 克每种食物的结果:

你的任务是找出每种不同食物的数量,以获得指定数量的维生素。在下表中,您可以根据每种维生素的单位分析 1 克每种食物的结果:

食物 维生素A 维生素B 维生素C 维生素D 维生素E
#1 1 10 1 2 2
#2 9 1 0 1 1
#3 2 2 5 1 2
#4 1 1 1 2 13
#5 1 1 1 9 2

通过将食物 1 表示为x ₁ 等,并考虑到您将混合x ₁ 单位的食物 1、x 2 单位的食物 2 等等,您可以写出您所摄入的维生素 A 量的表达式d 进入组合。考虑到均衡饮食应包含 170 个单位的维生素 A,您​​可以使用维生素 A 列中的数据写出以下等式:

维生素A的方程式

对维生素 B、C、D 和 E 重复相同的过程,您会得到以下线性系统:

适用于所有维生素的线性系统

要使用scipy.linalg.solve(),您必须获得系数矩阵A和独立项向量b,它们由以下给出:

使用矩阵和向量的所有维生素的线性系统

现在您只需使用scipy.linalg.solve()来找出数量x ₁, …, x ₅:

>>>
In [1]: import numpy as np
   ...: from scipy.linalg import solve

In [2]: A = np.array(
   ...:     [
   ...:         [1, 9, 2, 1, 1],
   ...:         [10, 1, 2, 1, 1],
   ...:         [1, 0, 5, 1, 1],
   ...:         [2, 1, 1, 2, 9],
   ...:         [2, 1, 2, 13, 2],
   ...:     ]
   ...: )

In [3]: b = np.array([170, 180, 140, 180, 350]).reshape((5, 1))

In [4]: x = solve(A, b)
   ...: x
Out[4]:
array([[10.],
       [10.],
       [20.],
       [20.],
       [10.]])

这表明均衡饮食应包括10食物单位 1、食物10单位 2、20食物20单位3、食物单位 4 和10食物单位 5。

结论

恭喜!您已经学习了如何使用一些线性代数概念以及如何使用scipy.linalg来解决涉及线性系统的问题。您已经看到向量和矩阵可用于表示数据,并且通过使用线性代数概念,您可以对实际问题进行建模并以有效的方式解决它们。

在本教程中,您学习了如何:

  • 线性代数概念应用到实际问题中scipy.linalg
  • 使用 Python 和 NumPy处理向量矩阵
  • 使用线性系统模拟实际问题
  • 使用求解线性系统 scipy.linalg

线性代数是一个非常广泛的话题。有关其他一些线性代数应用程序的更多信息,请查看以下资源:

继续学习,随时在下面留下任何问题或评论!

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区),文章链接,文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件至:cloudbbs@huaweicloud.com进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容。
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。