雷鋒網 AI 科技評論按，數據科學家需要算力。無論您是用 pandas 處理一個大數據集，還是用 Numpy 在一個大矩陣上運行一些計算，您都需要一臺強大的機器，以便在合理的時間內完成這項工作。
在過去的幾年中，數據科學家常用的 Python 庫已經非常擅長利用 CPU 能力。
Pandas 的基礎代碼是用 C 語言編寫的，它可以很好地處理大小超過 100GB 的數據集。如果您沒有足夠的 RAM 來容納這樣的數據集，那麼您可以使用分塊功能，它很方便，可以一次處理一個數據塊。
GPUs vs CPUs：並行處理
有了大量的數據，CPU 就不會切斷它了。
一個超過 100GB 的數據集將有許多數據點，數據點的數值在數百萬甚至數十億的範圍內。有了這麼多的數據點要處理，不管你的 CPU 有多快，它都沒有足夠的內核來進行有效的並行處理。如果你的 CPU 有 20 個內核（這將是相當昂貴的 CPU），你一次只能處理 20 個數據點！
CPU 在時鐘頻率更重要的任務中會更好——或者根本沒有 GPU 實現。如果你嘗試執行的流程有一個 GPU 實現，且該任務可以從並行處理中受益，那麼 GPU 將更加有效。
"雷鋒網 AI 科技評論按，數據科學家需要算力。無論您是用 pandas 處理一個大數據集，還是用 Numpy 在一個大矩陣上運行一些計算，您都需要一臺強大的機器，以便在合理的時間內完成這項工作。
在過去的幾年中，數據科學家常用的 Python 庫已經非常擅長利用 CPU 能力。
Pandas 的基礎代碼是用 C 語言編寫的，它可以很好地處理大小超過 100GB 的數據集。如果您沒有足夠的 RAM 來容納這樣的數據集，那麼您可以使用分塊功能，它很方便，可以一次處理一個數據塊。
GPUs vs CPUs：並行處理
有了大量的數據，CPU 就不會切斷它了。
一個超過 100GB 的數據集將有許多數據點，數據點的數值在數百萬甚至數十億的範圍內。有了這麼多的數據點要處理，不管你的 CPU 有多快，它都沒有足夠的內核來進行有效的並行處理。如果你的 CPU 有 20 個內核（這將是相當昂貴的 CPU），你一次只能處理 20 個數據點！
CPU 在時鐘頻率更重要的任務中會更好——或者根本沒有 GPU 實現。如果你嘗試執行的流程有一個 GPU 實現，且該任務可以從並行處理中受益，那麼 GPU 將更加有效。
多核系統如何更快地處理數據。對於單核系統（左），所有 10 個任務都轉到一個節點。對於雙核系統（右），每個節點承擔 5 個任務，從而使處理速度加倍
深度學習已經在利用 GPU 方面發揮了相當大的作用。許多在深度學習中完成的卷積操作是重複的，因此在 GPU 上可以大大加速，甚至可以達到 100 次。
今天的數據科學沒有什麼不同，因為許多重複的操作都是在大數據集上執行的，庫中有 pandas、Numpy 和 scikit-learn。這些操作也不太複雜，無法在 GPU 上實現。
最後，還有一個解決方案。
用 Rapids 加速 GPU
Rapids 是一套軟件庫，旨在利用 GPU 加速數據科學。它使用低級別的 CUDA 代碼實現快速的、GPU 優化的算法，同時它上面還有一個易於使用的 Python 層。
Rapids 的美妙之處在於它與數據科學庫的集成非常順利，比如 pandas 數據幀就很容易通過 Rapids 實現 GPU 加速。下圖說明了 Rapids 如何在保持頂層易用性的同時實現低層的加速。
"雷鋒網 AI 科技評論按，數據科學家需要算力。無論您是用 pandas 處理一個大數據集，還是用 Numpy 在一個大矩陣上運行一些計算，您都需要一臺強大的機器，以便在合理的時間內完成這項工作。
在過去的幾年中，數據科學家常用的 Python 庫已經非常擅長利用 CPU 能力。
Pandas 的基礎代碼是用 C 語言編寫的，它可以很好地處理大小超過 100GB 的數據集。如果您沒有足夠的 RAM 來容納這樣的數據集，那麼您可以使用分塊功能，它很方便，可以一次處理一個數據塊。
GPUs vs CPUs：並行處理
有了大量的數據，CPU 就不會切斷它了。
一個超過 100GB 的數據集將有許多數據點，數據點的數值在數百萬甚至數十億的範圍內。有了這麼多的數據點要處理，不管你的 CPU 有多快，它都沒有足夠的內核來進行有效的並行處理。如果你的 CPU 有 20 個內核（這將是相當昂貴的 CPU），你一次只能處理 20 個數據點！
CPU 在時鐘頻率更重要的任務中會更好——或者根本沒有 GPU 實現。如果你嘗試執行的流程有一個 GPU 實現，且該任務可以從並行處理中受益，那麼 GPU 將更加有效。
多核系統如何更快地處理數據。對於單核系統（左），所有 10 個任務都轉到一個節點。對於雙核系統（右），每個節點承擔 5 個任務，從而使處理速度加倍
深度學習已經在利用 GPU 方面發揮了相當大的作用。許多在深度學習中完成的卷積操作是重複的，因此在 GPU 上可以大大加速，甚至可以達到 100 次。
今天的數據科學沒有什麼不同，因為許多重複的操作都是在大數據集上執行的，庫中有 pandas、Numpy 和 scikit-learn。這些操作也不太複雜，無法在 GPU 上實現。
最後，還有一個解決方案。
用 Rapids 加速 GPU
Rapids 是一套軟件庫，旨在利用 GPU 加速數據科學。它使用低級別的 CUDA 代碼實現快速的、GPU 優化的算法，同時它上面還有一個易於使用的 Python 層。
Rapids 的美妙之處在於它與數據科學庫的集成非常順利，比如 pandas 數據幀就很容易通過 Rapids 實現 GPU 加速。下圖說明了 Rapids 如何在保持頂層易用性的同時實現低層的加速。
Rapids 利用了幾個 Python 庫：
cuDF-Python GPU 數據幀。它幾乎可以做 pandas 在數據處理和操作方面所能做的一切。
cuML-cuGraph 機器學習庫。它包含了 Scikit-Learn 擁有的許多 ML 算法，所有算法的格式都非常相似。
cuGraph-cuGraph 圖處理庫。它包含許多常見的圖分析算法，包括 PageRank 和各種相似性度量。
如何使用 Rapids
安裝
現在你將看到如何使用 Rapids！
要安裝它，請訪問這個網站，在這裡你將看到如何安裝 Rapids。你可以通過 Conda 將其直接安裝到你的機器上，或者簡單地使用 Docker 容器。
安裝時，可以設置系統規範，如 CUDA 版本和要安裝的庫。例如，我有 CUDA 10.0，想要安裝所有庫，所以我的安裝命令是：
conda install -c nvidia -c rapidsai -c numba -c conda-forge -c pytorch -c defaults cudf=0.8 cuml=0.8 cugraph=0.8 python=3.6 cudatoolkit=10.0
一旦命令完成運行，就可以開始用 GPU 加速數據科學了。
設置我們的數據
對於本教程，我們將介紹 DBSCAN demo 的修改版本。我將使用 Nvidia 數據科學工作站和 2 個 GPU 運行這個測試。
DBSCAN 是一種基於密度的聚類算法，可以自動對數據進行分類，而無需用戶指定有多少組數據。在 Scikit-Learn 中有它的實現。
我們將從獲取所有導入設置開始。先導入用於加載數據、可視化數據和應用 ML 模型的庫。
import os
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_circles
make_circles 函數將自動創建一個複雜的數據分佈，類似於我們將應用於 DBSCAN 的兩個圓。
讓我們從創建 100000 點的數據集開始，並在圖中可視化：
"X, y = make_circles(n_samples=int(1e5), factor=.35, noise=.05)
X[:, 0] = 3*X[:, 0]
X[:, 1] = 3*X[:, 1]
plt.scatter(X[:, 0], X[:, 1])
plt.show
雷鋒網 AI 科技評論按，數據科學家需要算力。無論您是用 pandas 處理一個大數據集，還是用 Numpy 在一個大矩陣上運行一些計算，您都需要一臺強大的機器，以便在合理的時間內完成這項工作。
在過去的幾年中，數據科學家常用的 Python 庫已經非常擅長利用 CPU 能力。
Pandas 的基礎代碼是用 C 語言編寫的，它可以很好地處理大小超過 100GB 的數據集。如果您沒有足夠的 RAM 來容納這樣的數據集，那麼您可以使用分塊功能，它很方便，可以一次處理一個數據塊。
GPUs vs CPUs：並行處理
有了大量的數據，CPU 就不會切斷它了。
一個超過 100GB 的數據集將有許多數據點，數據點的數值在數百萬甚至數十億的範圍內。有了這麼多的數據點要處理，不管你的 CPU 有多快，它都沒有足夠的內核來進行有效的並行處理。如果你的 CPU 有 20 個內核（這將是相當昂貴的 CPU），你一次只能處理 20 個數據點！
CPU 在時鐘頻率更重要的任務中會更好——或者根本沒有 GPU 實現。如果你嘗試執行的流程有一個 GPU 實現，且該任務可以從並行處理中受益，那麼 GPU 將更加有效。
多核系統如何更快地處理數據。對於單核系統（左），所有 10 個任務都轉到一個節點。對於雙核系統（右），每個節點承擔 5 個任務，從而使處理速度加倍
深度學習已經在利用 GPU 方面發揮了相當大的作用。許多在深度學習中完成的卷積操作是重複的，因此在 GPU 上可以大大加速，甚至可以達到 100 次。
今天的數據科學沒有什麼不同，因為許多重複的操作都是在大數據集上執行的，庫中有 pandas、Numpy 和 scikit-learn。這些操作也不太複雜，無法在 GPU 上實現。
最後，還有一個解決方案。
用 Rapids 加速 GPU
Rapids 是一套軟件庫，旨在利用 GPU 加速數據科學。它使用低級別的 CUDA 代碼實現快速的、GPU 優化的算法，同時它上面還有一個易於使用的 Python 層。
Rapids 的美妙之處在於它與數據科學庫的集成非常順利，比如 pandas 數據幀就很容易通過 Rapids 實現 GPU 加速。下圖說明了 Rapids 如何在保持頂層易用性的同時實現低層的加速。
Rapids 利用了幾個 Python 庫：
cuDF-Python GPU 數據幀。它幾乎可以做 pandas 在數據處理和操作方面所能做的一切。
cuML-cuGraph 機器學習庫。它包含了 Scikit-Learn 擁有的許多 ML 算法，所有算法的格式都非常相似。
cuGraph-cuGraph 圖處理庫。它包含許多常見的圖分析算法，包括 PageRank 和各種相似性度量。
如何使用 Rapids
安裝
現在你將看到如何使用 Rapids！
要安裝它，請訪問這個網站，在這裡你將看到如何安裝 Rapids。你可以通過 Conda 將其直接安裝到你的機器上，或者簡單地使用 Docker 容器。
安裝時，可以設置系統規範，如 CUDA 版本和要安裝的庫。例如，我有 CUDA 10.0，想要安裝所有庫，所以我的安裝命令是：
conda install -c nvidia -c rapidsai -c numba -c conda-forge -c pytorch -c defaults cudf=0.8 cuml=0.8 cugraph=0.8 python=3.6 cudatoolkit=10.0
一旦命令完成運行，就可以開始用 GPU 加速數據科學了。
設置我們的數據
對於本教程，我們將介紹 DBSCAN demo 的修改版本。我將使用 Nvidia 數據科學工作站和 2 個 GPU 運行這個測試。
DBSCAN 是一種基於密度的聚類算法，可以自動對數據進行分類，而無需用戶指定有多少組數據。在 Scikit-Learn 中有它的實現。
我們將從獲取所有導入設置開始。先導入用於加載數據、可視化數據和應用 ML 模型的庫。
import os
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_circles
make_circles 函數將自動創建一個複雜的數據分佈，類似於我們將應用於 DBSCAN 的兩個圓。
讓我們從創建 100000 點的數據集開始，並在圖中可視化：
X, y = make_circles(n_samples=int(1e5), factor=.35, noise=.05)
X[:, 0] = 3*X[:, 0]
X[:, 1] = 3*X[:, 1]
plt.scatter(X[:, 0], X[:, 1])
plt.show
CPU 上的 DBSCAN
使用 Scikit-Learn 在 CPU 上運行 DBSCAN 很容易。我們將導入我們的算法並設置一些參數。
from sklearn.cluster import DBSCAN
db = DBSCAN(eps=0.6, min_samples=2)
我們現在可以通過調用 Scikit-Learn 中的一個函數對循環數據使用 DBSCAN。在函數前面加上一個「%」，就可以讓 Jupyter Notebook 測量它的運行時間。
%%time
y_db = db.fit_predict(X)
這 10 萬個點的運行時間是 8.31 秒，如下圖所示：
"雷鋒網 AI 科技評論按，數據科學家需要算力。無論您是用 pandas 處理一個大數據集，還是用 Numpy 在一個大矩陣上運行一些計算，您都需要一臺強大的機器，以便在合理的時間內完成這項工作。
在過去的幾年中，數據科學家常用的 Python 庫已經非常擅長利用 CPU 能力。
Pandas 的基礎代碼是用 C 語言編寫的，它可以很好地處理大小超過 100GB 的數據集。如果您沒有足夠的 RAM 來容納這樣的數據集，那麼您可以使用分塊功能，它很方便，可以一次處理一個數據塊。
GPUs vs CPUs：並行處理
有了大量的數據，CPU 就不會切斷它了。
一個超過 100GB 的數據集將有許多數據點，數據點的數值在數百萬甚至數十億的範圍內。有了這麼多的數據點要處理，不管你的 CPU 有多快，它都沒有足夠的內核來進行有效的並行處理。如果你的 CPU 有 20 個內核（這將是相當昂貴的 CPU），你一次只能處理 20 個數據點！
CPU 在時鐘頻率更重要的任務中會更好——或者根本沒有 GPU 實現。如果你嘗試執行的流程有一個 GPU 實現，且該任務可以從並行處理中受益，那麼 GPU 將更加有效。
多核系統如何更快地處理數據。對於單核系統（左），所有 10 個任務都轉到一個節點。對於雙核系統（右），每個節點承擔 5 個任務，從而使處理速度加倍
深度學習已經在利用 GPU 方面發揮了相當大的作用。許多在深度學習中完成的卷積操作是重複的，因此在 GPU 上可以大大加速，甚至可以達到 100 次。
今天的數據科學沒有什麼不同，因為許多重複的操作都是在大數據集上執行的，庫中有 pandas、Numpy 和 scikit-learn。這些操作也不太複雜，無法在 GPU 上實現。
最後，還有一個解決方案。
用 Rapids 加速 GPU
Rapids 是一套軟件庫，旨在利用 GPU 加速數據科學。它使用低級別的 CUDA 代碼實現快速的、GPU 優化的算法，同時它上面還有一個易於使用的 Python 層。
Rapids 的美妙之處在於它與數據科學庫的集成非常順利，比如 pandas 數據幀就很容易通過 Rapids 實現 GPU 加速。下圖說明了 Rapids 如何在保持頂層易用性的同時實現低層的加速。
Rapids 利用了幾個 Python 庫：
cuDF-Python GPU 數據幀。它幾乎可以做 pandas 在數據處理和操作方面所能做的一切。
cuML-cuGraph 機器學習庫。它包含了 Scikit-Learn 擁有的許多 ML 算法，所有算法的格式都非常相似。
cuGraph-cuGraph 圖處理庫。它包含許多常見的圖分析算法，包括 PageRank 和各種相似性度量。
如何使用 Rapids
安裝
現在你將看到如何使用 Rapids！
要安裝它，請訪問這個網站，在這裡你將看到如何安裝 Rapids。你可以通過 Conda 將其直接安裝到你的機器上，或者簡單地使用 Docker 容器。
安裝時，可以設置系統規範，如 CUDA 版本和要安裝的庫。例如，我有 CUDA 10.0，想要安裝所有庫，所以我的安裝命令是：
conda install -c nvidia -c rapidsai -c numba -c conda-forge -c pytorch -c defaults cudf=0.8 cuml=0.8 cugraph=0.8 python=3.6 cudatoolkit=10.0
一旦命令完成運行，就可以開始用 GPU 加速數據科學了。
設置我們的數據
對於本教程，我們將介紹 DBSCAN demo 的修改版本。我將使用 Nvidia 數據科學工作站和 2 個 GPU 運行這個測試。
DBSCAN 是一種基於密度的聚類算法，可以自動對數據進行分類，而無需用戶指定有多少組數據。在 Scikit-Learn 中有它的實現。
我們將從獲取所有導入設置開始。先導入用於加載數據、可視化數據和應用 ML 模型的庫。
import os
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_circles
make_circles 函數將自動創建一個複雜的數據分佈，類似於我們將應用於 DBSCAN 的兩個圓。
讓我們從創建 100000 點的數據集開始，並在圖中可視化：
X, y = make_circles(n_samples=int(1e5), factor=.35, noise=.05)
X[:, 0] = 3*X[:, 0]
X[:, 1] = 3*X[:, 1]
plt.scatter(X[:, 0], X[:, 1])
plt.show
CPU 上的 DBSCAN
使用 Scikit-Learn 在 CPU 上運行 DBSCAN 很容易。我們將導入我們的算法並設置一些參數。
from sklearn.cluster import DBSCAN
db = DBSCAN(eps=0.6, min_samples=2)
我們現在可以通過調用 Scikit-Learn 中的一個函數對循環數據使用 DBSCAN。在函數前面加上一個「%」，就可以讓 Jupyter Notebook 測量它的運行時間。
%%time
y_db = db.fit_predict(X)
這 10 萬個點的運行時間是 8.31 秒，如下圖所示：
使用 Scikit-Learn 在 CPU 上運行 DBSCAN 的結果
GPU 上帶 Rapids 的 DBSCAN
現在，讓我們用 Rapids 進行加速！
首先，我們將把數據轉換為 pandas.DataFrame 並使用它創建一個 cudf.DataFrame。pandas.DataFrame 無縫轉換成 cudf.DataFrame，數據格式無任何更改。
import pandas as pd
import cudf
X_df = pd.DataFrame({'fea%d'%i: X[:, i] for i in range(X.shape[1])})
X_gpu = cudf.DataFrame.from_pandas(X_df)
然後我們將從 cuML 導入並初始化一個特殊版本的 DBSCAN，它是 GPU 加速的版本。DBSCAN 的 cuML 版本的函數格式與 Scikit-Learn 的函數格式完全相同：相同的參數、相同的樣式、相同的函數。
from cuml import DBSCAN as cumlDBSCAN
db_gpu = cumlDBSCAN(eps=0.6, min_samples=2)
最後，我們可以在測量運行時間的同時運行 GPU DBSCAN 的預測函數。
%%time
y_db_gpu = db_gpu.fit_predict(X_gpu)
GPU 版本的運行時間為 4.22 秒，幾乎加速了 2 倍。由於我們使用的是相同的算法，因此結果圖也與 CPU 版本完全相同。
"雷鋒網 AI 科技評論按，數據科學家需要算力。無論您是用 pandas 處理一個大數據集，還是用 Numpy 在一個大矩陣上運行一些計算，您都需要一臺強大的機器，以便在合理的時間內完成這項工作。
在過去的幾年中，數據科學家常用的 Python 庫已經非常擅長利用 CPU 能力。
Pandas 的基礎代碼是用 C 語言編寫的，它可以很好地處理大小超過 100GB 的數據集。如果您沒有足夠的 RAM 來容納這樣的數據集，那麼您可以使用分塊功能，它很方便，可以一次處理一個數據塊。
GPUs vs CPUs：並行處理
有了大量的數據，CPU 就不會切斷它了。
一個超過 100GB 的數據集將有許多數據點，數據點的數值在數百萬甚至數十億的範圍內。有了這麼多的數據點要處理，不管你的 CPU 有多快，它都沒有足夠的內核來進行有效的並行處理。如果你的 CPU 有 20 個內核（這將是相當昂貴的 CPU），你一次只能處理 20 個數據點！
CPU 在時鐘頻率更重要的任務中會更好——或者根本沒有 GPU 實現。如果你嘗試執行的流程有一個 GPU 實現，且該任務可以從並行處理中受益，那麼 GPU 將更加有效。
多核系統如何更快地處理數據。對於單核系統（左），所有 10 個任務都轉到一個節點。對於雙核系統（右），每個節點承擔 5 個任務，從而使處理速度加倍
深度學習已經在利用 GPU 方面發揮了相當大的作用。許多在深度學習中完成的卷積操作是重複的，因此在 GPU 上可以大大加速，甚至可以達到 100 次。
今天的數據科學沒有什麼不同，因為許多重複的操作都是在大數據集上執行的，庫中有 pandas、Numpy 和 scikit-learn。這些操作也不太複雜，無法在 GPU 上實現。
最後，還有一個解決方案。
用 Rapids 加速 GPU
Rapids 是一套軟件庫，旨在利用 GPU 加速數據科學。它使用低級別的 CUDA 代碼實現快速的、GPU 優化的算法，同時它上面還有一個易於使用的 Python 層。
Rapids 的美妙之處在於它與數據科學庫的集成非常順利，比如 pandas 數據幀就很容易通過 Rapids 實現 GPU 加速。下圖說明了 Rapids 如何在保持頂層易用性的同時實現低層的加速。
Rapids 利用了幾個 Python 庫：
cuDF-Python GPU 數據幀。它幾乎可以做 pandas 在數據處理和操作方面所能做的一切。
cuML-cuGraph 機器學習庫。它包含了 Scikit-Learn 擁有的許多 ML 算法，所有算法的格式都非常相似。
cuGraph-cuGraph 圖處理庫。它包含許多常見的圖分析算法，包括 PageRank 和各種相似性度量。
如何使用 Rapids
安裝
現在你將看到如何使用 Rapids！
要安裝它，請訪問這個網站，在這裡你將看到如何安裝 Rapids。你可以通過 Conda 將其直接安裝到你的機器上，或者簡單地使用 Docker 容器。
安裝時，可以設置系統規範，如 CUDA 版本和要安裝的庫。例如，我有 CUDA 10.0，想要安裝所有庫，所以我的安裝命令是：
conda install -c nvidia -c rapidsai -c numba -c conda-forge -c pytorch -c defaults cudf=0.8 cuml=0.8 cugraph=0.8 python=3.6 cudatoolkit=10.0
一旦命令完成運行，就可以開始用 GPU 加速數據科學了。
設置我們的數據
對於本教程，我們將介紹 DBSCAN demo 的修改版本。我將使用 Nvidia 數據科學工作站和 2 個 GPU 運行這個測試。
DBSCAN 是一種基於密度的聚類算法，可以自動對數據進行分類，而無需用戶指定有多少組數據。在 Scikit-Learn 中有它的實現。
我們將從獲取所有導入設置開始。先導入用於加載數據、可視化數據和應用 ML 模型的庫。
import os
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_circles
make_circles 函數將自動創建一個複雜的數據分佈，類似於我們將應用於 DBSCAN 的兩個圓。
讓我們從創建 100000 點的數據集開始，並在圖中可視化：
X, y = make_circles(n_samples=int(1e5), factor=.35, noise=.05)
X[:, 0] = 3*X[:, 0]
X[:, 1] = 3*X[:, 1]
plt.scatter(X[:, 0], X[:, 1])
plt.show
CPU 上的 DBSCAN
使用 Scikit-Learn 在 CPU 上運行 DBSCAN 很容易。我們將導入我們的算法並設置一些參數。
from sklearn.cluster import DBSCAN
db = DBSCAN(eps=0.6, min_samples=2)
我們現在可以通過調用 Scikit-Learn 中的一個函數對循環數據使用 DBSCAN。在函數前面加上一個「%」，就可以讓 Jupyter Notebook 測量它的運行時間。
%%time
y_db = db.fit_predict(X)
這 10 萬個點的運行時間是 8.31 秒，如下圖所示：
使用 Scikit-Learn 在 CPU 上運行 DBSCAN 的結果
GPU 上帶 Rapids 的 DBSCAN
現在，讓我們用 Rapids 進行加速！
首先，我們將把數據轉換為 pandas.DataFrame 並使用它創建一個 cudf.DataFrame。pandas.DataFrame 無縫轉換成 cudf.DataFrame，數據格式無任何更改。
import pandas as pd
import cudf
X_df = pd.DataFrame({'fea%d'%i: X[:, i] for i in range(X.shape[1])})
X_gpu = cudf.DataFrame.from_pandas(X_df)
然後我們將從 cuML 導入並初始化一個特殊版本的 DBSCAN，它是 GPU 加速的版本。DBSCAN 的 cuML 版本的函數格式與 Scikit-Learn 的函數格式完全相同：相同的參數、相同的樣式、相同的函數。
from cuml import DBSCAN as cumlDBSCAN
db_gpu = cumlDBSCAN(eps=0.6, min_samples=2)
最後，我們可以在測量運行時間的同時運行 GPU DBSCAN 的預測函數。
%%time
y_db_gpu = db_gpu.fit_predict(X_gpu)
GPU 版本的運行時間為 4.22 秒，幾乎加速了 2 倍。由於我們使用的是相同的算法，因此結果圖也與 CPU 版本完全相同。
使用 cuML 在 GPU 上運行 DBSCAN 的結果
使用 Rapids GPU 獲得超高速
我們從 Rapids 獲得的加速量取決於我們正在處理的數據量。一個好的經驗法則是，較大的數據集將更加受益於 GPU 加速。在 CPU 和 GPU 之間傳輸數據有一些開銷時間——對於較大的數據集，開銷時間變得更「值得」。
我們可以用一個簡單的例子來說明這一點。
我們將創建一個隨機數的 Numpy 數組並對其應用 DBSCAN。我們將比較常規 CPU DBSCAN 和 cuML 的 GPU 版本的速度，同時增加和減少數據點的數量，以瞭解它如何影響我們的運行時間。
下面的代碼說明如何進行測試：
import numpy as np
n_rows, n_cols = 10000, 100
X = np.random.rand(n_rows, n_cols)
print(X.shape)
X_df = pd.DataFrame({'fea%d'%i: X[:, i] for i in range(X.shape[1])})
X_gpu = cudf.DataFrame.from_pandas(X_df)
db = DBSCAN(eps=3, min_samples=2)
db_gpu = cumlDBSCAN(eps=3, min_samples=2)
%%time
y_db = db.fit_predict(X)
%%time
y_db_gpu = db_gpu.fit_predict(X_gpu)
檢查下面的 Matplotlib 結果圖：
"雷鋒網 AI 科技評論按，數據科學家需要算力。無論您是用 pandas 處理一個大數據集，還是用 Numpy 在一個大矩陣上運行一些計算，您都需要一臺強大的機器，以便在合理的時間內完成這項工作。
在過去的幾年中，數據科學家常用的 Python 庫已經非常擅長利用 CPU 能力。
Pandas 的基礎代碼是用 C 語言編寫的，它可以很好地處理大小超過 100GB 的數據集。如果您沒有足夠的 RAM 來容納這樣的數據集，那麼您可以使用分塊功能，它很方便，可以一次處理一個數據塊。
GPUs vs CPUs：並行處理
有了大量的數據，CPU 就不會切斷它了。
一個超過 100GB 的數據集將有許多數據點，數據點的數值在數百萬甚至數十億的範圍內。有了這麼多的數據點要處理，不管你的 CPU 有多快，它都沒有足夠的內核來進行有效的並行處理。如果你的 CPU 有 20 個內核（這將是相當昂貴的 CPU），你一次只能處理 20 個數據點！
CPU 在時鐘頻率更重要的任務中會更好——或者根本沒有 GPU 實現。如果你嘗試執行的流程有一個 GPU 實現，且該任務可以從並行處理中受益，那麼 GPU 將更加有效。
多核系統如何更快地處理數據。對於單核系統（左），所有 10 個任務都轉到一個節點。對於雙核系統（右），每個節點承擔 5 個任務，從而使處理速度加倍
深度學習已經在利用 GPU 方面發揮了相當大的作用。許多在深度學習中完成的卷積操作是重複的，因此在 GPU 上可以大大加速，甚至可以達到 100 次。
今天的數據科學沒有什麼不同，因為許多重複的操作都是在大數據集上執行的，庫中有 pandas、Numpy 和 scikit-learn。這些操作也不太複雜，無法在 GPU 上實現。
最後，還有一個解決方案。
用 Rapids 加速 GPU
Rapids 是一套軟件庫，旨在利用 GPU 加速數據科學。它使用低級別的 CUDA 代碼實現快速的、GPU 優化的算法，同時它上面還有一個易於使用的 Python 層。
Rapids 的美妙之處在於它與數據科學庫的集成非常順利，比如 pandas 數據幀就很容易通過 Rapids 實現 GPU 加速。下圖說明了 Rapids 如何在保持頂層易用性的同時實現低層的加速。
Rapids 利用了幾個 Python 庫：
cuDF-Python GPU 數據幀。它幾乎可以做 pandas 在數據處理和操作方面所能做的一切。
cuML-cuGraph 機器學習庫。它包含了 Scikit-Learn 擁有的許多 ML 算法，所有算法的格式都非常相似。
cuGraph-cuGraph 圖處理庫。它包含許多常見的圖分析算法，包括 PageRank 和各種相似性度量。
如何使用 Rapids
安裝
現在你將看到如何使用 Rapids！
要安裝它，請訪問這個網站，在這裡你將看到如何安裝 Rapids。你可以通過 Conda 將其直接安裝到你的機器上，或者簡單地使用 Docker 容器。
安裝時，可以設置系統規範，如 CUDA 版本和要安裝的庫。例如，我有 CUDA 10.0，想要安裝所有庫，所以我的安裝命令是：
conda install -c nvidia -c rapidsai -c numba -c conda-forge -c pytorch -c defaults cudf=0.8 cuml=0.8 cugraph=0.8 python=3.6 cudatoolkit=10.0
一旦命令完成運行，就可以開始用 GPU 加速數據科學了。
設置我們的數據
對於本教程，我們將介紹 DBSCAN demo 的修改版本。我將使用 Nvidia 數據科學工作站和 2 個 GPU 運行這個測試。
DBSCAN 是一種基於密度的聚類算法，可以自動對數據進行分類，而無需用戶指定有多少組數據。在 Scikit-Learn 中有它的實現。
我們將從獲取所有導入設置開始。先導入用於加載數據、可視化數據和應用 ML 模型的庫。
import os
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_circles
make_circles 函數將自動創建一個複雜的數據分佈，類似於我們將應用於 DBSCAN 的兩個圓。
讓我們從創建 100000 點的數據集開始，並在圖中可視化：
X, y = make_circles(n_samples=int(1e5), factor=.35, noise=.05)
X[:, 0] = 3*X[:, 0]
X[:, 1] = 3*X[:, 1]
plt.scatter(X[:, 0], X[:, 1])
plt.show
CPU 上的 DBSCAN
使用 Scikit-Learn 在 CPU 上運行 DBSCAN 很容易。我們將導入我們的算法並設置一些參數。
from sklearn.cluster import DBSCAN
db = DBSCAN(eps=0.6, min_samples=2)
我們現在可以通過調用 Scikit-Learn 中的一個函數對循環數據使用 DBSCAN。在函數前面加上一個「%」，就可以讓 Jupyter Notebook 測量它的運行時間。
%%time
y_db = db.fit_predict(X)
這 10 萬個點的運行時間是 8.31 秒，如下圖所示：
使用 Scikit-Learn 在 CPU 上運行 DBSCAN 的結果
GPU 上帶 Rapids 的 DBSCAN
現在，讓我們用 Rapids 進行加速！
首先，我們將把數據轉換為 pandas.DataFrame 並使用它創建一個 cudf.DataFrame。pandas.DataFrame 無縫轉換成 cudf.DataFrame，數據格式無任何更改。
import pandas as pd
import cudf
X_df = pd.DataFrame({'fea%d'%i: X[:, i] for i in range(X.shape[1])})
X_gpu = cudf.DataFrame.from_pandas(X_df)
然後我們將從 cuML 導入並初始化一個特殊版本的 DBSCAN，它是 GPU 加速的版本。DBSCAN 的 cuML 版本的函數格式與 Scikit-Learn 的函數格式完全相同：相同的參數、相同的樣式、相同的函數。
from cuml import DBSCAN as cumlDBSCAN
db_gpu = cumlDBSCAN(eps=0.6, min_samples=2)
最後，我們可以在測量運行時間的同時運行 GPU DBSCAN 的預測函數。
%%time
y_db_gpu = db_gpu.fit_predict(X_gpu)
GPU 版本的運行時間為 4.22 秒，幾乎加速了 2 倍。由於我們使用的是相同的算法，因此結果圖也與 CPU 版本完全相同。
使用 cuML 在 GPU 上運行 DBSCAN 的結果
使用 Rapids GPU 獲得超高速
我們從 Rapids 獲得的加速量取決於我們正在處理的數據量。一個好的經驗法則是，較大的數據集將更加受益於 GPU 加速。在 CPU 和 GPU 之間傳輸數據有一些開銷時間——對於較大的數據集，開銷時間變得更「值得」。
我們可以用一個簡單的例子來說明這一點。
我們將創建一個隨機數的 Numpy 數組並對其應用 DBSCAN。我們將比較常規 CPU DBSCAN 和 cuML 的 GPU 版本的速度，同時增加和減少數據點的數量，以瞭解它如何影響我們的運行時間。
下面的代碼說明如何進行測試：
import numpy as np
n_rows, n_cols = 10000, 100
X = np.random.rand(n_rows, n_cols)
print(X.shape)
X_df = pd.DataFrame({'fea%d'%i: X[:, i] for i in range(X.shape[1])})
X_gpu = cudf.DataFrame.from_pandas(X_df)
db = DBSCAN(eps=3, min_samples=2)
db_gpu = cumlDBSCAN(eps=3, min_samples=2)
%%time
y_db = db.fit_predict(X)
%%time
y_db_gpu = db_gpu.fit_predict(X_gpu)
檢查下面的 Matplotlib 結果圖：
當使用 GPU 而不是 CPU 時，數量會急劇增加。即使在 10000 點（最左邊），我們的速度仍然是 4.54x。在更高的一端，1 千萬點，我們切換到 GPU 時的速度是 88.04x！
Via：https://www.kdnuggets.com/2019/07/accelerate-data-science-on-gpu.html
雷鋒網雷鋒網
"