Math - Linear Algebra 數學 - 線性代數

Linear Algebra is the branch of mathematics that studies vector spaces and linear transformations between vector spaces, such as rotating a shape, scaling it up or down, translating it (ie. moving it), etc.
線性代數是數學的一個分支，它研究向量空間和向量空間之間的線性變換，例如旋轉形狀、放大或縮小、平移（即移動）等。

Machine Learning relies heavily on Linear Algebra, so it is essential to understand what vectors and matrices are, what operations you can perform with them, and how they can be useful.
機器學習在很大程度上依賴於線性代數，因此了解什麼是向量和矩陣、您可以使用它們執行哪些操作以及它們有何用處至關重要。

Before we start, let's ensure that this notebook works well in both Python 2 and 3:
在開始之前，我們來確保此筆記本在 Python 2 和 3 中都能正常工作：

Vectors¶ 向量¶

Definition¶ 定義¶

A vector is a quantity defined by a magnitude and a direction. For example, a rocket's velocity is a 3-dimensional vector: its magnitude is the speed of the rocket, and its direction is (hopefully) up. A vector can be represented by an array of numbers called scalars. Each scalar corresponds to the magnitude of the vector with regards to each dimension.
向量是由大小和方向定義的量。例如，火箭的速度是一個 3 維向量：它的大小是火箭的速度，它的方向（希望）是向上的。向量可以由稱為標量的數字數位數組表示。每個標量對應於向量相對於每個維度的大小。

For example, say the rocket is going up at a slight angle: it has a vertical speed of 5,000 m/s, and also a slight speed towards the East at 10 m/s, and a slight speed towards the North at 50 m/s. The rocket's velocity may be represented by the following vector:
例如，假設火箭以一個小角度上升：它的垂直速度為 5,000 m/s，向東的垂直速度為 10 m/s，向北的微速度為 50 m/s。火箭的速度可以用以下向量表示：

velocity $=\left(\begin{array}{c}10\\ 50\\ 5000\end{array}\right)$
速度 $=\left(\begin{array}{c}10\\ 50\\ 5000\end{array}\right)$

Note: by convention vectors are generally presented in the form of columns. Also, vector names are generally lowercase to distinguish them from matrices (which we will discuss below) and in bold (when possible) to distinguish them from simple scalar values such as $meters\mathrm{\_}per\mathrm{\_}second=5026$.
注意：按照約定，向量通常以列的形式表示。此外，向量名稱通常為小寫，以便與矩陣（我們將在下面討論）區分開來，並使用粗體（如果可能）以區別於簡單的標量值，例如 $meters\mathrm{\_}per\mathrm{\_}second=5026$ .

A list of N numbers may also represent the coordinates of a point in an N-dimensional space, so it is quite frequent to represent vectors as simple points instead of arrows. A vector with 1 element may be represented as an arrow or a point on an axis, a vector with 2 elements is an arrow or a point on a plane, a vector with 3 elements is an arrow or point in space, and a vector with N elements is an arrow or a point in an N-dimensional space… which most people find hard to imagine.
N 個數位的清單也可以表示 N 維空間中某個點的座標，因此將向量表示為簡單點而不是箭頭是相當常見的。具有 1 個元素的向量可以表示為軸上的箭頭或點，具有 2 個元素的向量是平面上的箭頭或點，具有 3 個元素的向量是空間中的箭頭或點，具有 N 個元素的向量是 N 維空間中的箭頭或點......大多數人覺得很難想像。

Purpose¶ 目的¶

Vectors have many purposes in Machine Learning, most notably to represent observations and predictions. For example, say we built a Machine Learning system to classify videos into 3 categories (good, spam, clickbait) based on what we know about them. For each video, we would have a vector representing what we know about it, such as:
向量在機器學習中有很多用途，最明顯的是表示觀察和預測。例如，假設我們構建了一個機器學習系統，根據我們對視頻的瞭解將視頻分為 3 類（好、垃圾、點擊誘餌）。對於每個視頻，我們將有一個向量來表示我們對它的瞭解，例如：

