PyTorch和NumPy深度比較！！！

作者：小壯 2024-01-10 14:17:52

人工智能深度學習

很多人對pytorch和numpy的邊界感是模糊的，咱們今兒就從幾方面進行整理和詳細的說明。

嗨，我是小壯！

太多人催著讓更新pytorch的內容了，我們最近總結了不少東西。

包括實用的一些操作，還有一些總結性的內容。

很多人對pytorch和numpy的邊界感是模糊的，咱們今兒就從幾方面進行整理和詳細的說明。

每塊知識點從簡單對比到實際代碼的對比，值得收藏起來慢慢看~

所有的內容，咱們從下面幾個要點進行了對比：

深度學習支持： PyTorch專注于深度學習任務，提供了動態計算圖和內置的神經網絡接口，而NumPy主要用于傳統的科學計算，缺深度學習模塊。
自動微分： PyTorch具有自動微分功能，使得在構建和訓練神經網絡時更加靈活，而NumPy需要手動計算導數。
GPU加速： PyTorch內置GPU支持，使得在GPU上進行張量計算和模型訓練更為便捷，而NumPy需要額外的庫（如CuPy）才能實現GPU加速。
模型部署： PyTorch提供了TorchScript和ONNX等工具，便于模型導出和部署，而NumPy通常需要額外的庫和手動工作來實現模型的導出和部署。

總之，最顯著的一點，就是NumPy主要負責數據的計算，而PyTorch更適用于深度學習任務，提供了更豐富的工具和接口。

具體分為 6 大部分，涉及到：

張量計算
自動微分
深度學習支持
GPU加速
模型部署
代碼風格

來吧，一起看看~

一、張量計算

NumPy：主要用于數組操作，不提供專門的張量計算功能。NumPy數組是靜態的，不支持自動微分。
PyTorch：提供了動態計算圖和自動微分，使其更適合深度學習任務。PyTorch的張量計算功能更靈活，可以輕松構建神經網絡模型。

張量計算是PyTorch和NumPy的一個關鍵方面，因為兩者都涉及對多維數組（張量）進行操作。

1. 張量的創建

NumPy:

import numpy as np

# 創建NumPy數組
np_array = np.array([[1, 2, 3], [4, 5, 6]])

# 查看數組屬性
print("NumPy Array:")
print(np_array)
print("Shape:", np_array.shape)

PyTorch:

import torch

# 創建PyTorch張量
torch_tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 查看張量屬性
print("PyTorch Tensor:")
print(torch_tensor)
print("Shape:", torch_tensor.shape)

2. 張量的運算

NumPy:

# NumPy數組運算
np_array1 = np.array([[1, 2, 3], [4, 5, 6]])
np_array2 = np.array([[7, 8, 9], [10, 11, 12]])

result_np = np_array1 + np_array2  # 或者使用 np.add(np_array1, np_array2)
print("NumPy Array Addition:")
print(result_np)

PyTorch:

# PyTorch張量運算
torch_tensor1 = torch.tensor([[1, 2, 3], [4, 5, 6]])
torch_tensor2 = torch.tensor([[7, 8, 9], [10, 11, 12]])

result_torch = torch_tensor1 + torch_tensor2  # 或者使用 torch.add(torch_tensor1, torch_tensor2)
print("PyTorch Tensor Addition:")
print(result_torch)

3. 自動微分

NumPy:

# NumPy不支持自動微分，需要手動計算導數
x_np = np.array([2.0], dtype=float)
y_np = x_np**2
dy_dx_np = 2 * x_np
print("NumPy Manual Differentiation:")
print("Input:", x_np)
print("Output:", y_np)
print("Derivative:", dy_dx_np)

PyTorch:

# PyTorch支持自動微分
x_torch = torch.tensor([2.0], requires_grad=True)
y_torch = x_torch**2
y_torch.backward()
dy_dx_torch = x_torch.grad
print("PyTorch Autograd:")
print("Input:", x_torch)
print("Output:", y_torch)
print("Derivative:", dy_dx_torch)

4. GPU加速

NumPy:

# NumPy需要額外的庫（如CuPy）才能實現GPU加速

PyTorch:

# PyTorch內置GPU支持
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
torch_tensor = torch_tensor.to(device)

5. 模型構建

NumPy:

# NumPy通常用于傳統的科學計算，沒有專門的深度學習模塊

PyTorch:

# PyTorch提供了高級的神經網絡構建接口
import torch.nn as nn

class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(3, 1)

    def forward(self, x):
        return self.fc(x)

model = SimpleModel()

