关于python:结合scipylinalg在Python中使用线性系统

摘要：将线性代数概念利用到理论问题中 scipy.linalg 应用 Python 和 NumPy 解决向量和矩阵 应用线性系统模仿理论问题 应用求解线性系统 scipy.linalg

本文分享自华为云社区《应用 scipy.linalg 在 Python 中应用线性系统》，作者：Yuchuan。

线性代数 广泛应用于各种学科，一旦您应用 向量 和线性方程 等概念组织信息，您就能够用它来解决许多问题。在 Python 中，与该主题相干的大多数例程都在中实现 scipy.linalg，它提供了十分疾速的线性代数性能。

尤其是，线性系统 在模仿各种事实世界问题中施展着重要作用，并 scipy.linalg 提供了以无效形式钻研和解决这些问题的工具。

在本教程中，您将学习如何：

• 将线性代数概念利用到理论问题中 scipy.linalg
• 应用 Python 和 NumPy 解决向量和矩阵
• 应用线性系统模仿理论问题
• 如何应用线性系统求解 scipy.linalg

让咱们开始吧！

入门 scipy.linalg

SciPy 是一个用于科学计算的开源 Python 库，包含用于迷信和工程中常见工作的几个模块，例如线性代数、优化、积分、插值和信号处理。它是 SciPy 堆栈的一部分，其中包含其余几个用于科学计算的包，例如 NumPy、Matplotlib、SymPy、IPython 和 pandas。

线性代数是数学的一个分支，波及线性方程及其应用向量和矩阵的示意。它是用于多个工程畛域的基础学科，也是深刻理解机器学习的先决条件。

scipy.linalg 包含用于解决线性代数问题的多种工具，包含用于执行矩阵计算的函数，例如行列式、逆矩阵、特征值、特征向量和奇怪值合成。

在本教程中，您将应用 from 的一些函数 scipy.linalg 来解决波及线性系统的理论问题。为了应用 scipy.linalg，您必须装置和设置 SciPy 库，您能够应用 AnacondaPython 发行版和 conda 包和环境管理系统来实现。

留神：要理解无关 Anaconda 和 conda 的更多信息，请查看在 Windows 上设置 Python 进行机器学习。

首先，创立一个 conda 环境并激活它：

$condacreate--namelinalg
$condaactivatelinalg

激活 conda 环境后，您的提醒将显示其名称 linalg. 而后你能够在环境中装置必要的包：

(linalg)$condainstallscipyjupyter
执行此命令后，零碎应该须要一段时间能力确定依赖项并持续装置。

留神：除了 SciPy，您还将应用 JupyterNotebook 在交互式环境中运行代码。这样做不是强制性的，但它有助于解决数值和迷信应用程序。

无关应用 JupyterNotebooks 的温习，请查看 JupyterNotebook：简介。

如果您更喜爱应用不同的 Python 发行版和 pip 包管理器来浏览本文，请开展上面的可折叠局部以理解如何设置您的环境。

设置环境应用 pip 显示暗藏

在关上 JupyterNotebook 之前，您须要注册 condalinalg 环境，以便您能够应用它作为内核来创立 Notebook。为此，在 linalg 激活环境的状况下，运行以下命令：

(linalg)$python-mipykernelinstall--user--namelinalg

当初您能够通过运行以下命令关上 JupyterNotebook：

$jupyternotebook
在浏览器中加载 Jupyter 后，通过点击创立一个新的笔记本电脑新→linalg，如下图所示：

内的笔记本电脑，你能够测试是否装置胜利通过导入的 scipy 包：

In[1]:importscipy
当初您曾经实现了环境的设置，您将看到如何在 Python 中应用向量和矩阵，这是应用 scipy.linalg 线性代数应用程序的根底。

应用 NumPy 解决向量和矩阵

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

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

要开始解决矩阵和向量，您须要在 JupyterNotebook 中做的第一件事是导入 numpy. 通常的办法是应用别名 np：

In[2]:importnumpyasnp
为了示意矩阵和向量，NumPy 应用一种称为 ndarray.

要创立 ndarray 对象，您能够应用 np.array()，它须要一个相似数组的对象，例如列表或嵌套列表。

例如，假如您须要创立以下矩阵：

要应用 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。例如，你能够失去的转 A 用 A.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,)andnot(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)

在上述例子中，尺寸 v 是 1×3，其对应于一个两维的线矢量的尺寸。要创立列向量，您能够应用嵌套列表：

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

在这种状况下，尺寸 v 为 3×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。

您能够应用 @运算符取得雷同的后果，从 PEP465 和 Python3.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.linalg 用 numpy.linalg

NumPy 在 numpy.linalg 模块中蕴含一些用于解决线性代数应用程序的工具。然而，除非您不想将 SciPy 作为依赖项增加到我的项目中，否则通常最好应用 scipy.linalg，起因如下：

• 因为在解释官网文档，scipy.linalg 蕴含了所有的性能 numpy.linalg 再加上一些额定的高级性能，不包含在 numpy.linalg。
• scipy.linalg 编译时始终反对 BLAS 和 LAPACK，这些库包含用于以优化形式执行数值运算的例程。对于 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 和 vectorb，您能够应用 NumPy 数组定义它们。这样，您能够应用以下代码解决零碎问题：

1In[1]:importnumpyasnp
2...:fromscipy.linalgimportsolve
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()fromscipy.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()，是时候理解线性系统的理论利用了。

解决理论问题：BuildingaMealPlan

通常应用线性系统解决的一类问题是当您须要找到取得某种混合物所需的组件比例时。上面，您将应用这个想法来制订膳食打算，混合不同的食物以取得平衡的饮食。

为此，请思考平衡饮食应包含以下内容：

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

你的工作是找出每种不同食物的数量，以取得指定数量的维生素。在下表中，您能够依据每种维生素的单位剖析 1 克每种食物的后果：

你的工作是找出每种不同食物的数量，以取得指定数量的维生素。在下表中，您能够依据每种维生素的单位剖析 1 克每种食物的后果：

通过将食物 1 示意为 x₁等，并思考到您将混合 x₁单位的食物 1、x2 单位的食物 2 等等，您能够写出您所摄入的维生素 A 量的表达式 d 进入组合。思考到平衡饮食应蕴含 170 个单位的维生素 A，您​​能够应用维生素 A 列中的数据写出以下等式：

对维生素 B、C、D 和 E 反复雷同的过程，您会失去以下线性系统：

要应用 scipy.linalg.solve()，您必须取得系数矩阵 A 和独立项向量 b，它们由以下给出：

当初您只需应用 scipy.linalg.solve()来找出数量 x₁,…,x₅：

In[1]:importnumpyasnp
...:fromscipy.linalgimportsolve

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

点击关注，第一工夫理解华为云陈腐技术~