video $=\left(\begin{array}{c}10.5\\ 5.2\\ 3.25\\ 7.0\end{array}\right)$ 視頻 $=\left(\begin{array}{c}10.5\\ 5.2\\ 3.25\\ 7.0\end{array}\right)$

This vector could represent a video that lasts 10.5 minutes, but only 5.2% viewers watch for more than a minute, it gets 3.25 views per day on average, and it was flagged 7 times as spam. As you can see, each axis may have a different meaning.
這個向量可以代表一個持續 10.5 分鐘的視頻，但只有 5.2% 的觀眾觀看時間超過一分鐘，平均每天獲得 3.25 次觀看，並且被標記為垃圾郵件 7 次。如您所見，每個軸可能具有不同的含義。

Based on this vector our Machine Learning system may predict that there is an 80% probability that it is a spam video, 18% that it is clickbait, and 2% that it is a good video. This could be represented as the following vector:
根據這個向量，我們的機器學習系統可能會預測它是垃圾郵件視頻的概率為80%，點擊誘餌的概率為18%，優質視頻的概率為2%。這可以表示為以下向量：

class_probabilities $=\left(\begin{array}{c}0.80\\ 0.18\\ 0.02\end{array}\right)$
$=\left(\begin{array}{c}0.80\\ 0.18\\ 0.02\end{array}\right)$ class_probabilities

Vectors in python¶
python 中的 vectors¶

In python, a vector can be represented in many ways, the simplest being a regular python list of numbers:
在 python 中，向量可以用多種方式表示，最簡單的是常規的 python 數字清單：

Since we plan to do quite a lot of scientific calculations, it is much better to use NumPy's ndarray, which provides a lot of convenient and optimized implementations of essential mathematical operations on vectors (for more details about NumPy, check out the NumPy tutorial). For example:
由於我們計劃進行相當多的科學計算，因此最好使用 NumPy 的 ndarray，它為向量的基本數學運算提供了許多方便和優化的實現（有關 NumPy 的更多詳細資訊，請查看 NumPy 教程）。例如：

The size of a vector can be obtained using the size attribute:
可以使用 size 屬性獲取向量的大小：

The $i^{th}$ element (also called entry or item) of a vector $\mathbf{\text{v}}$ is noted ${\mathbf{\text{v}}}_i$.
表示 ${\mathbf{\text{v}}}_i$ 向量 $\mathbf{\text{v}}$ 的 $i^{th}$ 元素（也稱為 entry 或 item）。

Note that indices in mathematics generally start at 1, but in programming they usually start at 0. So to access ${\mathbf{\text{video}}}_3$ programmatically, we would write:
請注意，數學中的索引通常從 1 開始，但在程式設計中它們通常從 0 開始。因此，要以程式設計方式訪問 ${\mathbf{\text{video}}}_3$ ，我們可以編寫：

Plotting vectors¶
繪製向量¶

To plot vectors we will use matplotlib, so let's start by importing it (for details about matplotlib, check the matplotlib tutorial):
要繪製向量，我們將使用 matplotlib，因此讓我們從導入它開始（有關 matplotlib 的詳細資訊，請查看 matplotlib 教程）：

2D vectors¶ 2D 向量¶

Let's create a couple very simple 2D vectors to plot:
讓我們創建幾個非常簡單的 2D 向量來繪製：

These vectors each have 2 elements, so they can easily be represented graphically on a 2D graph, for example as points:
這些向量每個都有2個元素，因此它們可以很容易地在2D圖形上以圖形方式表示，例如點：

Vectors can also be represented as arrows. Let's create a small convenience function to draw nice arrows:
向量也可以表示為箭頭。讓我們創建一個小的便捷函數來繪製漂亮的箭頭：

Now let's draw the vectors u and v as arrows:
現在讓我們將向量 u 和 v 繪製為箭頭：

3D vectors¶ 3D 向量¶

Plotting 3D vectors is also relatively straightforward. First let's create two 3D vectors:
繪製 3D 向量也相對簡單。首先，讓我們創建兩個 3D 向量：

Now let's plot them using matplotlib's Axes3D:
現在讓我們使用 matplotlib 的 Axes3D 繪製它們：

