vault backup: 2025-03-04 11:17:00

20.01. Programming/numpy/numpy - 同樣順序打亂多個array.md

@@ -0,0 +1,10 @@
+如果多個array的順序有相關性，我們要用同樣的順序來打亂他們，可以用以下方法：
+```python
+array1 = np.array([[1, 1], [2, 2], [3, 3]])
+array2 = np.array([1, 2, 3])
+
+shuffler = np.random.permutation(len(array1))
+array1_shuffled = array1[shuffler]
+array2_shuffled = array2[shuffler]
+```
+

20.01. Programming/numpy/numpy axis 運算.md

@@ -0,0 +1,121 @@
+numpy有很多運算都可以指定axis，例如`x.sum(axis=0)`或是`x.max(axis=0)`之類。
+axis在2軸（像是 `[[1, 2], [3, 4]]`） 可以理解成x方向或是y方向。但是在更多軸的情況下就很難這樣理解了。
+
+我的理解方式是把axis當作「第幾層」。例如`x.sum(axis=0)`就是把「第0層」之下的東西都加起來，例如說有一個array `a`長這樣：
+```python
+array([[[1. , 2. , 3. ],
+        [4. , 5. , 6. ],
+        [7. , 8. , 9. ]],
+
+       [[0.1, 0.2, 0.3],
+        [0.4, 0.5, 0.6],
+        [0.7, 0.8, 0.9]]])
+```
+
+## axis=0
+那麼`np.sum(a, axis=0)`就是把「第0層」之下的東西都加起來，`a`的shape是(2, 3, 3)，所以第0層之下就是**有2個3x3的array**，也就是
+```python
+[[1. , 2. , 3. ],
+ [4. , 5. , 6. ],
+ [7. , 8. , 9. ]]
+```
+與
+```python
+[[0.1, 0.2, 0.3],
+ [0.4, 0.5, 0.6],
+ [0.7, 0.8, 0.9]]
+```
+要加起來也就是：
+```python
+np.array([[1. , 2. , 3. ],
+          [4. , 5. , 6. ],
+          [7. , 8. , 9. ]]) + 
+np.array([[0.1, 0.2, 0.3],
+          [0.4, 0.5, 0.6],
+          [0.7, 0.8, 0.9]])
+```
+答案跟`np.sum(a, axis=0)`是一樣的。
+
+## axis=1
+那麼`np.sum(a, axis=1)`呢？也就是把「第1層」之下的東西都加起來，`a`的shape是(2, 3, 3)，所以「第1層」有2個，分別是
+```python
+[[1. , 2. , 3. ],
+ [4. , 5. , 6. ],
+ [7. , 8. , 9. ]]
+```
+與
+```python
+[[0.1, 0.2, 0.3],
+ [0.4, 0.5, 0.6],
+ [0.7, 0.8, 0.9]]
+```
+這2個各自會產生各自的結果，先看第一個。我們要把「第1層」之下的東西都加起來，「第1層」之下的東西就是：
+```python
+[1. , 2. , 3. ],
+[4. , 5. , 6. ],
+[7. , 8. , 9. ]
+```
+我要把他們加起來，也就是`[1. , 2. , 3. ] + [4. , 5. , 6. ] + [7. , 8. , 9. ] = [12., 15., 18.]`
+
+再看第二個，我們要把「第1層」之下的東西都加起來，「第1層」之下的東西就是：
+```python
+[0.1, 0.2, 0.3],
+[0.4, 0.5, 0.6],
+[0.7, 0.8, 0.9]
+```
+我要把他們加起來，也就是`[0.1, 0.2, 0.3] + [0.4, 0.5, 0.6] + [0.7, 0.8, 0.9] = [1.2, 1.5, 1.8]`
+
+所以`np.sum(a, axis=1)`的答案就是：
+```python
+[[12., 15., 18.],
+ [1.2, 1.5, 1.8]]
+```
+
+## axis=2
+那麼`np.sum(a, axis=2)`呢？也就是把「第2層」之下的東西都加起來，`a`的shape是(2, 3, 3)，所以「第1層」有2個，分別是
+```python
+[[1. , 2. , 3. ],
+ [4. , 5. , 6. ],
+ [7. , 8. , 9. ]]
+```
+與
+```python
+[[0.1, 0.2, 0.3],
+ [0.4, 0.5, 0.6],
+ [0.7, 0.8, 0.9]]
+```
+而這2個第1層又各自有3個的第2層，分別是：
+```python
+[##第0層
+    [##第1層-0
+        [1. , 2. , 3. ]  ##第2層-0 <-- 裡面要加起來
+        [4. , 5. , 6. ]  ##第2層-1 <-- 裡面要加起來
+        [7. , 8. , 9. ]  ##第2層-2 <-- 裡面要加起來
+    ],
+    [##第1層-1
+        [0.1, 0.2, 0.3]  ##第2層-0 <-- 裡面要加起來
+        [0.4, 0.5, 0.6]  ##第2層-1 <-- 裡面要加起來
+        [0.7, 0.8, 0.9]  ##第2層-2 <-- 裡面要加起來
+    ]
+]
+```
+總共有6個，加起來之後就變成：
+```python
+[
+    [
+        [1. , 2. , 3. ] # 1+2+3 = 6
+        [4. , 5. , 6. ] # = 15
+        [7. , 8. , 9. ] # = 24
+    ],
+    [
+        [0.1, 0.2, 0.3] # 0.1+0.2+0.3 = 0.6
+        [0.4, 0.5, 0.6] # = 1.5
+        [0.7, 0.8, 0.9] # = 2.4
+    ]
+]
+```
+所以`np.sum(a, axis=2)`的答案就是：
+```python
+[[ 6. , 15., 24. ],
+ [ 0.6, 1.5, 2.4]]
+```