面試工作的流程

面試工作的流程大致上有：

1. 填寫申請表、上傳簡歷（curriculum vitae, CV），通常建議是一頁簡歷（one-page CV）並且不需要附照片。

2. 能力傾向測驗（online aptitude test），內容通常是與應徵職缺之專業較為無關的測驗，有點像是基礎的語文、數學與邏輯測驗。

3. 人資面試，內容通常會和應徵職缺之專業有相關，但不是太深入，比較深入的焦點會擺在面試候選人對於職缺內容的理解程度、對於團隊的預期、對於公司的認識以及對於公司所屬產業的趨勢與近況。

4. 專業能力面試，內容會和應徵職缺之專業高度相關，會由職缺所屬的主管或資深同事來負責，形式可能包含線上考題、實體測驗卷、口頭面試甚至是專案實作，在這個階段如果表現良好，錄取的可能性就會相當高。在線上考題、實體測驗卷或專案實作中，候選人多半處於被動接收挑戰的處境，基本上就是仰賴基本功與專業素養見招拆招；而在口頭面試的時候，是候選人有機會能夠化被動為主動的難得機會，作品集就會在此時登場，可以透過解釋資料來源、實作過程所遭遇的困難、解決困難的作法以及呈現作品，讓面試官擔任「聆聽」與「提問」的角色，藉此表現自己在工作場合中如何與聽眾進行溝通。

5. 主管面試，過了專業能力面試代表已經被職缺所屬的團隊或部門核可錄取，最後是讓候選人和更高層級的經理人有交流的機會，通常只要表現得隨和，沒有不合適的行為舉止，很多時候這只是聊備一格的會談，保持輕鬆且愉悅的心情，笑容可掬地準備收錄取通知即可。

資料科學專案的組成