It is a bit hard to visualize exactly where in space these two points are, so let's add vertical lines. We'll create a small convenience function to plot a list of 3d vectors with vertical lines attached:
要準確想像這兩個點在空間中的確切位置有點困難，因此讓我們添加垂直線。我們將建立一個小的便捷函數來繪製帶有垂直線的 3D 向量清單：

Norm¶ 范數¶

The norm of a vector $\mathbf{\text{u}}$, noted $\Vert \mathbf{\text{u}}\Vert$, is a measure of the length (a.k.a. the magnitude) of $\mathbf{\text{u}}$. There are multiple possible norms, but the most common one (and the only one we will discuss here) is the Euclidian norm, which is defined as:
向量的範數 $\mathbf{\text{u}}$ ，注意到 $\Vert \mathbf{\text{u}}\Vert$ ，是的長度（又名大小）的量度 $\mathbf{\text{u}}$ 。有多種可能的範數，但最常見的一種（也是我們在這裡討論的唯一一種）是歐幾里得範數，其定義如下：

$\Vert \mathbf{\text{u}}\Vert =\sqrt{\sum _i{{\mathbf{\text{u}}}_i}^2}$

We could implement this easily in pure python, recalling that $\sqrt{x}=x^{\frac{1}{2}}$
我們可以很容易地用純 python 實現這一點，回想一下 $\sqrt{x}=x^{\frac{1}{2}}$

However, it is much more efficient to use NumPy's norm function, available in the linalg (Linear Algebra) module:
但是，使用 NumPy 的範數函數要高效得多，該函數在 linalg （Linear Algebra） 模組中可用：

Let's plot a little diagram to confirm that the length of vector $\mathbf{\text{v}}$ is indeed $\approx 5.4$:
讓我們畫一個小圖來確認向量 $\mathbf{\text{v}}$ 的長度確實是： $\approx 5.4$

Looks about right! 看起來差不多！

Addition¶ 添加¶

Vectors of same size can be added together. Addition is performed elementwise:
相同大小的向量可以相加。加法按元素執行：

Let's look at what vector addition looks like graphically:
讓我們看看向量加法的圖形效果：

Vector addition is commutative, meaning that $\mathbf{\text{u}}+\mathbf{\text{v}}=\mathbf{\text{v}}+\mathbf{\text{u}}$. You can see it on the previous image: following $\mathbf{\text{u}}$ then $\mathbf{\text{v}}$ leads to the same point as following $\mathbf{\text{v}}$ then $\mathbf{\text{u}}$.
向量加法是可交換的，這意味著 $\mathbf{\text{u}}+\mathbf{\text{v}}=\mathbf{\text{v}}+\mathbf{\text{u}}$ .您可以在上圖中看到它：following $\mathbf{\text{u}}$ then $\mathbf{\text{v}}$ 導致與 following $\mathbf{\text{v}}$ then $\mathbf{\text{u}}$ 相同的點。

Vector addition is also associative, meaning that $\mathbf{\text{u}}+(\mathbf{\text{v}}+\mathbf{\text{w}})=(\mathbf{\text{u}}+\mathbf{\text{v}})+\mathbf{\text{w}}$.
向量加法也是結合的，這意味著 $\mathbf{\text{u}}+(\mathbf{\text{v}}+\mathbf{\text{w}})=(\mathbf{\text{u}}+\mathbf{\text{v}})+\mathbf{\text{w}}$ 。

If you have a shape defined by a number of points (vectors), and you add a vector $\mathbf{\text{v}}$ to all of these points, then the whole shape gets shifted by $\mathbf{\text{v}}$. This is called a geometric translation:
如果元件由多個點（向量）定義，並且向所有這些點添加一個向量 $\mathbf{\text{v}}$ ，則整個形狀將移動 $\mathbf{\text{v}}$ 。這稱為幾何平移：

Finally, substracting a vector is like adding the opposite vector.
最後，減去向量就像添加相反的向量。

Multiplication by a scalar¶
乘以標量¶