這些示例突顯了PyTorch在深度學習任務中的優勢，特別是在自動微分和GPU加速方面。然而，在傳統科學計算任務中，NumPy仍然是一種非常強大和廣泛使用的工具。

二、自動微分

NumPy：不具備自動微分功能，需要手動計算導數。
PyTorch：提供了動態計算圖和自動微分，使得在神經網絡中反向傳播更加容易和直觀。

自動微分允許計算圖中的變量自動計算梯度。在這方面，PyTorch和NumPy有著顯著的差異。

大家可以從基本操作方面進行對比，numpy只能是手動微分。

1. 自動微分

NumPy： NumPy不具備內建的自動微分功能。如果想要計算梯度，需要手動進行導數計算或者使用數值方法，例如有限差分。
PyTorch： PyTorch使用動態計算圖來實現自動微分。每當執行一個操作時，PyTorch會在后臺構建計算圖，并且可以通過反向傳播來自動計算梯度。

2. NumPy中的手動微分

import numpy as np

# NumPy中的手動微分
x_np = np.array([2.0], dtype=float)
y_np = x_np**2
dy_dx_np = 2 * x_np
print("NumPy Manual Differentiation:")
print("Input:", x_np)
print("Output:", y_np)
print("Derivative:", dy_dx_np)

在NumPy中，需要手動計算導數。上述示例演示了對函數 y=x^2 進行手動微分的過程。

3. PyTorch中的自動微分

import torch

# PyTorch中的自動微分
x_torch = torch.tensor([2.0], requires_grad=True)
y_torch = x_torch**2
y_torch.backward()
dy_dx_torch = x_torch.grad
print("PyTorch Autograd:")
print("Input:", x_torch)
print("Output:", y_torch)
print("Derivative:", dy_dx_torch)

在PyTorch中，只需將requires_grad設置為True，然后執行前向計算和backward()即可自動計算梯度。grad屬性保存了計算得到的梯度。

4. 動態計算圖

NumPy： NumPy使用靜態計算圖，因為它在計算之前需要完全定義好操作。
PyTorch： PyTorch使用動態計算圖，這意味著計算圖是在運行時構建的，可以根據需要進行靈活的更改。

5. 更復雜的示例 - 梯度下降

# PyTorch中使用梯度下降
learning_rate = 0.1
num_iterations = 100

x_torch = torch.tensor([2.0], requires_grad=True)

for _ in range(num_iterations):
    y_torch = x_torch**2
    y_torch.backward()
    
    # 使用梯度下降更新參數
    x_torch.data = x_torch.data - learning_rate * x_torch.grad.data
    
    # 梯度清零
    x_torch.grad.zero_()

print("Final Result after Gradient Descent:", x_torch.data)

這個示例演示了如何使用梯度下降優化一個簡單的函數（y=x^2）的參數。PyTorch通過自動微分提供了方便的方式來計算和應用梯度。在每次迭代中，backward()計算梯度，然后通過梯度下降更新參數。

三、深度學習支持

NumPy：主要用于傳統的科學計算，沒有專門的深度學習模塊。
PyTorch：專注于深度學習任務，提供了高級的神經網絡構建和訓練接口，如torch.nn和torch.optim等。

PyTorch專注于深度學習任務，提供了高級的神經網絡構建和訓練接口，而NumPy則更適用于傳統的科學計算。

1. 神經網絡構建

NumPy主要用于數組操作和科學計算，沒有內建的深度學習模塊。構建神經網絡需要手動實現網絡層和激活函數。 PyTorch提供了torch.nn模塊，其中包含了各種預定義的網絡層和激活函數。

import torch
import torch.nn as nn

# 定義神經網絡
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(10, 5)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(5, 1)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 創建模型實例
model = SimpleNet()

2. 損失函數和優化器

NumPy中，需要手動實現損失函數和優化器。通常需要使用梯度下降等優化算法。PyTorch提供了各種內建的損失函數和優化器，使得訓練過程更加簡單。

以下是一個簡單的訓練過程的例子：

import torch.optim as optim

# 定義損失函數和優化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 訓練過程
for epoch in range(num_epochs):
    # 前向傳播
    outputs = model(inputs)
    loss = criterion(outputs, targets)

    # 反向傳播和優化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

3. 自動微分和反向傳播

NumPy不支持自動微分和反向傳播。需要手動計算梯度并實現反向傳播過程。PyTorch的動態計算圖和自動微分使得反向傳播變得簡單。在上述示例中，通過loss.backward()即可自動計算梯度并進行反向傳播。

4. GPU加速

NumPy需要額外的庫（如CuPy）才能實現GPU加速。PyTorch內置GPU支持，可以直接在GPU上執行張量計算和模型訓練。以下是將模型移動到GPU的例子：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