資料科學專案實際的形式會以資料夾作為單位，一個專案就是一個資料夾，專案名稱即為資料夾名稱，有的時候資料夾會作為上線部署的來源，因此盡量以小寫英文命名、以底線或者減號作為單字的分隔符，我個人會更偏好用底線做分隔符，原因是在程式語言中減號與物件名稱相鄰的時候（無論中間有無空白），會視為物件的減法運算，而為了避免在這種情況下要進行額外的標註（例如使用跳脫字元 \ 或者 tilt 符號 `）。在這個資料夾裡頭，通常會由下列這幾個檔案、資料夾所組成：

Read more

複合函數

從正規方程式、梯度遞減、羅吉斯迴歸再到深度學習，我們可以描繪出一條機器學習的小徑，讓初學者從完全門外漢到略懂函數近似的技巧與挑戰。在前三者我們所近似的函數 f 都是屬於「非」複合函數，深度學習領域中要透過演算法近似的函數，則是屬於「複合」函數（function composition），而非複合函數與複合函數的差異，也造就了尋找參數最佳化的時候所仰賴技巧的不同。

複合函數：https://en.wikipedia.org/wiki/Function_composition

深度前饋網路

深度學習中最基礎的模型稱為深度前饋網路（deep feedforward neural networks），又稱為多層感知器（multiple layer perceptrons），目標是近似某個複合函數 f，可能由 n 個函數鏈結組成，例如當 n 為 3 的時候，可以表示為：

上標 (1) 就稱為第一層，更常見的名稱是輸入層（input layer），上標 (2) 就稱為第二層，更常見的名稱是隱藏層（hidden layer），至於上標 (3) 就稱為第三層，更常見的名稱是輸出層（output layer）；當 n 為 4 的時候，可以表示為：

這時上標 (1) 稱為輸入層（input layer），上標 (2) 與上標 (3) 就稱為隱藏層（hidden layer），至於上標 (4) 稱為輸出層（output layer），隨著 n 變大，以此類推除了第一層與第 n 層稱為輸入層、輸出層，第二層至第 n-1 層皆稱為隱藏層。

「隱藏」的命名由來

由 n 個函數鏈結組成的函數，其中 n 大於等於 3，意即至少要有一層隱藏層才稱為深度學習，至於為什麼排除了輸入層與輸出層以外的層數被命名為「隱藏」？其命名緣由是因為訓練資料的回饋作用僅止於輸出層，無法影響更之前的層，意即訓練資料在模型訓練階段僅可以回饋到輸出層的參數最適化，中間層數都是由學習演算法決定其近似 f 函數的參數，白話文的說明即是，由於訓練資料中無法觀察到中間層數的輸出，故將其命名為隱藏層。

泛用特徵工程

將函數 f 改為以複合函數的形式去近似有明顯各一個缺點與優點，缺點即是要近似的函數數量不僅增多了（至少有 3 個函數需要近似來合成函數 f，因為 n 必須大於等於 3），也因為這些函數有合成、鏈結關係，需要以連鎖法則處理偏微分的計算，造成計算量比非合成函數來得大；優點則是可以將隱藏層作為非線性轉換來擴充線性、非線性模型的泛用性，就像是為訓練資料提供更多的特徵一般，如此一來深度學習在選擇非線性轉換函數的環節上又比傳統機器學習模型更有彈性且簡單，傳統機器模型必須手動建立非線性轉換函數，例如針對不論是語音辨識或者電腦視覺都以獨立且專門的非線性轉換函數來應用；反觀深度學習的作法則是採用將非線性轉換函數納入了訓練的範疇，在學習演算法中找尋相對良好的非線性轉換函數，以式子表達即為：

意即將原本的特徵矩陣優化成了經過非線性轉換而得的輸出，藉此獲得一個高度通用、適用廣泛情境的特徵矩陣。已經對機器學習理論有相當認識的讀者，可以將隱藏層的作用視為一種在訓練過程中依據深度學習架構設計與活化函數選用而產出的「泛用特徵工程」，它可能是在訓練過程中為訓練資料生成了高次項、交互項、標準化或者是連續值離散化等。

深度學習的函數

定義一個最單純的深度前饋網路，首先需要決定層數與各層的單元數，其中單元數與層數的架構，就會決定到總參數的數量，然後需要選擇用於隱藏層的活化函數（activation functions）最後則是選擇如何運行學習演算法，雖然本質上也是利用梯度遞減的學習演算法，但由於深度前饋網路是一種合成函數的近似，其學習演算法稱為倒傳遞（backpropagation）。

假如我們要利用深度前饋網路來解決 MNIST 手寫數字辨識的問題，該怎麼從零開始思考架構、活化函數與倒傳遞？我們會先在下一次電子報中導讀摘要 Gilbert Strang: The Functions of Deep Learning 再進入實作環節。

第四十五週約維安計畫：深度學習（一）來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、分享🙌、訂閱📨或者留言🙋‍♂️

Share

Subscribe now

Leave a comment

羅吉斯迴歸的成本函數

在約維安計畫：羅吉斯迴歸（上）一文中我們提到了羅吉斯迴歸類別預測模型的定義、交叉熵（cross entropy）成本函數、Sigmoid 函數以及如何運用梯度遞減（gradient descent）學習演算方法求解權重向量。

在這個式子中最重要的一個求解任務就是成本函數 J 關於權重向量的梯度，那麼這個成本函數 J，也就是交叉熵成本函數的偏微該怎麼推導呢？首先我們將成本函數 J 的內容再細寫一次：

仔細檢查成本函數 J 的組成，我們會發現這是一個鏈結函數（chaining function）的結構，內層有對特徵矩陣和權重向量相乘結果應用 Sigmoid 函數，外層則有對 Sigmoid 函數輸出應用對數函數，若是想順利推導其成本函數的梯度，我們可以預期必須具有幾項先備知識：連鎖法則（chain rule）、對數函數微分以及 Sigmoid 函數微分。

連鎖法則

連鎖法則可以用於求解鏈結函數的導數，如果一個鏈結函數 h 是由 g 和 f 兩函數依序作用合成，g 函數先作用，其輸出再成為 f 函數的輸入，那麼 h 函數關於 x 的導數為兩個微分結果的相乘，依序是 h 函數關於 g 函數的微分、g 函數關於 x 的微分。

將連鎖法則應用於成本函數 J 的梯度求解，可以將其寫成兩個偏微分結果的結合，依序是成本函數 J 關於對數函數的偏微分、對數函數關於權重向量的偏微分。接下來我們可以拆開來解這兩個偏微分的部分，最後結合起來得到想要求解的「成本函數 J 關於權重向量的梯度」。

對數函數偏微分

關於對數函數偏微分，先備知識（不另外證明的部分）為：

因此我們可以先將成本函數 J 關於權重向量的偏微分推導為成本函數 J 關於對數函數的偏微分形式：

完成對數函數偏微分的部分，接下來是 Sigmoid 函數偏微分的部分。

Sigmoid 函數偏微分

關於 Sigmoid 函數偏微分，先備知識（不另外證明的部分）為：

先備知識中的第二式運用到微分的除法規則、第四式則運用到了一個巧妙的 +1-1 的技巧。

因此我們可以接著將成本函數 J 關於權重向量的偏微分推導為最終的形式：

我們終於推導出以交叉熵作為成本函數 J 關於權重向量的梯度，最後將羅吉斯迴歸梯度遞減的泛型式表示如下。

以 Numpy 實作羅吉斯迴歸

成功推導出以交叉熵作為成本函數 J 關於權重向量的梯度之後，最後我們寫作一個類別 LogisticRegression，以 Python 與 Numpy 模組實作，在給定適當資料集的特徵矩陣與目標向量，能夠迭代優化隨機生成的權重向量，進而生成 h 函數。

class LogisticRegression:
    def fit(self, X_train, y_train):
        # ...
    def predict(self, X_test):
        # ...

LogisticRegression 類別的使用是以 fit() 方法生成權重向量，並以 predict() 方法生成預測。我們可以將 LogisticRegression 類別應用在 Kaggle 的 Titanic 資料集，藉此來驗證它的可用性。

train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")
X_train = train["Fare"].values.reshape(-1, 1)
y_train = train["Survived"].values
X_test = test["Fare"].values.reshape(-1, 1)
logistic_regression = LogisticRegression()
logistic_regression.fit(X_train, y_train)
y_pred = logistic_regression.predict(X_test)

第四十四週約維安計畫：羅吉斯迴歸來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、分享🙌、訂閱📨或者留言🙋‍♂️

Share

Subscribe now

Leave a comment

約維安計畫學員專區

約維安計畫學員可以點選下列連結複製完整的內容與程式碼到自己的 Google Drive 之中。

Read more

什麼是羅吉斯迴歸

在約維安計畫：梯度遞減一文中我們提到了梯度遞減（gradient descent），這是一種以多次迭代的方式優化權重向量，進而以優化過後的權重向量生成 h 函數的學習演算法（learning algorithm），也是我們在機器學習系列文章中，繼第一個學習演算法正規方程式（normal equations）之後所學會的第二個學習演算法。

第一個學習演算法：正規方程式。

第二個學習演算法：梯度遞減。

在先前介紹這兩個學習演算法的文章中，我們的成本函數（cost function）都是以均方誤差（mean square error）為例，計算均方誤差關於權重向量的偏微分，獲得梯度的值，來回推梯度為零的權重向量解，或者以梯度乘上學習速率（learning rate）來得知在該次迭代中權重向量應該被更新的方向與量值。

那麼當成本函數不是均方誤差的時候呢？均方誤差是迴歸的學習演算方法最為泛用的成本函數，而交叉熵（cross entropy）則是分類的最為泛用的成本函數，羅吉斯迴歸（logistic regression）就是一種基於交叉熵作為成本函數、Sigmoid 函數作為活化函數（activation function）的分類學習演算法，雖然它的命名中有迴歸（regression），但其實是類別預測的模型，而非數值預測的模型。

交叉熵

交叉熵是一種基於對數函數與分類機率所設計而成的成本函數，它利用了在對數函數前面加上一個負號，達成分類學習演算法的核心目的：錯誤分類會造成很大的成本，正確分類會造成很低的成本。

在對應目標向量的第 i 個元素為 0 時，模型若輸出微小的機率 epsilon 表示正確預測，此時負對數函數的值為 -log(1 - epsilon) 接近於零；模型若輸出極高的機率 1 - epsilon 表示錯誤預測，此時負對數函數的值為 -log(epsilon) 接近於無限大。

在對應目標向量的第 i 個元素為 1 時，模型若輸出微小的機率 epsilon 表示錯誤預測，此時負對數函數的值為 -log(epsilon) 接近於無限大；模型若輸出極高的機率 1 - epsilon 表示正確預測，此時負對數函數的值為 -log(1 - epsilon) 接近於零。

藉由這兩個負對數函數的特性，我們可以將它們合而為一，成為交叉熵函數，當我們將 y_i 分別以 0 或 1 帶入時，就可以各自得到原本的兩個負對數函數。

Sigmoid 函數

由於特徵矩陣和權重向量中元素相乘相加的結果是連續值的線性函數，若想將其轉換為機率的輸出，就需要仰賴 Sigmoid 函數，該函數是一個將連續值輸入映射至 [0, 1] 範圍的活化函數，由自然對數的底數 e（Euler’s constant）所組成，也被稱作羅吉斯函數（logistic function）。

Sigmoid 函數在輸入連續值很小（負無限大）的情況下，會得到一個接近於零的輸出；在輸入連續值恰巧等於 1 的情況下，會得到剛好等於 0.5 的輸出；在輸入連續值很大（無限大）的情況下，會得到一個接近於 1 的輸出，因此是一種將連續值輸入轉換為機率值的活化函數。

羅吉斯迴歸

在使用交叉熵作為成本函數、Sigmoid 函數作為活化函數的情況下，我們能夠以梯度遞減的學習演算方法求得權重向量，這便是羅吉斯迴歸的二元分類模型，其命名由來羅吉斯（logistic）就是因為 Sigmoid 函數也被稱為 Logistic 函數的原因。

再透過梯度遞減的學習演算方法求解權重向量。

下一篇文章，我們就要接著推導以交叉熵作為成本函數 J 關於權重向量的梯度，第四十三週約維安計畫：羅吉斯迴歸（上）來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、分享🙌、訂閱📨或者留言🙋‍♂️

Share

Subscribe now

Leave a comment

約維安計畫學員專區

約維安計畫學員可以點選下列連結複製完整的內容與程式碼到自己的 Google Drive 之中。

Read more

什麼是梯度遞減

在約維安計畫：正規方程式一文中我們提到了正規方程式（normal equations），這是面對迴歸的機器學習任務時的函數生成方法，也是我們在機器學習系列文章中所學會的第一個學習演算法（learning algorithm）。在資料集給定特徵矩陣與目標向量，以及運用均方誤差（mean square error）作為效能評估的前提下，我們能夠計算權重向量，進而生成 h 函數。

不過，並非所有前提相同的問題以正規方程式求解權重向量都是最有效率的作法，原因是在正規方程式中，必須要求解轉置特徵矩陣和特徵矩陣相乘後的反矩陣，轉置特徵矩陣的外型為 (n, m)，而特徵矩陣的外型為 (m, n)，兩者相乘之後的矩陣外型為 (n, n)。

求解一個外型為 (n, n) 的反矩陣，標準的時間計算複雜度是大 O 符號 n 的立方 O(n^3)，因此當特徵矩陣的變數增加 10 倍時，所需要的計算時間並不是增加 10 倍，而是增加 1000 倍，為此在因應 n 很大的狀況時，我們會改用第二個學習演算法：梯度遞減（gradient descent）。其中梯度（gradient）指的是在向量對函數的偏微分，對應導數（derivative）指的是純量對函數的偏微分。
梯度遞減指的是，在資料集給定特徵矩陣與目標向量，且效能評估的函數可以做最小化或最大化的前提下，我們能夠以多次迭代的方式優化權重向量，進而以優化過後的權重向量生成 h 函數。其中 w 是隨機生成的權重向量，J 函數是成本函數（cost function），也就是用來進行效能評估的函數，有時也寫做 L 函數即損失函數（loss function），而 epsilon 則是一個正的純量，稱作學習速率（learning rate），是一個決定優化幅度的正數純量。

上圖中的藍色虛線描繪一個成本函數 f，綠色實線描繪該函數的導數，對於 x < 0 的部分導數為負，所以 x 會向右移動；對於 x > 0 的部分導數為正，所以 x 會向左移動；對於 x = 0 的部分導數為零，x 不移動。

效能評估

以均方誤差（mean square error）作為成本函數 J 來當例子，我們可以推導梯度的表示式如下。

因此，當以均方誤差作為成本函數時，我們可以將梯度遞減的泛型式表示如下。

以 Numpy 實作梯度遞減

成功推導出正規方程式之後，最後我們寫作一個類別 GradientDescent，以 Python 與 Numpy 模組實作，在給定適當資料集的特徵矩陣與目標向量，能夠迭代優化隨機生成的權重向量，進而生成 h 函數。實作過程中我們會用到 Numpy 模組的 np.transpose() 或 ndarray 的 T 屬性來生成轉置矩陣、np.dot() 或 ndarray 的 dot() 方法來計算向量與矩陣的相乘。

class GradientDescent:
    def fit(self, X_train, y_train):
        # ...
    def predict(self, X_test):
        # ...

GradientDescent 類別的使用是以 fit() 方法生成權重向量，並以 predict() 方法生成預測。我們可以將 GradientDescent 類別應用在 Kaggle 的 House Prices 資料集，藉此來驗證它的可用性。

train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")
X_train = train["OverallQual"].values.reshape(-1, 1)
y_train = train["SalePrice"].values
X_test = test["OverallQual"].values.reshape(-1, 1)
gradient_descent = GradientDescent()
gradient_descent.fit(X_train, y_train)
y_pred = gradient_descent.predict(X_test)

第四十二週約維安計畫：梯度遞減來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、分享🙌、訂閱📨或者留言🙋‍♂️

Share

Subscribe now

Leave a comment

約維安計畫學員專區

約維安計畫學員可以點選下列連結複製完整的內容與程式碼到自己的 Google Drive 之中。

Read more

什麼是正規方程式

在約維安計畫：機器學習基礎一文中我們提到了常見的機器學習任務，其中一項耳熟能詳的「迴歸」其任務描述是要求電腦程式產生一個函數，這個函數能夠將輸入的資料預測某個數值，輸出的資料為連續的形式。
我們可以將迴歸視為理解機器學習演算法的第一個里程碑，正規方程式（normal equations）則是協助我們達到這個里程碑的學習演算法，也就是面對迴歸的機器學習任務時的函數生成方法。該函數我們暫且以 h 函數作為命名，意即 hypothesis，h 函數的輸入形式為向量，輸出形式為純量。

h 函數由截距項、權重（或稱係數）以及特徵所組合而成，其中截距項、特徵由資料集提供，權重則由機器學習演算法決定。這邊我們觀察到截距項加上權重的個數恰巧比特徵個數多出一個，如果個數相同，就可以化為向量相乘形式，因此可以為截距項配對一個等於 1 的權重。

當輸入 h 函數僅有一個觀測值的特徵，輸入形式為向量、輸出形式為純量；當有多個觀測值的特徵時，輸入形式為矩陣其專有名詞稱為特徵矩陣（feature matrix）、輸出形式為向量。

而正規方程式指的就是，在資料集給定特徵矩陣與目標向量（與模型輸出的預測外型、格式均相同，但是來自於資料集中真實、已實現之數值）的前提下，我們就能夠計算權重向量，進而生成 h 函數。

權重向量

權重向量（weights）是控制模型預測行為的依據，用來決定每個對應的特徵對預測的影響程度。若是第 i 個特徵對應了正權重，則增加此特徵的值會提高預測值，意即對於該特徵與預測為正相關；反之若是第 i 個特徵對應了負權重，則增加此特徵的值會降低預測值，意即對於該特徵與預測為負相關；若是第 i 個特徵的絕對值大，那麼該特徵對於預測的影響力大，反之若是第 i 個特徵的絕對值趨近於零，那麼該特徵對於預測毫無影響力。
透過正規方程式我們可以計算出權重向量生成 h 函數，進而獲得輸入特徵對應輸出預測的模型。正規方程式又是如何推導而得？本文已經將「迴歸」的機器學習任務（task, T）定義得相當細膩：在資料給定特徵矩陣與目標向量的情況下生成 h 函數，該 h 函數能夠輸入特徵對應輸出預測。

效能評估

接著是定義效能評估（performance measure, P），當我們透過 h 函數獲得了預測，可以將其與目標向量進行比對，由於預測與目標向量都屬於連續形式，兩者之間的誤差可以由均方誤差（mean square error）決定。

向量與矩陣形式的計算會比純量運算更加快捷有效率，所以我們將均方誤差改以向量形式表示。

為了讓均方誤差最小，可以求解梯度為零的解，梯度（gradient）指的是在向量對函數的偏微分，對應導數（derivative）指的是純量對函數的偏微分。

至此我們能夠得知正規方程式的求解，源於讓效能評估的均方誤差最小化，進而計算讓權重向量對均方誤差函數的梯度為零的解。

以 Numpy 實作正規方程式

成功推導出正規方程式之後，最後我們寫作一個類別 NormalEquations，以 Python 與 Numpy 模組實作，在給定適當資料集的特徵矩陣與目標向量，能夠生成 h 函數的權重向量。實作過程中我們會用到 Numpy 模組的 np.transpose() 或 ndarray 的 T 屬性來生成轉置矩陣、np.linalg.inv() 來生成反矩陣、np.dot() 或 ndarray 的 dot() 方法來計算向量與矩陣的相乘。

class NormalEquations:
    def fit(self, X_train, y_train):
        # ...
    def predict(self, X_test):
        # ...

NormalEquations 類別的使用是以 fit() 方法生成權重向量，並以 predict() 方法將生成預測。我們可以將 NormalEquations 類別應用在 Kaggle 的 House Prices 資料集，藉此來驗證它的可用性。

train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")
X_train = train["OverallQual"].values.reshape(-1, 1)
y_train = train["SalePrice"].values
X_test = test["OverallQual"].values.reshape(-1, 1)
normal_equations = NormalEquations()
normal_equations.fit(X_train, y_train)
y_pred = normal_equations.predict(X_test)

第四十一週約維安計畫：正規方程式來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️、訂閱📨或者分享🙌

Share

Subscribe now

Leave a comment

約維安計畫學員專區

Read more

機器學習演算法

截至目前為止，我覺得還是沒有其他對機器學習演算法的定義比得上 Tom Mitchell 的版本，更簡短的版本解釋能力不足、篇幅更長的版本不夠精練，在解釋能力與精練程度上，這段話現階段居於各種版本定義之首，Well…it is definitely “In My Humble Opinion.”

A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P if its performance at tasks in T, as measured by P, improves with experience E.

Tom Mitchell

一段具備預測數值、預測類別或挖掘特徵的電腦程式（也就是我們日常俗稱的模型），應該符合「三個要素」、「一個但書」的特性。其中，三個要素依序為經驗（Experience）、任務（Task）與效能評估（Performance measure）；一個但書（Condition）則為隨著歷史資料觀測值數量增加，在其他條件不變前提下模型的表現應該要變得更優秀，也就是預測的誤差降低、挖掘資料特徵的能力提升。

對於 Tom Mitchell 有興趣的讀者，可以觀看他的 Wikipedia 頁面：https://en.wikipedia.org/wiki/Tom_M._Mitchell，或者他在卡內基美隆大學（Carnegie Mellon University, CMU）的頁面：https://www.cs.cmu.edu/~tom。

任務

機器學習演算法的需求、動機源自於軟體工程師在撰寫程式解決現實世界的問題時，碰到了「固定程式」難以解決的問題，因此尋求能夠讓電腦程式基於如人工智慧一般的能力來面對這類型問題，常見的機器學習任務有多種：

• 分類（Classification）：分類任務會要求電腦程式產生一個函數，這個函數能夠將輸入的資料歸屬成為 k 類別中的其中一個，輸出的資料為離散的形式，例如物件辨識、貸款申請核准與否或疾病診斷陰性陽性等。

• 迴歸（Regression）：迴歸任務會要求電腦程式產生一個函數，這個函數能夠將輸入的資料預測某個數值，輸出的資料為連續的形式，例如貸款核准金額、金融商品價格預測或房屋成交價格預測等。

• 轉錄（Transcription）：轉錄任務會要求電腦程式產生一個函數，這個函數能夠將輸入的非結構化特徵（Unstructured features）轉換為離散的文字格式，例如光學字元辨識（Optical Character Recognition, OCR）或語音辨識。

• 機器翻譯（Machine translation）：機器翻譯任務會要求電腦程式產生一個函數，這個函數能夠將輸入語言的文字符號序列轉換成另一種語言的文字符號序列。

• 結構化輸出（Structured output）：結構化輸出任務會要求電腦程式產生一個函數，這個函數能夠將輸入的非結構化特徵轉換為有效、能夠被自然語言理解的文字格式，例如影像標註（Image captioning）、詞性標註。

• 異常偵測（Anomaly detection）：異常偵測任務會要求電腦程式產生一個函數，這個函數能夠將輸入一組事件序列輸出為異常標記，例如信用卡詐欺偵測。

• 合成與抽樣（Synthesis and sampling）：合成與抽樣任務會要求電腦程式產生一個函數，這個函數能夠將輸入的資料輸出特定類型的格式，例如語音合成能夠從提供的文字輸出一段與該文字相符的語音，目前我們在 Medium 看到每一篇英文文章都有語音合成的功能，將文章轉換為有聲書形式。

• 遺漏值填補（Imputation of missing values）：遺漏值填補任務會要求電腦程式產生一個函數，這個函數能夠將輸入的遺漏值資料輸出其預測值。

• 去雜訊（Denoising）：去雜訊任務會要求電腦程式產生一個函數，這個函數能夠將輸入的混雜樣本輸出為預測純淨樣本，或更廣泛地輸出預測條件機率分佈。

• 密度估計（Density estimation）或機率質量函數估計（Probability mass function estimation）：密度估計任務會要求電腦程式產生一個函數，這個函數能夠將輸入的連續資料輸出為機率密度函數，或者將輸入的離散資料輸出為機率質量函數。

效能評估

當電腦程式依照程式設計者（包含軟體工程師、資料科學家或資料分析師等）的要求順利產生了一個函數，下一步自然要針對這個函數是否能達成任務、能達成多少制定衡量的尺度。對於分類、轉錄等任務而言，常用來做效能評估的是準確率（Accuracy）或者誤差率（Error rate），兩者都是以介於 0 與 1 之間的比率計算，因此又稱為預期的 0-1 損失（Expected 0-1 loss），本質上準確率與誤差率是相同的概念，前者是正面表列而後者是負面表列，如此而已。

對於迴歸、密度估計等任務而言，常用來做效能評估的則是平均平方誤差（Mean squared Error, MSE）或者平均對數機率。

機器學習演算法的效能評估著重在「先前沒有遇過」的資料，因此作為效能評估時所使用的測試資料集（Test data）跟訓練機器學習演算法的訓練資料集（Train data）是分開的。效能評估的概念看似簡單、直觀，但是在評估的過程常會遭遇到許多需要抉擇的場景，例如異常偵測任務面對的輸出分佈有極大的落差，是否能夠使用與輸出分佈相對均勻的分類任務同樣的效能評估度量方式？

經驗

機器學習演算法大致上分為非監督式（Unsupervised）或監督式（Supervised），兩者的差異就在於訓練過程中所使用的訓練資料集類型之不同，資料集（Dataset）是許多樣本的集合，而樣本也稱為資料點（Data points）。

年代最久遠的資料集之一是家喻戶曉的鳶尾花（Iris dataset），由 150 株鳶尾花不同部位的數值測量集合而成作為特徵，包含三種不同的物種：Setosa、Versicolor 與 Virginica 集合而成作為目標。

from sklearn.datasets import load_iris

iris = load_iris()
print(iris.data)
print(iris.target)
print(iris.feature_names)
print(iris.target_names)

描述資料及的常見方法是使用設計矩陣（Design matrix），每列對應不同特徵、每欄含有不同樣本的矩陣，例如鳶尾花資料集包含 150 個樣本，每個樣本有四個特徵，因此我們就可以描述一個設計矩陣來表示該資料集。

print(iris.data.shape)

然而若要將資料集描述為設計矩陣，必須將每個樣本都描述成相同長度的向量，這在實務上並非一件容易的事情，例如資料集是不同長、寬、解析度的影像，就不能以相同長度的向量描述，必須要改描述為含有 m 個元素的集合。

非監督式學習演算法涵蓋資料集的特徵部分，而監督式學習則涵蓋資料集的特徵與目標部分。具體來說，非監督式學習演算法試圖在觀測隨機向量 x 之後，學習其中的機率分佈 p(x)。

而監督式學習演算法則試圖在觀測隨機向量 x 以及其對應向量 y 之後，學習透過估計 p(y | x) 從而達成由 x 預測 y。

傳統上，機器學習領域的人們將迴歸、分類與結構化輸出歸納為監督式學習；將密度估計或機率質量函數估計歸納為非監督式學習。此外，也有其他變異型的學習演算法，例如在半監督式學習（Semi-supervised learning）某些樣本涵蓋目標、其他樣本則沒有涵蓋。

第四十週約維安計畫：機器學習基礎來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️、訂閱📨或者分享🙌

Share

Subscribe now

Leave a comment

約維安計畫學員專區

約維安計畫學員可以點選下列連結將本篇文章完整的 Google Colab 複製到自己的 Google Drive 之中。

Read more

中選會選舉資料

經歷第三十八週的約維安計畫：中選會選舉資料操作處理，我們手邊已經取得整齊格式（Tidy format）資料：

• president.csv

• legislator.csv

• party_legislator.csv

• polling_place.csv

在這週我們將運用關聯式資料庫的重要觀念：正規化（Normalization）進一步將整齊格式資料轉換為正規化的資料格式。

何謂正規化

資料庫的資料儲存模式非常多元，包含關聯式、文件式、網絡式或者鍵值式等，其中基於關聯式模型（Relation model）所建立的就稱為關聯式資料庫。建立關聯式資料庫的過程中必須要仰賴的其中一個技巧與觀念是正規化（Normalization）。

簡而言之，正規化就是將原始資料轉換為符合正規化格式（Normal Form, NF）的過程。正規化格式是一種有順序性的資料描述樣態，所以在正規化格式前面還會再加上由 1 起始的整數作為前綴字。

正規化格式

目前主流的正規化格式前綴整數從 1 起始至 3，就稱為第一正規化（First Normal Form, 1NF）、第二正規化（Second Normal Form, 2NF）以及第三正規化（Third Normal Form, 3NF）。

要求更多、更為進階與嚴謹的正規化格式其命名前綴字準則就有所調整，例如介於第三和第四正規化格式之間有 Elementary Key Normal Form, EKNF、Boyce–Codd Normal Form, BCNF；介於第四和第五正規化格式之間有 Essential Tuple Normal Form；介於第五和第六正規化格式之間有 Domain-Key Normal Form。

接著我們解釋主流的正規化格式，即第一正規化格式至第三正規化格式其定義與要件：

第一正規化（First Normal Form, 1NF）：每一個由列欄對應的儲存格中都要有資料，也只能有一份資料；每一列資料必須要對應獨一且不重複的識別整數，即流水編號或稱主鍵。例如在整齊格式資料中，每一筆資料都是候選人在一個行政區的一個投票所的得票數。

第二正規化（Second Normal Form, 2NF）：資料必須先符合第一正規化格式，並進一步消除部分相依性（Functionally dependent）。部分相依性聽起來非常抽象，我們必須舉例說明，例如在整齊格式資料中，我們將 county、town、village 與 polling_place 提取出來成為 districts 資料表；或者將 party 提取出來成為 parties 資料表，以及將 candidate 提取出來成為 candidates 資料表，簡而言之，消除部分相依性就是將資料個體獨立出來，進而成為主要的父母資料表（Parent Tables）。

第三正規化（Third Normal Form, 3NF）：資料必須先符合第二正規化格式，並進一步消除遞移相依性（Transitive dependency）。遞移相依性同樣聽起來非常抽象，我們必須舉例說明，例如在 polling_places 資料表中，我們將原本資料中的「投票數」欄位移除，因為投票數可以透過有效票數加上無效票數計算而得；又或者我們將原本資料中的「已領未投票數」欄位移除，因為已領未投票數可以透過發出票數減去頭票數計算而得。簡而言之，消除遞移相依性就是將可以透過衍生計算而得的欄位移除，進而讓資料表更為精煉簡潔。

完成中選會選舉資料正規化之後，第三十九週約維安計畫：中選會選舉資料正規化來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️、訂閱📨或者分享🙌

Leave a comment

Subscribe now

Share

約維安計畫學員專區

約維安計畫學員可以點選下列連結取得本篇文章的正規化格式資料。

Read more

中選會選舉資料

經歷第三十六週的約維安計畫：基礎的資料處理技法以及第三十七週的約維安計畫：進階的資料處理技法之後，在這週我們將綜合使用這些基礎與進階的資料處理技法，來面對真實世界的資料：2024-01-13 的台灣總統、立法委員投票所明細資料，從中選會的官網可以下載第 16 任總統副總統選舉以第 11 屆立法委員選舉的「各投票所得票明細及概況」。

• 第 16 任總統副總統選舉

• 第 11 屆立法委員選舉

我們所下載的原始資料是「下載各項統計表」中的「各投票所得票明細及概況（Excel 檔，ZIP 壓縮）」，解壓縮之後可以看到裡面的 Excel 活頁簿檔案大致是這樣的外觀。

待處理的部分

從 Excel 活頁簿檔案中我們可以看到原始資料中存在下列問題：

• 合併儲存格與空白儲存格，會導致載入後有遺漏值。

• 總計、小計與明細共存，會導致在應用時有重複計算之虞。

• 候選人號次、候選人姓名與政黨資料儲存在欄位名稱之中，不方便使用。

在載入活頁簿檔案中的每一張試算表時，我們可以透過相同的處理步驟來使得資料成為整齊的格式：

1. 將位於倒數八欄的投票所資料獨立出來整理。

2. 載入時以 skiprows 參數略過特定的列數解決合併儲存格的問題。

3. 利用 Series 的 fillna() 方法填補遺漏值。

4. 利用 DataFrame 的 dropna() 方法刪除總計與小計的列數。

5. 利用 pd.melt() 函數將候選人號次、候選人姓名與政黨資料轉置到資料列中。

由於這些處理步驟會應用到每一個載入的試算表，所以我們應該要寫作方便重複使用的函數組織程式碼。

函數的規劃與執行流程

整齊格式的資料會針對不同的選舉類型而有所差異，因此會有三個函數：

1. 總統副總統選舉：tidy_president_dataframes() 函數。

2. 區域立法委員選舉：tidy_legislator_dataframes() 函數。

3. 不分區立法委員選舉：tidy_party_legislator_dataframes() 函數。

中選會將每個選舉類型的資料都提供至投票所層級，投票所的資料加總後為村鄰里，村鄰里的資料加總後為鄉鎮行政區，鄉鎮行政區的資料加總後為縣市，因此在資料的彙整部分就是將台灣 22 個縣市垂直合併，對應選舉類型同樣有三個函數：

1. 總統副總統選舉：concat_president_dataframes() 函數。

2. 立法委員選舉：concat_legislator_dataframes() 函數。

3. 投票所資訊：concat_office_dataframes() 函數。

在執行流程的規劃上，會由垂直合併的函數（有 concat_ 前綴字）去執行原始資料的載入，並呼叫處理資料的函數（有 tidy_ 前綴字）將資料清理成為整齊格式。

def tidy_president_dataframes():
    ...
    return candidate_df, office_df

def tidy_legislator_dataframes():
    ...
    return candidate_df, office_df

def tidy_party_legislator_dataframes():
    ...
    return candidate_df, office_df

def concat_president_dataframes():
    ...
    return concatenated_president_df, concatenated_office_df

def concat_legislator_dataframes():
    ...
    return concatenated_legislator_df, concatenated_party_legislator_df, concatenated_office_df

def concat_office_dataframes():
    ...
    return concatenated_office_df

president_df, president_office_df = concat_president_dataframes()
legislator_df, party_legislator_df, legislator_office_df = concat_legislator_dataframes()
office_df = concat_office_dataframes(president_office_df, legislator_office_df)

函數執行後的成果

垂直合併的函數（有 concat_ 前綴字）執行完畢後，我們可以檢視四個整齊格式的資料框，分別是總統副總統：

立法委員（含區域、山地與平地）：

不分區立法委員（即政黨票）：

投票所資訊（含總統副總統、立法委員與不分區立法委員）：

類別的規劃

確認函數的規劃、執行流程以及成果無誤之後，我們可以更進一步將程式碼組織成為類別 TidyTaiwanElection2024Data，把前述函數整理為物件方法。

class TidyTaiwanElection2024Data:
    def __init__(self):
        ...
    def tidy_president_dataframes(self):
        ...
    def tidy_legislator_dataframes(self):
        ...
    def tidy_party_legislator_dataframes(self):
        ...
    def concat_president_dataframes(self):
        ...
    def concat_legislator_dataframes(self):
        ...
    def get_tidy_dataframes(self):
        ...
    def get_tidy_csv_files(self):
        ...

作為類別之後，就可以再用一個獨立的模組封裝，未來打算重新運行的時候，就可以將類別由模組載入到工作環境，直接呼叫物件方法即可得到整齊格式的資料框與 CSV 檔案。

from tidy_taiwan_election_2024_data import TidyTaiwanElection2024Data

tidy_twn_election_2024_data = TidyTaiwanElection2024Data()
tidy_dataframes = tidy_twn_election_2024_data.get_tidy_dataframes()
tidy_twn_election_2024_data.get_tidy_csv_files()
tidy_dataframes["president"]
tidy_dataframes["legislator"]
tidy_dataframes["party_legislator"]
tidy_dataframes["polling_place"]

完成中選會選舉資料操作處理之後，我們就能夠在下次的電子報中介紹如何整合正規化到整集格式資料之上。第三十八週約維安計畫：中選會選舉資料操作處理來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️、訂閱📨或者分享🙌

Leave a comment

Subscribe now

Share

約維安計畫學員專區

約維安計畫學員可以點選下列連結取得本篇文章完整的程式碼與整齊格式資料。

Read more

進階的資料處理技法一覽

繼第三十六週的約維安計畫：基礎的資料處理技法之後，接著要從基礎邁向進階，具體來說，我們將六種處理方法歸類在「進階」部分，分別是：

1. 定位資料。

2. 衍生計算欄位。

3. 處理遺漏值。

4. 處理文字欄位。

5. 轉置資料。

6. 合併資料。

接著我們會分六個小段落示範上述技法，為了能夠示範上述這些進階資料處理，我們先載入兩個儲存在工作目錄中的逗號分隔值檔案 UID_ISO_FIPS_LookUp_Table.csv 與 time_series_covid19_confirmed_global.csv。

lookup_table = pd.read_csv("UID_ISO_FIPS_LookUp_Table.csv")
time_series_confirmed = pd.read_csv("time_series_covid19_confirmed_global.csv")
print(lookup_table)
print(time_series_confirmed)

定位資料

定位資料的方式有兩種，第一種是透過資料的列索引、欄索引名稱來取得資料，使用 df.loc[row_index, column_index] 語法（loc 是 location 的縮寫）。

lookup_table.set_index("Combined_Key").loc["Taiwan*", ["Lat", "Long_", "Population"]]

第二種是透過資料的列相對位置、欄相對位置來取得資料，使用 df.iloc[row_number, column_number] 語法（iloc 是 integer location 的縮寫）。

lookup_table.iloc[782, [8, 9, 11]] 

衍生計算欄位

我們可以使用 Series 的 map() 方法來衍生計算欄位，map() 方法接受兩種輸入形式，第一種是輸入資料結構 dict，衍生計算的邏輯就是從 dict 中的 key 對應成 value。

map_dict = {
    "Taiwan*": "Taiwan"
}
time_series_confirmed["Country/Region"].map(map_dict)[249]

第二種是輸入函數，通常會以 lambda 匿名函數的形式寫作，衍生計算的邏輯就是從 lambda 敘述的輸入對應成輸出。

lookup_table["Combined_Key"] = lookup_table["Combined_Key"].map(lambda x: x.replace("*", "") if "*" in x else x)
lookup_table["Country_Region"] = lookup_table["Country_Region"].map(lambda x: x.replace("*", "") if "*" in x else x)
time_series_confirmed["Country/Region"] = time_series_confirmed["Country/Region"].map(lambda x: x.replace("*", "") if "*" in x else x)
lookup_table[lookup_table["Combined_Key"] == "Taiwan"]

處理遺漏值

面對資料中的遺漏值，我們可以使用 Series 的 isnull() 方法來判斷該資料值是否為遺漏值，輸出的 Series 由布林組成，長度和原始輸入的 Series 相同，並能夠進一步利用布林的天性（False 為整數 0、True 為整數 1）加總輸出的 Series，藉此暸解原始輸入的 Series 共有幾個遺漏值。

print(lookup_table["Province_State"].isnull())
print(lookup_table["Province_State"].isnull().sum())

若是希望判斷「非遺漏值」改採負面表列，Series 亦有對應的 notnull() 方法，或者可以使用 Series 的 NOT 運算符「~」將資料中的布林反轉（Negate）。

print(lookup_table["Province_State"].notnull())
print(~lookup_table["Province_State"].isnull())

判斷遺漏值的存在與否之後，我們可以從三種後續處理方式選擇，一是不對遺漏值做處理，沒錯你並沒有看錯，知道遺漏值存在於資料之中並在專案中與它共存不是罕見的做法；二是使用 Series 與 DataFrame 的 dropna() 方法來刪除遺漏值或者遺漏值存在的列、遺漏值存在的欄。

print(lookup_table["Province_State"].dropna())
print(lookup_table.dropna())

三是使用 Series 與 DataFrame 的 fillna() 方法將遺漏值以指定的常數或參數取代。

lookup_table["Province_State"].fillna("No Province State Data")

處理文字欄位

面對資料中的文字欄位，我們可以使用 Series 底下的 str 小模組中的各種文字處理方法，例如 str.capitalize() 能夠將英文轉換為大寫開頭的格式。

lookup_table["Country_Region"].str.capitalize()

而 str.casefold() 則能夠將英文轉換為全小寫的格式。

lookup_table["Country_Region"].str.casefold()

Series 底下的 str 小模組有眾多的方法可以使用，族繁不及備載，直接查找 Series 的方法文件是最完整便捷的：https://pandas.pydata.org/docs/reference/series.html#string-handling

轉置資料

我們可以使用 Pandas 模組的 melt() 函數將寬格式的資料轉換為長格式。

id_variables = ["Province/State", "Country/Region", "Lat", "Long"]
time_series_confirmed_long = pd.melt(time_series_confirmed, 
                                     id_vars=id_variables,
                                     var_name="date",
                                     value_name="cumulative_confirmed"
                                    )
time_series_confirmed_long

也可以使用資料框的 pivot() 方法將長格式的資料轉換為寬格式。

time_series_confirmed_wide = time_series_confirmed_long.pivot(columns="date",
                                 index=id_variables,
                                 values="cumulative_confirmed"
                                ).reset_index()
time_series_confirmed_wide = time_series_confirmed_wide.rename_axis(None, axis=1)
time_series_confirmed_wide

關於資料的寬格式與長格式背景知識，推薦可以閱讀維基百科的頁面：https://en.wikipedia.org/wiki/Wide_and_narrow_data

合併資料

合併資料的方式分為兩種，第一種是單純的垂直與水平合併，第二種則是根據相同的欄位或列索引水平合併。我們可以使用 Pandas 模組的 concat() 函數進行單純的垂直與水平合併。

print(pd.concat((lookup_table["iso2"], lookup_table["iso3"]), axis=0))
print(pd.concat((lookup_table[["iso2"]], lookup_table[["iso3"]]), axis=1))

如果要根據相同的欄位進行水平合併，我們可以使用 Pandas 模組的 merge() 函數指定對應的欄位與合併參數，預設合併參數為內部連結（Inner join）。

time_series_confirmed_long = time_series_confirmed_long[time_series_confirmed_long["Province/State"].isna()]
lookup_table = lookup_table[["iso2", "iso3", "Country_Region"]]
pd.merge(time_series_confirmed_long, lookup_table,
         left_on="Country/Region", right_on="Country_Region")

如果要根據相同的列索引進行水平合併，我們可以使用資料框物件的 join() 方法指定合併參數，預設合併參數為左外部連結（ Left outer-join）。

time_series_confirmed_long = time_series_confirmed_long.set_index("Country/Region")
lookup_table = lookup_table.set_index("Country_Region")
time_series_confirmed_long.join(lookup_table)

關於資料的連結背景知識，推薦可以閱讀：

1. 約維安計畫：SQL 的進階查詢（第十週）

2. 維基百科的頁面：https://en.wikipedia.org/wiki/Join_(SQL)

掌握進階的資料操作技巧之後，我們就能夠在下次的電子報中介紹如何應用資料操作技巧彙整中選會選舉資料庫。第三十七週約維安計畫：進階的資料處理技法來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️、訂閱📨或者分享🙌

Subscribe now

Share

Leave a comment

約維安計畫學員專區

約維安計畫學員可以點選下列連結將本篇文章完整的 Google Colab 複製到自己的 Google Drive 之中：

Read more

資料科學的應用場景

根據 Grolemund, G., & Wickham, H. (2017). R for Data Science. O’Reilly Media. 資料科學的應用場景與工具需求包含六個項目，分別是：

1. Import 資料載入。

2. Tidy 資料清理。

3. Transform 資料轉換。

4. Visualize 視覺化。

5. Model 模型。

6. Communicate 溝通。

其中 Import 資料載入、Tidy 資料清理加上 Transform 資料轉換又被合稱為 Data Wrangling，至於何謂 Wrangling？這是一種源自美國拓荒時期，於美國中西部生活的牛仔在圈趕牛羊馬時候所使用的繩索技巧，這也是有一個牛仔褲品牌叫做 Wrangler 的起源，現今多數的讀者可能已經沒有再看過以牛仔生活為主題的好萊塢電影，不過必定看過 DC Comics 極受歡迎的神力女超人（Wonder Woman）使用真理之索（The Lasso of Truth）的英姿，這個動作就是 Wrangle。

基礎的資料處理技法一覽

基礎的資料處理技法就如同結構化查詢語言 SQL 對關聯式資料庫資料表的資料操作保留字，像是：

• 檢視資料。

• SELECT 選擇欄位。

• WHERE 篩選觀測值。

• ORDER BY 排序資料。

• GROUP BY 分組聚合。

為了能夠示範上述這幾項基礎資料處理技法，我們先載入一個儲存在工作目錄中逗號分隔值檔案 movies.csv。

movies = pd.read_csv("movies.csv")

檢視資料

我們可以使用 DataFrame 類別所建立實例的四個屬性檢視資料：

1. shape 屬性：檢視外型。

2. dtypes 屬性：檢視各欄位的資料類別。

3. index 屬性：檢視每個觀測值對應的列索引（Row-index）。

4. columns 屬性：檢視每個變數對應的欄索引（Column-index）。

print(movies.shape)
print(movies.dtypes)
print(movies.index)
print(movies.columns)

除了以上述四個屬性檢視資料， 也能夠使用 DataFrame 類別所建立實例的四個方法檢視資料：

1. head() 方法：回傳前 n 列觀測值。

2. tail() 方法：回傳後 n 列觀測值。

3. describe() 方法：回傳數值類別欄位的描述性統計，包含計數、最小值、25 分位數、中位數、平均數、75 分位數與最大值。

4. info() 方法：回傳資料的詳細資訊，包含外型、資料類別與欄位名稱等。

print(movies.head())
print(movies.tail())
print(movies.describe())
print(movies.info())

選擇欄位

透過指定欄位名稱從資料中選擇欄位成為一個 Series。

print(type(movies["title"]))
print(movies["title"])

透過以 list 包裝多個欄位名稱從資料中選擇欄位成為一個 DataFrame。

print(type(movies[["title", "release_year", "rating"]]))
print(movies[["title", "release_year", "rating"]])

篩選觀測值

透過關係運算符生成一個由布林值組合而成的 Series。

print(movies["release_year"] >= 2020)

再藉由前面生成的 Series 從資料中篩選出對應布林值為 True 的列數。

print(movies[movies["release_year"] >= 2020])

排序資料

使用 DataFrame 類別所建立實例的 sort_values() 方法依據欄位的大小遞增、遞減排序。

print(movies.sort_values("release_year"))
print(movies.sort_values("release_year", ascending=False))

使用 DataFrame 類別所建立實例的 sort_index() 方法依據列索引（Row-index）遞增、遞減排序。

print(movies.sort_index())
print(movies.sort_index(ascending=False))

分組聚合

選擇欄位並直接使用 Series 類別所建立實例的聚合方法，例如 sum()、min()、mean()、max() 或 count() 等獲得指定欄位的聚合函數計算結果。

print(movies["rating"].mean())

使用 DataFrame 類別所建立實例的 groupby() 方法對指定欄位取獨一值且排序，然後選擇欄位並使用聚合方法，獲得指定欄位的分組聚合計算結果。

print(movies.groupby("release_year")["rating"].mean())

掌握基礎的資料操作技巧之後，我們就能夠在下次的電子報中介紹進階的資料操作技巧。第三十六週約維安計畫：基礎的資料處理技法 來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️、訂閱📨或者分享🙌

Leave a comment

Subscribe now

Share

約維安計畫學員專區

約維安計畫學員可以點選下列連結將本篇文章完整的 Google Colab 複製到自己的 Google Drive 之中：

Read more

Pandas 與熊貓的關係

在 Pandas 模組問世以前，Python 缺少一個與 Excel 試算表、R data.frame、SAS Datasets 或 Matlab table 功能相似的資料結構，Pandas 作者 Wes McKinney 認為表格式資料（或稱有標籤的二維陣列 Labeled two-dimensional arrays）是 Python 在資料科學上的最後一塊拼圖，因此他結合了 Python 原生資料結構 tuple 與 set 的特性，創造出 Index 類別，並進一步將 Index 類別整合了 NumPy 模組的 ndarray 類別，創造出 Series 類別與 DataFrame 類別，其中 Series 類別是在一維陣列加上一組標籤、DataFrame 類別是在二維陣列加上兩組標籤。

（沒什麼用的冷知識）在更早期的 Pandas 版本中，還有 Panel 類別是在三維陣列加上三組標籤，因此 Panel、DataFrame 與 Series 取開頭的數個英文字母結合，恰巧就是 Pandas，有此一說這是模組命名緣由，因此 Pandas 與熊貓的關係可以說是八竿子打不著，不過 Panel 類別很快地被棄用（Deprecated），因此現今 Pandas 主要的三個類別為 Index、Series 與 DataFrame。

安裝與載入 Pandas

Pandas 的安裝可以透過 pip 或者 conda，如果讀者的 Python 是從 Python.org 下載的就直接透過 pip 安裝，假如是約維安計畫的成員，Python 應該是 Miniconda 版本，那麼建議可以透過 conda 安裝1。

$ pip install pandas==MAJOR.MINOR.PATCH
$ conda install pandas==MAJOR.MINOR.PATCH

如果希望從既有的 Pandas 版本更新升級，可以在 install 指令之後加上 -U 或 --update-deps 參數。

$ pip install -U pandas==MAJOR.MINOR.PATCH
$ conda install -c conda-forge --update-deps pandas==MAJOR.MINOR.PATCH

官方文件建議載入模組的所有功能並且縮寫為 pd。

import pandas as pd

利用兩個模組內建屬性檢視 Pandas 的安裝版本與路徑。

print(pd.__version__)
print(pd.__file__)

怎樣學好 Pandas

學好 Pandas 的關鍵是理解其核心的三個主要類別以及它的根基類別 ndarray，瞭解四個類別彼此之間的關係，就能掌握 Pandas 入門與進階的技巧。

• NumPy 的 ndarray 類別是一種可以進行向量化運算的多維度陣列。

• Pandas 的 Index 類別是一種結合了 Python 原生資料結構 tuple 與 set 特性的一維資料結構。

• Pandas 的 Series 類別是在一維 ndarray 上添加一組 Index 類別的資料結構。

• Pandas 的 DataFrame 類別是在二維 ndarray 上添加兩組 Index 類別的資料結構，也可以想成數個 Series 類別共享相同的 Index 類別。

如何創造 Index

以 Index 類別轉換一維資料結構創造 Index。

primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
prime_indices = pd.Index(primes)
print(prime_indices)
print(type(prime_indices))

Index 類別具備了 Python 原生資料結構 tuple 與 set 特性，我們首先觀察它的 tuple 特性：不可更動（Immutable）。

try:
    prime_indices[-1] = 31
except TypeError as e:
    print(e)

接著我們再觀察它的 set 特性：集合運算（Set operation）。

odds = range(1, 30, 2)
odd_indices = pd.Index(odds)
print(prime_indices.intersection(odd_indices))
print(prime_indices.union(odd_indices))
print(prime_indices.symmetric_difference(odd_indices))
print(prime_indices.difference(odd_indices))
print(odd_indices.difference(prime_indices))

如何創造 Series

以 Series 類別轉換一維資料結構創造 Series。

prime_series = pd.Series(primes)
print(prime_series)
print(type(prime_series))

我們首先觀察 Series 是在一維 ndarray 上添加一組 Index 類別的特性。

print(type(prime_series.index))
print(type(prime_series.values))

建立 Series 的時候，我們可以選擇自訂其添加的 Index 類別，預設是使用從零開始的數列。

prime_series = pd.Series(primes, index=range(1, 11))
print(prime_series)
print(prime_series.index)

由於 Series 的組成中有一個 ndarray，在操作上具備了所有 ndarray 特性，包含向量化運算、華麗索引（Fancy indexing）以及布林索引（Boolean indexing）。

print(prime_series**2) # Vectorization
print(prime_series[[0, 1, 9]]) # Fancy indexing
print(prime_series[prime_series >= 10]) # Boolean indexing

如何創造 DataFrame

以 DataFrame 類別轉換二維資料結構成為 DataFrame，由於 DataFrame 是在二維 ndarray 上添加兩組 Index 類別的資料結構，在建立的時候我們能夠選擇以欄為單位（Column-wise）或者以列為單位（Row-wise）兩種輸入資料的方式。

首先以欄為單位輸入資料建立 DataFrame。

movie_df = pd.DataFrame()
movie_df["title"] = ["The Shawshank Redemption", "The Dark Knight", "Schindler's List", "Forrest Gump", "Inception"]
movie_df["imdb_rating"] = [9.3, 9.0, 8.9, 8.8, 8.7]
print(type(movie_df))
movie_df

亦可以列為單位輸入資料建立 DataFrame，利用 Python 原生資料結構 list 去結合多組鍵（Key）都相同的 dict。

movie_list = [
    {"title": "The Shawshank Redemption", "imdb_rating": 9.3},
    {"title": "The Dark Knight", "imdb_rating": 9.0},
    {"title": "Schindler's List", "imdb_rating": 8.9},
    {"title": "Forrest Gump", "imdb_rating": 8.8},
    {"title": "Inception", "imdb_rating": 8.7}
]
movie_df = pd.DataFrame(movie_list)
print(type(movie_df))
movie_df

我們可以觀察到 DataFrame 是在二維 ndarray 上添加兩組 Index 類別的特性。

print(type(movie_df.values))
print(type(movie_df.index))
print(type(movie_df.columns))

入門 Pandas 之後，我們就能夠在下次的電子報中基礎的資料框操作技巧。第三十五週約維安計畫：Pandas 來到尾聲，希望您也和我一樣期待下一篇文章。對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

Subscribe now

Share

約維安計畫學員專區

Read more

科學計算語言的定義

在「約維安計畫：NumPy」我們認識了 NumPy 模組給予的 ndarray 資料結構，儲存同質資料的 n 維數值陣列提供了與 Python 內建資料結構截然不同的功能面向，前者專注於計算效率、後者則著重於儲存彈性。事實上 NumPy 模組被命名為 Numeric Python(or Numerical Python) 就意味著這是一個位 Python 實踐數值計算的模組，也是科學計算的入門磚，簡而言之，假使我們提出一個問題：究竟是什麼原因能夠讓 Python 從「泛用程式語言」搖身一變為「科學計算語言」呢？答案呼之欲出：NumPy 模組。

看到這裡讀者不免感到納悶，怎麼說 Python 不是「科學計算語言」呢？Python 不是數據分析、資料科學與機器學習的首選程式語言嗎？這時我們應該要探究「科學計算語言」的廣義或嚴格定義：

廣義而言，科學計算語言指的是被多數科學研究者用於計算、數學或科學程式語言，因此，C/C++ 和 Python 可以被認為是廣義的科學計算語言。

嚴格定義而言，科學計算語言是為數學公式計算以及矩陣計算而設計、優化的程式語言，這類型的語言不僅要具備能夠相關的模組與套件，還要具備數學與科學計算的語法，例如，C/C++ 和 Python 都沒有內建的矩陣資料結構類別，亦沒有內建的矩陣運算函數、運算符號，這些功能必須仰賴標準或者第三方模組與套件提供。因此在嚴格定義下 C/C++ 和 Python 並不是科學計算語言，符合嚴格定義的科學計算語言包括 ALGOL、APL、Fortran、J、Julia、Maple、MATLAB 和 R。

來源：https://en.wikipedia.org/wiki/Scientific_programming_language

如何關聯 ndarray 與數學

ndarray 資料結構類型的設計和數學對待資料維度的概念一致，在數學上我們有純量、向量、矩陣與張量分別去描述零維、一維、二維與 n 維的資料，在 ndarray 的建立上，同樣也有零維陣列、一維陣列、二維陣列與 n 維陣列，我們可以用一張示意圖來暸解資料維度：

矩陣運算

矩陣是一個由 m 列（row）n 欄（column）元素所組成的二維陣列，其中一個重要用途是解線性方程組，也常見於數值計算、統計分析與電腦科學等，在 NumPy 模組中我們就用二維的 ndarray 來建立與操作矩陣，因此像是列向量（row-vector）或者欄向量（column-vector）雖然在命名中是向量，我們仍會以外型 (1, n) 或者 (m, 1) 的二維陣列來對應，藉此確保維度的一致性。

u = np.array([5, 6, 7, 8]).reshape(-1, 1)
v = np.array([5, 6, 7, 8]).reshape(-1, 1)

ndarray 與 list 的其中一個差異處就在於元素對應運算（Element-wise），有時亦稱為向量化運算（Vectorization），我們可以讓 ndarray 和一個純量直接運算。

print(u * 5)
print(v * 6)

常見的矩陣處理技巧為轉置（Transpose），能夠將外型 (m, n) 的矩陣轉換為外型 (n, m)，這樣能使得位於 m 列 n 欄的元素，更動到 n 列 m 欄的位置。我們可以使用 np.transpose() 函數或者 ndarray 的 T 屬性。

A = np.arange(1, 7).reshape(2, 3)
transpose_A = np.transpose(A)
A_T = A.T
print(A)
print(transpose_A)
print(A_T)

列向量或欄向量的「相乘運算」除了元素對應運算外還有矩陣相乘，也就是所謂的乘積運算（Dot product），相乘的前提是左側向量的欄數和右側向量的列數必須相等。

我們可以使用 np.dot() 函數或者 ndarray 的 dot() 方法來進行欄向量相乘。

print(np.dot(u.T, v))
print(u.dot(v.T))

同樣的道理，矩陣相乘的前提也是左側矩陣的欄數和右側矩陣的列數必須相等。

A = np.arange(1, 7).reshape(2, 3)
B = np.arange(1, 7).reshape(3, 2)
print(A.dot(B))

利用 np.eye() 函數建立單位矩陣（Identity matrix），單位矩陣是一個方矩陣（意即列數與欄數相等），其對角線上的元素都是 1。

I_22 = np.eye(2)
I_33 = np.eye(3)
I_44 = np.eye(4)
print(I_22)
print(I_33)
print(I_44)

單位矩陣在矩陣運算中的作用與常數 1 在代數運算中的作用相似，在代數中變數與其倒數相乘可以得到常數 1，解此來求解方程式，例如在解下列代數方程式的時候我們會將等號兩邊乘上 a 的倒數來求解。

面對矩陣代數的時候，矩陣與其反矩陣相乘可以得到單位矩陣，因此在解下列矩陣代數方程式的時候，是將等號兩邊乘上 A 的反矩陣來求解，我們可以使用 np.linalg.inv() 函數計算 A 的反矩陣。

以下列的線性方程組為例：

A = np.array([1, 3, 1, 2]).reshape(2, 2)
B = np.array([5, 3]).reshape(2, 1)
inv_A = np.linalg.inv(A)
x = inv_A.dot(B)
print(x)

入門矩陣運算之後，我們就能夠在未來的電子報中透過 ndarray 運算認識機器學習的資料預處理與模型訓練，這週也是我第一次使用了 Substack 的 LaTex 功能，非常開心！在認識了 NumPy 與矩陣運算之後，第三十四週約維安計畫來到尾聲，希望您也和我一樣期待下一篇文章。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Subscribe now

約維安計畫學員專區

Read more

什麼是 NumPy

NumPy 是 Numeric Python(or Numerical Python)的簡稱，是 Python 最重要的資料科學模組之一。NumPy 創造了 ndarray 的資料結構類別以及大量的通用函數與聚合函數，讓 Python 使用者能夠對數列進行快速的數值計算、對數列使用統計函數、進行線性代數運算以及操作隨機的模擬任務等。NumPy 的前身為兩個模組，都是在 1990 年代中期所誕生的 Numeric 與 Numarray 模組，NumPy 於 2005 年集兩者之大成問世。對 NumPy 模組的發展歷史有興趣的讀者可以進一步參考 Array Programming with NumPy1 以及 NumPy - Wikipedia2。

Subscribe now

安裝與載入 NumPy

NumPy 的安裝可以透過 pip 或者 conda，如果讀者的 Python 是從 Python.org 下載的就直接透過 pip 安裝，假如是約維安計畫的成員，Python 應該是 Miniconda 版本，那麼建議可以透過 conda 安裝3。

$ pip install numpy==MAJOR.MINOR.PATCH
$ conda install numpy==MAJOR.MINOR.PATCH

如果希望從既有的 NumPy 版本更新升級，可以在 install 指令之後加上 -U 或 --update-deps 參數。

$ pip install -U numpy==MAJOR.MINOR.PATCH
$ conda install -c conda-forge --update-deps numpy==MAJOR.MINOR.PATCH

官方文件建議載入模組的所有功能並且縮寫為 np。

import numpy as np

利用兩個模組內建屬性檢視 NumPy 的安裝版本與路徑。

print(np.__version__)
print(np.__file__)

怎樣學好 NumPy

學好 NumPy 的關鍵是理解其核心功能以及主要應用場景：

• 如何使用 ndarray 來進行數值操作。

• 如何使用 NumPy 定義的函數對 ndarray 進行數值運算。

• 如何應用 ndarray 於向量、矩陣以及張量的操作及運算。

• ndarray 是其他資料科學模組 Pandas、Matplotlib 與 Scikit-Learn 的基石。

如何創造 ndarray

常見兩種創造 ndarray 的方式有：從既有的 list 創造或者利用函數創造。

# Create ndarray from a list
prime_list = [2, 3, 5, 7, 11]
prime_array = np.array(prime_list)
print(prime_array)
print(type(prime_array))

利用 NumPy 定義的函數可以創造出內容元素相同、數列型態以及具備特定分配的 ndarray。

# Create ndarray with identical elements
print(np.zeros(5, dtype=int))
print(np.ones(5, dtype=float))
print(np.full(5, 6))
# Create ndarray as a sequence
print(np.arange(1, 11, 2))
print(np.linspace(1, 9, 5, dtype=int))
# Create ndarray with a specific distribution
m = 10000
uniform_array = np.random.random(m)
normal_array = np.random.normal(0, 1, m)
randint_array = np.random.randint(1, 7, size=m)
print(uniform_array)
print(normal_array)
print(randint_array)

常用的 ndarray 屬性

常用的 ndarray 屬性有四個，分別是：

1. ndarray.ndim 維度數。

2. ndarray.shape 外型。

3. ndarray.size 元素個數。

4. ndarray.dtype 資料類別。

print(prime_array.ndim)
print(prime_array.shape)
print(prime_array.size)
print(prime_array.dtype)

從 ndarray 中擷取元素、片段的方式

利用與 list 相同的 indexing/slicing 語法。

print(prime_array[0]) # indexing
print(prime_array[0:3:1]) # slicing

利用 ndarray 的特性，在中括號使用多個索引取得指定位置的元素。

matrix = np.array([[5, 5],
                   [6, 6],
                   [55, 66]])
print(matrix[2, 1])

利用 ndarray 的特性，能夠以 Fancy indexing 或 Boolean indexing 的方式取得指定位置、符合指定條件的元素。Fancy indexing（華麗索引？）指的是以一個 list 決定要取得哪些位置的元素，Boolean indexing 指的是以一個外型相同、充滿布林值的 ndarray 來取得對應位置為 True 的元素。

# Fancy indexing
print(prime_array[[0, 1, 4]])
# Boolean indexing
print(prime_array % 2 == 1)
print(prime_array[prime_array % 2 == 1])

常用的 ndarray 操作

我們常對 ndarray 進行的操作有調整外型、合併以及分割。使用 ndarray 的 reshape() 方法調整成指定外型，在其他維度已經決定時可以方便地指定 -1 給最後一個維度；使用 ndarray 的 ravel() 方法打平成一維。

array_range = np.arange(1, 13)
print(array_range) # (12,)
print(array_range.reshape(3, 4))  # (3, 4)
print(array_range.reshape(3, -1)) # (3, 4)
print(array_range.reshape(-1, 4)) # (3, 4)
print(array_range.reshape(3, 4).ravel()) # (12,)

合併操作能夠透過 np.concatenate() 函數達成，預設為垂直方向的合併（增加列數），指定參數 axis=1 則能夠調整為水平方向的合併（增加欄位）。

array_a = np.arange(1, 5).reshape(2, 2)
array_b = np.arange(5, 9).reshape(2, 2)
print(np.concatenate((array_a, array_b)))
print(np.concatenate((array_a, array_b), axis=1))

分割操作能夠透過 np.split() 函數達成，預設為垂直方向的分割，指定參數 axis=1 則能夠調整為水平方向的分割。

array_range = np.arange(20).reshape(-1, 2)
upper_array, lower_array = np.split(array_range, 2)
left_array, right_array = np.split(array_range, 2, axis=1)
print(upper_array)
print(lower_array)
print(left_array)
print(right_array)

NumPy 的數值運算函數

NumPy 提供非常豐富、能夠針對 ndarray 進行運算的通用函數、聚合函數。通用函數是具備向量化（Vectorized）特性的函數，接受固定數量、外型的輸入並對應相同數量、外型的輸出。

array_range = np.arange(10)
print(np.power(array_range, 2))
print(np.exp(array_range))

如果需要自行定義能夠對 ndarray 運算應用的通用函數，可以使用 np.vectorize() 函數將只能作用於純量的函數轉換為能作用於 ndarray 的通用函數。

def is_prime(x):
    number_of_divisors = 0
    for integer in range(1, x + 1):
        if x % integer == 0:
            number_of_divisors += 1
    return number_of_divisors == 2
vectorized_is_prime = np.vectorize(is_prime)
vectorized_is_prime(np.arange(10))

聚合函數則是能夠將多個資料值輸入摘要為單一值輸出的函數，在使用 NumPy 的聚合函數時有兩個值得注意的特性：可以沿指定的軸（axis）進行聚合、針對含有 np.nan（Not a Number）的 ndarray 有相對應名稱的聚合函數可以運算。

# Aggregate along specific axis
array_range = np.arange(1, 16, dtype=float).reshape(3, 5)
print(np.sum(array_range))
print(np.sum(array_range, axis=0))
print(np.sum(array_range, axis=1))
# Similar function names for array with np.nan
array_range[2, 4] = np.nan
print(array_range)
print(np.sum(array_range))
print(np.nansum(array_range))

入門 NumPy 之後，我們就能夠在下次的電子報中透過 ndarray 認識線性代數最重要的內容：矩陣運算。

在認識了 NumPy 的核心功能以及主要應用場景之後，第三十三週約維安計畫：NumPy 來到尾聲，希望您也和我一樣期待下一篇文章。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Subscribe now

約維安計畫學員專區

Read more

資料科學專案的發起點

資料科學家面對的專案可能會包含下列這些工作內容：使用者的需求發想、與使用者討論需求規格，取得測試資料、載入環境、整理資料、使用圖形探索資料、利用模型預測、部署專案到正式環境最後是將專案的內容以淺顯易懂的方式與組織內部其他的團隊溝通及分享。

載入資料在資料科學專案中扮演發起點，如果這個資料科學專案目的是協助我們制定資料驅動的策略（Data-driven strategy），而非倚賴直覺，那麼為專案細心盤點資料來源與整理獲取方法，可以為將來的決策奠基穩固的基礎。資料常見來源包含：

• 純文字檔案

  • 非結構化純文字檔案

  • 結構化純文字檔案

    • CSV

    • JSON

    • HTML

• 試算表

• 關聯式資料庫管理系統中的資料表

使用 R 語言載入純文字檔案

純文字檔案指的是只有文字所構成的電腦檔案，這代表其中不包含字型的樣式或段落標記等，這類型檔案最明顯的特性就是能夠使用最簡單的文字編輯器（例如 Windows 的「記事本」、macOS 的 TextEdit）直接開啟檢視。

純文字檔案涵蓋的範圍相當廣泛，能夠再區分為非結構化純文字檔案與結構化純文字檔案兩大類；而結構化純文字檔案亦能再細分出 JSON、CSV 與 HTML 等。

非結構化純文字檔案

非結構化純文字檔案常用來儲存像是文章、劇本或系統日誌（System logs）等，例如儲存在工作目錄的經典電影「刺激 1995」簡介 the_shawshank_redemption_summaries.txt，我們使用內建的 readLines() 函數將檔案內容一列一列載入到文字向量之中。

text_file_path <- "the_shawshank_redemption_summaries.txt"
the_shawshank_redemption_summaries <- readLines(text_file_path)
print(class(the_shawshank_redemption_summaries))
print(length(the_shawshank_redemption_summaries))
print(the_shawshank_redemption_summaries)

結構化純文字檔案

結構化純文字檔案指的是透過特定符號讓資料能夠系統性地儲存、讀取及處理，例如 JSON(JavaScript Object Notation) 可以透過大括號 {} 儲存鍵值對應的資料、CSV(Comma Separated Values) 可以透過逗號 , 分隔不同欄位、HTML(Hyper Text Markup Language) 可以透過標記 <></> 顯示不同外型與功能的資料。

JSON 是一種輕量的資料交換格式，對於人類而言是容易閱讀和寫作的格式，對於電腦而言是容易解析和建立的格式，簡言之，是一種對人類與電腦都友善的純文字格式，JSON 雖然源於 JavaScript，但卻是獨立於該程式語言之外，能夠被眾多程式語言輕鬆解析和建立的一種理想資料交換格式。JSON 可能由兩種資料結構組成：鍵值對應關係與有序列表，可以用 R 語言的 list 來理解。

我們使用 rjson 套件中的 fromJSON() 函數指定參數 file 載入 teams_rowbased.json。

json_file_path <- "teams_rowbased.json"
teams_json <- rjson::fromJSON(file = json_file_path)
print(class(teams_json))
print(length(teams_json))
print(teams_json[[1]])

CSV 是最廣泛被使用的一種結構化純文字檔案格式，因此還有特定的副檔名 .csv，我們使用內建的 read.csv() 函數載入。

movies_csv <- read.csv("movies.csv")
print(class(movies_csv))
head(movies_csv)

HTML 是一種用於建立網頁的標準標記語言，常與 CSS、JavaScript 一起被用於設計網頁、網頁應用程式以及行動應用程式的使用者介面，瀏覽器可以讀取 HTML 檔案，並將其渲染成視覺化網頁，HTML 描述了一個網站的結構語意隨著線索的呈現，使之成為一種標記語言而非程式語言。載入 HTML 時使用 httr 搭配 rvest 套件，前者用於對網頁伺服器發送請求，後者用於解析 HTML 的內容。

首先我們透過 httr 套件的 GET() 函數向 https://www.imdb.com/chart/top 這個網址發送了 GET 請求，並且帶著 Headers 使得回應可以是英文的。然後透過 rvest 套件的 read_html() 函數解析回應的文字，並且利用 CSS 選擇器取得想要的資訊，例如評分最高的前 250 部電影名稱。

r <- httr::GET("https://www.imdb.com/chart/top", add_headers("accept-language" = "en,en-US;q=1"))
imdb_top <- rvest::read_html(r[["content"]])
imdb_top_movie_titles <- imdb_top |> 
  rvest::html_elements(".titleColumn a") |>
  rvest::html_text2()
print(imdb_top_movie_titles)

有時候我們想要擷取的資訊是 HTML 標記中的屬性，也能夠改採 rvest 套件的 html_attr() 函數取得，例如評分最高的前 250 部電影頁面連結。

imdb_top_movie_links <- imdb_top |> 
  rvest::html_elements(".titleColumn a") |>
  rvest::html_attr("href")
split_movie_links <- strsplit(imdb_top_movie_links, split = "/?", fixed = TRUE)
movie_link_routes <- vector()
for (item in split_movie_links){
  movie_link_routes <- c(movie_link_routes, item[1])
}
imdb_top_movie_links <- paste0("https://www.imdb.com", movie_link_routes)
print(imdb_top_movie_links)

使用 R 語言載入試算表

試算表是類比紙本計算表格的電腦軟體，由許多列與欄所構成的儲存格，其中可以存放數值、算式或文字，常見的試算表軟體有 Microsoft Excel、macOS Numbers 與 Google Sheets。試算表的檔案為一個活頁簿（Workbook）、活頁簿中可以有多個試算表（Spreadsheets），我們使用 readxl 套件的 read_excel() 函數預設讀取第一張試算表。

excel_file_path <- "imdb.xlsx"
movies_xlsx <- readxl::read_excel(excel_file_path)
print(class(movies_xlsx))
head(movies_xlsx)

由於活頁簿中可以有多個試算表的設計，載入之前建議先使用 readxl 套件的 excel_sheets() 函數檢視活頁簿中有幾個試算表。

excel_sheets <- readxl::excel_sheets(excel_file_path)
print(excel_sheets)

在 readxl 套件的 read_excel() 函數指定參數 sheet 載入特定試算表，可以接受試算表名稱、亦能輸入整數（由左邊從一開始數來第幾張試算表）。

casting_xlsx <- readxl::read_excel(excel_file_path, sheet = "casting")
actors_xlsx <- readxl::read_excel(excel_file_path, sheet = 3)
head(casting_xlsx)
head(actors_xlsx)

使用 R 語言載入關聯式資料庫管理系統中的資料表

關聯式資料庫（Relational database）是基於關聯模型所建構的資料庫，是儲存在電腦中的資料集合。一個資料庫中通常會有多個資料表（Table）能夠藉助集合運算（Set operation）等數學方法來處理資料表之間的操作和關聯，也能夠用來表示現實世界中的商業邏輯，並能夠接受結構化查詢語言 SQL 來進行檢索和操作。

我們使用 DBI 套件的 dbConnect() 函數建立與資料庫的連線，並且運用 RSQLite 套件的 SQLite() 函數傳入連線引擎，再運用結構化查詢語言 SQL 搭配 DBI 套件的 dbReadTable() 函數載入，資料庫使用完畢之後用 dbDisconnect() 函數將連線關閉。

connection <- DBI::dbConnect(RSQLite::SQLite(),
                             dbname = "imdb.db")
movies_db <- DBI::dbReadTable(connection, name = "movies")
casting_db <- DBI::dbReadTable(connection, name = "casting")
actors_db <- DBI::dbReadTable(connection, name = "actors")
head(movies_db)
head(casting_db)
head(actors_db)
dbDisconnect(connection)

在認識了如何使用 R 語言載入純文字檔案、試算表與關聯式資料庫中的資料表之後，第三十二週約維安計畫：使用 R 語言載入資料來到尾聲，希望您也和我一樣期待下一篇文章。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

約維安計畫學員專區

Read more

橫空出世的職業？

從 2012 年哈佛商業評論拋出資料科學家（Data scientist）是 21 世紀最性感的職業那刻起，資料科學（Data science）從美國向世界捲起瘋狂的浪潮，一直延續到 2017 年 Deep Mind 團隊的 Alpha Go；資料科學、大數據、人工智慧、機器學習與深度學習等字彙從報章雜誌與社群媒體向我們大量放送。從新創團隊、軟體公司、金融業、顧問業與製造業開始重新思索資料驅動（Data-driven）的策略制定，進而期望招募更多同時具備軟體工程與統計學兩個領域專長的資料科學家，造成就業市場的需求量大增，進而驅動了資料科學家的年薪接近 14 萬美金，一躍而成矽谷最具吸引力的職缺。

資料科學家並不是一個橫空出世的職業，90 年代風靡全美的電視喜劇六人行（Friends），其中一個主角 Chandler Bing（由 Matthew Perry 飾演），在劇中有一個設定非常有趣，那就是他的好朋友們永遠都記不住他從事什麼樣的工作。有一天他告訴老婆 Monica Geller（由 Courtney Cox 飾演），為了家庭收入著想他要回去做他原本的工作，這時 Monica 跟他說：

I want you to do something you like, not statistical analysis and data reconfiguration.

如果 Chandler 晚 20 年從事他原本的工作，那麼職稱多半就是資料科學家，頂著這個最性感職業的光環，也許這位有點膚淺又憤世嫉俗的傢伙就不會這麼討厭他的工作了吧？

資料科學家的日常

那麼究竟資料科學家的工作職責是什麼？資料科學家面對的專案可能會包含下列這些工作內容：使用者的需求發想、與使用者討論需求規格，取得測試資料、載入環境、整理資料、使用圖形探索資料、利用模型預測、部署專案到正式環境最後是將專案的內容以淺顯易懂的方式與組織內部其他的團隊溝通及分享。

首先是載入資料，將常見資料格式，包含純文字檔案、試算表或關聯式資料庫管理系統中的資料表，透過各式模組、套件載入開發環境，完成資料科學的第一個里程碑；在順利取得資料之後，在掌控資料環節（Wrangle），透過對資料結構的認知將原型資料（Raw data）清理整併為緊實乾淨的形式（Tidy data），這樣一致且通用的資料樣式能夠讓資料科學團隊集中精力處理資料探索和資料預測相關的應用；一旦有了緊實整潔的資料，在探索資料環節，將透過利用視覺化模組和套件進行探索性資料分析，適當的探索性資料分析可以讓資料科學團隊挖掘潛藏的特徵，進而延展專案的範疇與洞見；在資料建模環節，引入統計分析與機器學習這個資料科學中最吸引人、加值程度最大的過程，在定義精確的問題下，演算法可以訓練已知資料來作為未知資料預測的依據；資料科學的最後一步是溝通，這是專案的關鍵部分，如果能夠有效地向合作部門（像是產品、行銷與管理團隊等）精準地傳達分析結果，將能顯著為資料科學專案的成果加值，提升資料科學團隊在組織內的價值。

資料科學專案的發起點

載入資料在資料科學專案中扮演發起點，如果這個資料科學專案目的是協助我們制定資料驅動的策略（Data-driven strategy），而非倚賴直覺，那麼為專案細心盤點資料來源與整理獲取方法，可以為將來的決策奠基穩固的基礎。資料常見來源包含：

• 純文字檔案

  • 非結構化純文字檔案

  • 結構化純文字檔案

    • CSV

    • JSON

    • HTML

• 試算表

• 關聯式資料庫管理系統中的資料表

使用 Python 載入純文字檔案

純文字檔案指的是只有文字所構成的電腦檔案，這代表其中不包含字型的樣式或段落標記等，這類型檔案最明顯的特性就是能夠使用最簡單的文字編輯器（例如 Windows 的「記事本」、macOS 的 TextEdit）直接開啟檢視。

純文字檔案涵蓋的範圍相當廣泛，能夠再區分為非結構化純文字檔案與結構化純文字檔案兩大類；而結構化純文字檔案亦能再細分出 JSON、CSV 與 HTML 等。

非結構化純文字檔案常用來儲存像是文章、劇本或系統日誌（System logs）等，例如儲存在工作目錄的經典電影「刺激 1995」簡介 the_shawshank_redemption_summaries.txt，我們使用內建的 open() 函數開啟檔案，並將檔案內容一列一列載入到 list 之中，為了讓開檔、讀檔與關檔的流程能夠一氣呵成，使用 with 敘述建立資源管理器的程式區塊。

text_file_path = "the_shawshank_redemption_summaries.txt"
with open(text_file_path) as file:
    the_shawshank_redemption_summaries = file.readlines()
print(the_shawshank_redemption_summaries)

結構化純文字檔案指的是透過特定符號讓資料能夠系統性地儲存、讀取及處理，例如 JSON(JavaScript Object Notation) 可以透過大括號 {} 儲存鍵值對應的資料、CSV(Comma Separated Values) 可以透過逗號 , 分隔不同欄位、HTML(Hyper Text Markup Language) 可以透過標記 <></> 顯示不同外型與功能的資料。

JSON 是一種輕量的資料交換格式，對於人類而言是容易閱讀和寫作的格式，對於電腦而言是容易解析和建立的格式，簡言之，是一種對人類與電腦都友善的純文字格式，JSON 雖然源於 JavaScript，但卻是獨立於該程式語言之外，能夠被眾多程式語言輕鬆解析和建立的一種理想資料交換格式。JSON 可能由兩種資料結構組成：鍵值對應關係與有序列表，可以用 Python 的 dict 與 list 來理解。我們使用 open() 函數搭配 with 敘述開啟 teams_rowbased.json，使用 json 模組的 load() 函數將檔案內容載入，因為 JSON 可能由兩種資料結構組成，輸出物件可能是 dict 或 list 類別的實例。

json_file_path = "teams_rowbased.json"
with open(json_file_path) as file:
    teams_json = json.load(file)
print(type(teams_json))
print(len(teams_json))
print(type(teams_json[0]))
print(len(teams_json[0]))

CSV 是最廣泛被使用的一種結構化純文字檔案格式，因此還有特定的副檔名 .csv，我們使用 pandas 模組的 read_csv() 函數載入。

movies_csv = pd.read_csv("movies.csv")
print(type(movies_csv))
movies_csv.head()

HTML 是一種用於建立網頁的標準標記語言，常與 CSS、JavaScript 一起被用於設計網頁、網頁應用程式以及行動應用程式的使用者介面，瀏覽器可以讀取 HTML 檔案，並將其渲染成視覺化網頁，HTML 描述了一個網站的結構語意隨著線索的呈現，使之成為一種標記語言而非程式語言。通常載入 HTML 時會使用 Requests 模組搭配 BeautifulSoup4 模組，前者用於對網頁伺服器發送請求、後者則用於解析 HTML 的內容。

headers = {
    "accept-language": "en,en-US;q=1"
}
r = requests.get("https://www.imdb.com/chart/top", headers=headers)
soup = BeautifulSoup(r.text)
for elem in soup.select(".titleColumn a"):
    print(elem.text)
for elem in soup.select(".titleColumn a"):
    print(elem.get("href"))

使用 Python 載入試算表

試算表是類比紙本計算表格的電腦軟體，由許多列與欄所構成的儲存格，其中可以存放數值、算式或文字，常見的試算表軟體有 Microsoft Excel、macOS Numbers 與 Google Sheets。試算表的檔案為一個活頁簿（Workbook）、活頁簿中可以有多個試算表（Spreadsheets），我們使用 pandas 模組的 read_excel() 函數預設讀取第零張試算表（左邊數來第一張）。

excel_file_path = "imdb.xlsx"
movies_xlsx = pd.read_excel(excel_file_path)
print(type(movies_xlsx))
movies_xlsx.head()

由於活頁簿中可以有多個試算表的設計，載入之前建議先使用 pandas 模組的 ExcelFile 類別的 sheet_names 屬性檢視活頁簿中有幾個試算表。

excel_file = pd.ExcelFile(excel_file_path)
excel_file.sheet_names

在 pandas 模組的 read_excel() 函數指定參數 sheet_name 載入特定試算表，可以接受試算表名稱、亦能輸入整數（由左邊從零開始數來第幾張試算表）。

casting_xlsx = pd.read_excel(excel_file_path, sheet_name="casting")
actors_xlsx = pd.read_excel(excel_file_path, sheet_name=2)
casting_xlsx.head()
actors_xlsx.head()

使用 Python 載入關聯式資料庫管理系統中的資料表

關聯式資料庫（Relational database）是基於關聯模型所建構的資料庫，是儲存在電腦中的資料集合。一個資料庫中通常會有多個資料表（Table）能夠藉助集合運算（Set operation）等數學方法來處理資料表之間的操作和關聯，也能夠用來表示現實世界中的商業邏輯，並能夠接受結構化查詢語言 SQL 來進行檢索和操作。我們使用 sqlite3 模組的 connect() 函數建立與資料庫的連線，再運用結構化查詢語言 SQL 搭配 pandas 模組的 read_sql() 函數載入，資料庫使用完畢之後將連線關閉。

connection = sqlite3.connect("imdb.db")
query = """
SELECT *
  FROM movies;
"""
movies_db = pd.read_sql(query, connection)
movies_db.head()
query = """
SELECT *
  FROM casting;
"""
casting_db = pd.read_sql(query, connection)
casting_db.head()
query = """
SELECT *
  FROM actors;
"""
actors_db = pd.read_sql(query, connection)
actors_db.head()
connection.close()

在認識了如何使用 Python 載入純文字檔案、試算表與關聯式資料庫中的資料表之後，第三十一週約維安計畫：使用 Python 載入資料來到尾聲，希望您也和我一樣期待下一篇文章。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

Read more