Vectors can be multiplied by scalars. All elements in the vector are multiplied by that number, for example:
向量可以乘以標量。向量中的所有元素都乘以該數位，例如：

Graphically, scalar multiplication results in changing the scale of a figure, hence the name scalar. The distance from the origin (the point at coordinates equal to zero) is also multiplied by the scalar. For example, let's scale up by a factor of k = 2.5:
從圖形上看，標量乘法會導致圖形的比例發生變化，因此得名標量。距原點 （座標等於零的點） 的距離也乘以標量。例如，讓我們按係數 k = 2.5 進行擴展：

As you might guess, dividing a vector by a scalar is equivalent to multiplying by its inverse:
正如您可能猜到的那樣，將向量除以標量等效於乘以其逆函數：

${\displaystyle \frac{\mathbf{\text{u}}}{\lambda }}={\displaystyle \frac{1}{\lambda }}\times \mathbf{\text{u}}$

Scalar multiplication is commutative: $\lambda \times \mathbf{\text{u}}=\mathbf{\text{u}}\times \lambda$.
標量乘法是可交換的： $\lambda \times \mathbf{\text{u}}=\mathbf{\text{u}}\times \lambda$ 。

It is also associative: ${\lambda }_1\times ({\lambda }_2\times \mathbf{\text{u}})=({\lambda }_1\times {\lambda }_2)\times \mathbf{\text{u}}$.
它也是結合的： ${\lambda }_1\times ({\lambda }_2\times \mathbf{\text{u}})=({\lambda }_1\times {\lambda }_2)\times \mathbf{\text{u}}$ .

Finally, it is distributive over addition of vectors: $\lambda \times (\mathbf{\text{u}}+\mathbf{\text{v}})=\lambda \times \mathbf{\text{u}}+\lambda \times \mathbf{\text{v}}$.
最後，它是分散式的，而不是向量的添加： $\lambda \times (\mathbf{\text{u}}+\mathbf{\text{v}})=\lambda \times \mathbf{\text{u}}+\lambda \times \mathbf{\text{v}}$ 。

Zero, unit and normalized vectors¶
零、單位和歸一化向量¶

• A **zero-vector ** is a vector full of 0s.
  零向量是充滿 0 的向量。
• A unit vector is a vector with a norm equal to 1.
  單位向量是范數等於 1 的向量。
• The normalized vector of a non-null vector $\mathbf{\text{u}}$, noted $\widehat{\mathbf{\text{u}}}$, is the unit vector that points in the same direction as $\mathbf{\text{u}}$. It is equal to: $\widehat{\mathbf{\text{u}}}={\displaystyle \frac{\mathbf{\text{u}}}{\Vert \mathbf{\text{u}}\Vert }}$
  非 null 向量 $\mathbf{\text{u}}$ 的歸一化向量 ，注意 $\widehat{\mathbf{\text{u}}}$ ，是指向與 $\mathbf{\text{u}}$ 相同的方向的單位向量。它等於： $\widehat{\mathbf{\text{u}}}={\displaystyle \frac{\mathbf{\text{u}}}{\Vert \mathbf{\text{u}}\Vert }}$

Dot product¶ 點積¶

Definition¶ 定義¶

The dot product (also called scalar product or inner product in the context of the Euclidian space) of two vectors $\mathbf{\text{u}}$ and $\mathbf{\text{v}}$ is a useful operation that comes up fairly often in linear algebra. It is noted $\mathbf{\text{u}}\cdot \mathbf{\text{v}}$, or sometimes $⟨\mathbf{\text{u}}|\mathbf{\text{v}}⟩$ or $(\mathbf{\text{u}}|\mathbf{\text{v}})$, and it is defined as:
兩個向量的點積（在歐幾里得空間的上下文中也稱為標量積或內積） $\mathbf{\text{u}}$ 是 $\mathbf{\text{v}}$ 線性代數中經常出現的有用運算。它被注意到 ，或有時 $⟨\mathbf{\text{u}}|\mathbf{\text{v}}⟩$ 是 $\mathbf{\text{u}}\cdot \mathbf{\text{v}}$ 或 $(\mathbf{\text{u}}|\mathbf{\text{v}})$ ，它被定義為：