5. 模型保存和加載

NumPy：保存和加載模型需要手動實現，通常使用NumPy的np.save和np.load。
PyTorch： PyTorch提供了方便的模型保存和加載接口。以下是一個保存和加載模型的例子：

# 保存模型
torch.save(model.state_dict(), 'model.pth')

# 加載模型
model.load_state_dict(torch.load('model.pth'))

四、GPU加速

NumPy：原生NumPy不支持GPU加速，但可以通過一些擴展庫如CuPy來實現。
PyTorch：內置GPU支持，可以直接在GPU上執行張量計算，提高深度學習模型的訓練速度。

GPU加速是在深度學習中提高計算速度的重要因素之一。在這方面，PyTorch和NumPy有一些顯著的差異。

以下是關于GPU加速的詳細闡述和代碼比較：

1. GPU加速概念

NumPy： NumPy本身不支持GPU加速。如果需要在GPU上執行操作，可能需要使用額外的庫，如CuPy，來替代NumPy數組。
PyTorch： PyTorch內置了對CUDA（NVIDIA GPU加速）的支持，可以直接在GPU上執行張量計算和模型訓練。

2. 在PyTorch中使用GPU

import torch

# 檢查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 創建張量并將其移動到GPU
tensor_on_cpu = torch.tensor([1, 2, 3])
tensor_on_gpu = tensor_on_cpu.to(device)

上述代碼演示了如何檢查GPU是否可用，并將PyTorch張量移動到GPU上。這是使用PyTorch進行GPU加速的基本步驟。

3. 在NumPy中使用GPU（使用CuPy）

import cupy as np  # 使用CuPy代替NumPy

# 創建CuPy數組
array_on_gpu = np.array([1, 2, 3])

在NumPy的情況下，可以通過使用CuPy來實現GPU加速。CuPy提供了與NumPy相似的接口，但在GPU上執行相應的操作。

4. PyTorch中的GPU加速訓練

import torch
import torch.nn as nn
import torch.optim as optim

# 創建模型和數據
model = nn.Linear(5, 1)
data = torch.randn((100, 5)).to(device)
target = torch.randn((100, 1)).to(device)

# 將模型和數據移動到GPU
model.to(device)

# 定義損失函數和優化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 在GPU上進行訓練
for epoch in range(num_epochs):
    outputs = model(data)
    loss = criterion(outputs, target)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

上述代碼演示了如何在PyTorch中進行GPU加速的訓練。在這個例子中，模型、輸入數據和目標數據都被移動到GPU上。

5. NumPy與PyTorch GPU加速性能比較

在涉及大規模數據和復雜模型的深度學習任務中，PyTorch的GPU加速通常更為方便且性能更好。這主要是因為PyTorch在設計時就考慮了深度學習任務的需求，而NumPy更專注于通用科學計算。

五、模型部署

NumPy：針對模型的部署可能需要將代碼轉換為其他框架或使用專門的工具。
PyTorch：提供了一些工具（如TorchScript），可以將模型導出為可在不同環境中運行的形式，便于部署。

模型部署是將訓練好的深度學習模型應用于實際生產環境的過程。在這方面，PyTorch和NumPy有一些區別，尤其是在模型導出和部署上。

以下是關于模型部署的詳細闡述和代碼比較：

1. PyTorch中的模型保存和加載

在PyTorch中，可以使用torch.save和torch.load來保存和加載整個模型或者模型的參數。

import torch
import torch.nn as nn

# 定義一個簡單的模型
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

model = SimpleModel()

# 保存整個模型
torch.save(model, 'model.pth')

# 或者只保存模型的參數
torch.save(model.state_dict(), 'model_params.pth')

# 加載模型
loaded_model = torch.load('model.pth')
loaded_model_params = SimpleModel()
loaded_model_params.load_state_dict(torch.load('model_params.pth'))

2. NumPy中的模型保存和加載

在NumPy中，可以使用numpy.save和numpy.load來保存和加載NumPy數組，但對于模型保存，通常需要使用其他庫，如Joblib。

import numpy as np
from sklearn.externals import joblib

# 使用Joblib保存和加載模型
model = ...  # 的模型
joblib.dump(model, 'model.joblib')

loaded_model = joblib.load('model.joblib')

3. TorchScript

PyTorch引入了TorchScript，它允許將PyTorch模型導出為一種中間表示形式，可以在不同的環境中運行。這對于模型的部署提供了更靈活的選擇。

import torch

# 定義并導出模型為TorchScript
class SimpleModel(torch.jit.ScriptModule):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = torch.nn.Linear(10, 1)

    @torch.jit.script_method
    def forward(self, x):
        return self.fc(x)