$\mathbf{\text{u}}\cdot \mathbf{\text{v}}=\Vert \mathbf{\text{u}}\Vert \times \Vert \mathbf{\text{v}}\Vert \times cos(\theta )$

where $\theta$ is the angle between $\mathbf{\text{u}}$ and $\mathbf{\text{v}}$.
其中 $\theta$ 是和 $\mathbf{\text{v}}$ 之間的 $\mathbf{\text{u}}$ 角度。

Another way to calculate the dot product is:
計算點積的另一種方法是：

$\mathbf{\text{u}}\cdot \mathbf{\text{v}}=\sum _i{\mathbf{\text{u}}}_i\times {\mathbf{\text{v}}}_i$

In python¶ 在 python 中¶

The dot product is pretty simple to implement:
點積的實現非常簡單：

But a much more efficient implementation is provided by NumPy with the dot function:
但是 NumPy 通過 dot 函數提供了一個更有效的實現：

Equivalently, you can use the dot method of ndarrays:
等效地，你可以使用 ndarrays 的 dot 方法：

Caution: the * operator will perform an elementwise multiplication, NOT a dot product:
注意： * 運算子將執行按元素乘法，而不是點積：

Main properties¶
主要屬性¶

• The dot product is commutative: $\mathbf{\text{u}}\cdot \mathbf{\text{v}}=\mathbf{\text{v}}\cdot \mathbf{\text{u}}$.
  點積是可交換的： $\mathbf{\text{u}}\cdot \mathbf{\text{v}}=\mathbf{\text{v}}\cdot \mathbf{\text{u}}$ 。
• The dot product is only defined between two vectors, not between a scalar and a vector. This means that we cannot chain dot products: for example, the expression $\mathbf{\text{u}}\cdot \mathbf{\text{v}}\cdot \mathbf{\text{w}}$ is not defined since $\mathbf{\text{u}}\cdot \mathbf{\text{v}}$ is a scalar and $\mathbf{\text{w}}$ is a vector.
  點積僅在兩個向量之間定義，而不是在標量和向量之間定義。這意味著我們不能鏈式點積：例如，表達式 $\mathbf{\text{u}}\cdot \mathbf{\text{v}}\cdot \mathbf{\text{w}}$ 沒有定義，因為 $\mathbf{\text{u}}\cdot \mathbf{\text{v}}$ 是標量 並且 $\mathbf{\text{w}}$ 是向量。
• This also means that the dot product is NOT associative: $(\mathbf{\text{u}}\cdot \mathbf{\text{v}})\cdot \mathbf{\text{w}}\ne \mathbf{\text{u}}\cdot (\mathbf{\text{v}}\cdot \mathbf{\text{w}})$ since neither are defined.
  這也意味著點積不是結合的： $(\mathbf{\text{u}}\cdot \mathbf{\text{v}})\cdot \mathbf{\text{w}}\ne \mathbf{\text{u}}\cdot (\mathbf{\text{v}}\cdot \mathbf{\text{w}})$ 因為兩者都沒有定義。
• However, the dot product is associative with regards to scalar multiplication: $\lambda \times (\mathbf{\text{u}}\cdot \mathbf{\text{v}})=(\lambda \times \mathbf{\text{u}})\cdot \mathbf{\text{v}}=\mathbf{\text{u}}\cdot (\lambda \times \mathbf{\text{v}})$
  但是，點積對於標量乘法是結合的： $\lambda \times (\mathbf{\text{u}}\cdot \mathbf{\text{v}})=(\lambda \times \mathbf{\text{u}})\cdot \mathbf{\text{v}}=\mathbf{\text{u}}\cdot (\lambda \times \mathbf{\text{v}})$
• Finally, the dot product is distributive over addition of vectors: $\mathbf{\text{u}}\cdot (\mathbf{\text{v}}+\mathbf{\text{w}})=\mathbf{\text{u}}\cdot \mathbf{\text{v}}+\mathbf{\text{u}}\cdot \mathbf{\text{w}}$.
  最後，點積在向量的添加上是分配的： $\mathbf{\text{u}}\cdot (\mathbf{\text{v}}+\mathbf{\text{w}})=\mathbf{\text{u}}\cdot \mathbf{\text{v}}+\mathbf{\text{u}}\cdot \mathbf{\text{w}}$ 。

Calculating the angle between vectors¶
計算 vector 之間的角度¶

One of the many uses of the dot product is to calculate the angle between two non-zero vectors. Looking at the dot product definition, we can deduce the following formula:
點積的眾多用途之一是計算兩個非零向量之間的角度。查看點積定義，我們可以推匯出以下公式：

$\theta =\arccos \left({\displaystyle \frac{\mathbf{\text{u}}\cdot \mathbf{\text{v}}}{\Vert \mathbf{\text{u}}\Vert \times \Vert \mathbf{\text{v}}\Vert }}\right)$

Note that if $\mathbf{\text{u}}\cdot \mathbf{\text{v}}=0$, it follows that $\theta ={\displaystyle \frac{\pi }{4}}$. In other words, if the dot product of two non-null vectors is zero, it means that they are orthogonal.
請注意，如果 ，則 $\mathbf{\text{u}}\cdot \mathbf{\text{v}}=0$ 遵循 $\theta ={\displaystyle \frac{\pi }{4}}$ 。換句話說，如果兩個非 null 向量的點積為零，則表示它們是正交的。

Let's use this formula to calculate the angle between $\mathbf{\text{u}}$ and $\mathbf{\text{v}}$ (in radians):
讓我們用這個公式來計算 和之間的 $\mathbf{\text{u}}$ $\mathbf{\text{v}}$ 角度（以弧度為單位）：

Note: due to small floating point errors, cos_theta may be very slightly outside of the $[-1,1]$ interval, which would make arccos fail. This is why we clipped the value within the range, using NumPy's clip function.
注意：由於浮點誤差較小，cos_theta可能會略微超出 $[-1,1]$ 區間，這會導致 arccos 失敗。這就是為什麼我們使用 NumPy 的 clip 函數在範圍內裁剪值的原因。

Projecting a point onto an axis¶
將點投影到軸上¶

The dot product is also very useful to project points onto an axis. The projection of vector $\mathbf{\text{v}}$ onto $\mathbf{\text{u}}$'s axis is given by this formula:
點積對於將點投影到軸上也非常有用。vector $\mathbf{\text{v}}$ 在 $\mathbf{\text{u}}$ 軸上的投影由以下公式給出：

${\mathbf{\text{proj}}}_{\mathbf{\text{u}}}\mathbf{\text{v}}={\displaystyle \frac{\mathbf{\text{u}}\cdot \mathbf{\text{v}}}{{\Vert \mathbf{\text{u}}\Vert }^2}}\times \mathbf{\text{u}}$

Which is equivalent to: 這相當於：

${\mathbf{\text{proj}}}_{\mathbf{\text{u}}}\mathbf{\text{v}}=(\mathbf{\text{v}}\cdot \widehat{\mathbf{\text{u}}})\times \widehat{\mathbf{\text{u}}}$

Matrices¶ 矩陣¶

A matrix is a rectangular array of scalars (ie. any number: integer, real or complex) arranged in rows and columns, for example:
矩陣是按行和列排列的標量（即任何數位：整數、實數或複數）的矩形陣陣，例如：

$$\left[\begin{array}{ccc}10& 20& 30\\ 40& 50& 60\end{array}\right]$$

You can also think of a matrix as a list of vectors: the previous matrix contains either 2 horizontal 3D vectors or 3 vertical 2D vectors.
您還可以將矩陣視為向量清單：前一個矩陣包含 2 個水準 3D 向量或 3 個垂直 2D 向量。

Matrices are convenient and very efficient to run operations on many vectors at a time. We will also see that they are great at representing and performing linear transformations such rotations, translations and scaling.
矩陣可以方便且非常高效地同時對多個向量運行操作。我們還將看到它們非常擅長表示和執行線性變換，例如旋轉、平移和縮放。

Matrices in python¶
python 中的矩陣¶