model = SimpleModel()
traced_model = torch.jit.trace(model, torch.rand(1, 10))

# 保存TorchScript模型
traced_model.save("traced_model.pt")

# 加載TorchScript模型
loaded_model = torch.jit.load("traced_model.pt")

4. ONNX

ONNX（Open Neural Network Exchange）是一種開放標準，允許在不同深度學習框架之間共享模型。PyTorch可以將模型導出為ONNX格式。

import torch
import torch.onnx

# 定義并導出模型為ONNX
class SimpleModel(torch.nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = torch.nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

model = SimpleModel()
dummy_input = torch.randn(1, 10)

# 導出模型為ONNX
torch.onnx.export(model, dummy_input, "model.onnx", verbose=True)

# 可以使用ONNX Runtime或其他支持ONNX的庫來部署模型

5. 部署時的注意事項

依賴項：確保部署環境中安裝了正確的依賴項，包括PyTorch或NumPy。
硬件兼容性：確保部署環境的硬件兼容于模型。例如，如果模型在GPU上訓練，確保部署環境中有相應的GPU。
推理速度：對于大規模部署，考慮使用模型量化、剪枝等技術以減小模型大小和提高推理速度。

總之，PyTorch提供了更多用于模型導出和部署的工具和庫，使得在不同環境中更容易進行部署。NumPy在這方面相對更為基礎，通常需要額外的工作來實現模型的導出和部署。

六、代碼風格

NumPy：通常使用面向過程的編程風格。
PyTorch：更加面向對象，利用PyTorch的torch.nn模塊進行模型構建。

代碼風格是編寫可讀性強、易于維護的代碼的一種約定。在深度學習中，PyTorch和NumPy在代碼風格上有一些區別。以下是關于代碼風格的詳細闡述和比較：

1. 代碼布局

NumPy： NumPy通常使用面向過程的編程風格。代碼布局可能更接近傳統的科學計算腳本，其中數組操作和數學運算在主程序中展開。

import numpy as np

# NumPy數組操作
array_a = np.array([1, 2, 3])
array_b = np.array([4, 5, 6])
result = array_a + array_b
print(result)

PyTorch： PyTorch更加面向對象，尤其是在構建神經網絡時，使用torch.nn模塊。代碼通常包含模型定義、訓練循環和評估等階段。

import torch
import torch.nn as nn

# PyTorch神經網絡
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(3, 1)

    def forward(self, x):
        return self.fc(x)

# 使用模型
model = SimpleNet()
input_data = torch.randn((10, 3))
output = model(input_data)
print(output)

2. 變量和張量命名

NumPy：變量命名通常采用小寫字母和下劃線，例如array_a。
PyTorch：張量和模型參數通常采用駝峰式命名，例如inputData或modelParameters。

3. 自動微分和梯度更新

NumPy： NumPy不支持自動微分和梯度更新。在手動計算導數時，變量和操作通常都在同一個塊中。
PyTorch： PyTorch的自動微分使得梯度更新更為直觀，通常涉及backward()和優化器的使用。

import torch

# PyTorch自動微分
x = torch.tensor([2.0], requires_grad=True)
y = x**2
y.backward()
print(x.grad)

4. 異常處理

NumPy：異常處理可能采用傳統的try和except語句。

import numpy as np

# NumPy異常處理
try:
    result = np.divide(1, 0)
except ZeroDivisionError as e:
    print("Error:", e)

PyTorch： PyTorch通常使用torch.nn.Module中的異常來處理模型參數等問題。

import torch
import torch.nn as nn

# PyTorch異常處理
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc = nn.Linear(3, 1)

model = MyModel()

try:
    output = model(torch.tensor([1, 2, 3]))
except nn.modules.module.ModuleAttributeError as e:
    print("Error:", e)

5. 代碼注釋

NumPy：注釋通常用于解釋復雜的算法或特殊的操作。
PyTorch：由于深度學習中涉及許多獨特的操作，注釋用于解釋模型結構、訓練步驟以及梯度更新等。

import torch
import torch.nn as nn

# PyTorch代碼注釋
class SimpleNet(nn.Module):
    def __init__(self):
        """
        構造函數，定義神經網絡結構。
        """
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(3, 1)

    def forward(self, x):
        """
        前向傳播函數，定義數據如何在網絡中傳播。
        """
        return self.fc(x)

# 使用模型
model = SimpleNet()
input_data = torch.randn((10, 3))
output = model(input_data)

總體而言，NumPy和PyTorch在代碼風格上有些許不同，因為它們分別用于傳統的科學計算和深度學習。

責任編輯：趙寧寧來源： DOWHAT小壯