In python, a matrix can be represented in various ways. The simplest is just a list of python lists:
在 python 中，矩陣可以用多種方式表示。最簡單的只是一個 python 列表：

A much more efficient way is to use the NumPy library which provides optimized implementations of many matrix operations:
一種更有效的方法是使用 NumPy 庫，它提供了許多矩陣運算的優化實現：

By convention matrices generally have uppercase names, such as $A$.
按照約定，矩陣通常具有大寫名稱，例如 $A$ .

In the rest of this tutorial, we will assume that we are using NumPy arrays (type ndarray) to represent matrices.
在本教程的其餘部分，我們將假設我們使用 NumPy 陣列（類型 ndarray）來表示矩陣。

Size¶ 大小¶

The size of a matrix is defined by its number of rows and number of columns. It is noted $rows\times columns$. For example, the matrix $A$ above is an example of a $2\times 3$ matrix: 2 rows, 3 columns. Caution: a $3\times 2$ matrix would have 3 rows and 2 columns.
矩陣的大小由其行數和列數定義。值得注意的是 $rows\times columns$ 。例如，上面的矩陣 $A$ 是 $2\times 3$ 矩陣的一個示例：2 行，3 列。注意： $3\times 2$ 矩陣將有 3 行和 2 列。

To get a matrix's size in NumPy:
要在 NumPy 中獲取矩陣的大小：

Caution: the size attribute represents the number of elements in the ndarray, not the matrix's size:
注意： size 屬性表示 ndarray 中的元素數，而不是矩陣的大小：

Element indexing¶
元素索引¶

The number located in the $i^{th}$ row, and $j^{th}$ column of a matrix $X$ is sometimes noted $X_{i,j}$ or $X_{ij}$, but there is no standard notation, so people often prefer to explicitely name the elements, like this: "let $X=(x_{i,j}{)}_{1\le i\le m,1\le j\le n}$". This means that $X$ is equal to:
位於矩陣的 $i^{th}$ 和 $j^{th}$ 列中的數字有時會被記為 $X_{i,j}$ 或 $X_{ij}$ ，但沒有標準表示法，因此人們通常更喜歡明確命名元素，例如：「let $X=(x_{i,j}{)}_{1\le i\le m,1\le j\le n}$ $X$ 」。這意味著 $X$ 等於：

$X=\left[\begin{array}{ccccc}{x}_{1,1}& x_{1,2}& x_{1,3}& \cdots & x_{1,n}\\ x_{2,1}& x_{2,2}& x_{2,3}& \cdots & x_{2,n}\\ x_{3,1}& x_{3,2}& x_{3,3}& \cdots & x_{3,n}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ x_{m,1}& x_{m,2}& x_{m,3}& \cdots & x_{m,n}\end{array}\right]$

However in this notebook we will use the $X_{i,j}$ notation, as it matches fairly well NumPy's notation. Note that in math indices generally start at 1, but in programming they usually start at 0. So to access $A_{2,3}$ programmatically, we need to write this:
但是，在這個筆記本中，我們將使用符號， $X_{i,j}$ 因為它與 NumPy 的符號非常匹配。請注意，在數學中，索引通常從 1 開始，但在程式設計中，它們通常從 0 開始。因此，要以程式設計方式訪問 $A_{2,3}$ ，我們需要編寫以下內容：

The $i^{th}$ row vector is sometimes noted $M_i$ or $M_{i,\ast }$, but again there is no standard notation so people often prefer to explicitely define their own names, for example: "let x${}_i$ be the $i^{th}$ row vector of matrix $X$". We will use the $M_{i,\ast }$, for the same reason as above. For example, to access $A_{2,\ast }$ (ie. $A$'s 2nd row vector):
$i^{th}$ 行向量有時會被記為 $M_i$ 或 $M_{i,\ast }$ ，但同樣沒有標準表示法，因此人們通常更喜歡明確定義自己的名稱，例如：“設 x ${}_i$ 為 matrix $X$ 的 $i^{th}$ 行向量 ”。我們將使用 $M_{i,\ast }$ ，原因與上述相同。例如，訪問 $A_{2,\ast }$ （即. $A$ 的第 2 行向量）：

Similarly, the $j^{th}$ column vector is sometimes noted $M^j$ or $M_{\ast ,j}$, but there is no standard notation. We will use $M_{\ast ,j}$. For example, to access $A_{\ast ,3}$ (ie. $A$'s 3rd column vector):
同樣， $j^{th}$ 列向量有時會被記下 $M^j$ 或 $M_{\ast ,j}$ ，但沒有標準表示法。我們將使用 $M_{\ast ,j}$ .例如，訪問 $A_{\ast ,3}$ （即. $A$ 的第 3 列向量）：

Note that the result is actually a one-dimensional NumPy array: there is no such thing as a vertical or horizontal one-dimensional array. If you need to actually represent a row vector as a one-row matrix (ie. a 2D NumPy array), or a column vector as a one-column matrix, then you need to use a slice instead of an integer when accessing the row or column, for example:
請注意，結果實際上是一個一維 NumPy 陣列：沒有垂直或水準一維數位之類的東西。如果你需要實際將行向量表示為單行矩陣（即 2D NumPy 陣列），或將列向量表示為單列矩陣，那麼在訪問行或列時需要使用切片而不是整數，例如：

Square, triangular, diagonal and identity matrices¶
正方形、三角形、對角線和標識矩陣¶

A square matrix is a matrix that has the same number of rows and columns, for example a $3\times 3$ matrix:
方陣是具有相同行數和列數的矩陣，例如 $3\times 3$ 矩陣：

$$\left[\begin{array}{ccc}4& 9& 2\\ 3& 5& 7\\ 8& 1& 6\end{array}\right]$$

An upper triangular matrix is a special kind of square matrix where all the elements below the main diagonal (top-left to bottom-right) are zero, for example:
上三角矩陣是一種特殊的方陣，其中主對角線以下（從左上到右下）的所有元素都為零，例如：

$$\left[\begin{array}{ccc}4& 9& 2\\ 0& 5& 7\\ 0& 0& 6\end{array}\right]$$

Similarly, a lower triangular matrix is a square matrix where all elements above the main diagonal are zero, for example:
同樣，下三角矩陣是一個方陣，其中主對角線上方的所有元素都為零，例如：

$$\left[\begin{array}{ccc}4& 0& 0\\ 3& 5& 0\\ 8& 1& 6\end{array}\right]$$

A triangular matrix is one that is either lower triangular or upper triangular.
三角矩陣是下三角矩陣或上三角矩陣。

A matrix that is both upper and lower triangular is called a diagonal matrix, for example:
同時為上三角矩陣和下三角矩陣的矩陣稱為對角矩陣，例如：

$$\left[\begin{array}{ccc}4& 0& 0\\ 0& 5& 0\\ 0& 0& 6\end{array}\right]$$

You can construct a diagonal matrix using NumPy's diag function:
您可以使用 NumPy 的 diag 函數建構對角矩陣：

If you pass a matrix to the diag function, it will happily extract the diagonal values:
如果您將矩陣傳遞給 diag 函數，它將很高興地提取對角線值：

Finally, the identity matrix of size $n$, noted $I_n$, is a diagonal matrix of size $n\times n$ with $1$'s in the main diagonal, for example $I_3$:
最後，大小 $n$ 為 的單位矩陣 ，記為 $I_n$ ，是大小 $n\times n$ 為 的對角矩陣，主對角線上有 $1$ ，例如 $I_3$ ：

$$\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right]$$

Numpy's eye function returns the identity matrix of the desired size:
Numpy 的 eye 函數傳回所需大小的單位矩陣：

The identity matrix is often noted simply $I$ (instead of $I_n$) when its size is clear given the context. It is called the identity matrix because multiplying a matrix with it leaves the matrix unchanged as we will see below.
當給定上下文時，當單位矩陣的大小很明確時，通常會簡單地 $I$ （而不是 $I_n$ ）注意到單位矩陣。它被稱為單位矩陣，因為將矩陣與它相乘會保持矩陣不變，我們將在下面看到。