import numpy as np

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

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

import torch

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

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

# NumPy數(shù)組運(yùn)算
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張量運(yùn)算
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)

# NumPy不支持自動(dòng)微分，需要手動(dòng)計(jì)算導(dǎo)數(shù)
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支持自動(dòng)微分
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)

# NumPy需要額外的庫(kù)（如CuPy）才能實(shí)現(xiàn)GPU加速

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

# NumPy通常用于傳統(tǒng)的科學(xué)計(jì)算，沒(méi)有專門(mén)的深度學(xué)習(xí)模塊

# PyTorch提供了高級(jí)的神經(jīng)網(wǎng)絡(luò)構(gòu)建接口
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()

import numpy as np

# NumPy中的手動(dòng)微分
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)

import torch

# PyTorch中的自動(dòng)微分
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中使用梯度下降
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()
    
    # 使用梯度下降更新參數(shù)
    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)

import torch
import torch.nn as nn

# 定義神經(jīng)網(wǎng)絡(luò)
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

# 創(chuàng)建模型實(shí)例
model = SimpleNet()

import torch.optim as optim

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

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

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

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

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

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

import torch

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

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

import cupy as np  # 使用CuPy代替NumPy

# 創(chuàng)建CuPy數(shù)組
array_on_gpu = np.array([1, 2, 3])

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

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

# 將模型和數(shù)據(jù)移動(dòng)到GPU
model.to(device)

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

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

import torch
import torch.nn as nn

# 定義一個(gè)簡(jiǎn)單的模型
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()

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

# 或者只保存模型的參數(shù)
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'))

import numpy as np
from sklearn.externals import joblib

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

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

import torch

# 定義并導(dǎo)出模型為T(mén)orchScript
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")

import torch
import torch.onnx

# 定義并導(dǎo)出模型為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)

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

# 可以使用ONNX Runtime或其他支持ONNX的庫(kù)來(lái)部署模型

import numpy as np

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

import torch
import torch.nn as nn

# PyTorch神經(jīng)網(wǎng)絡(luò)
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)

import torch

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

import numpy as np

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

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)

import torch
import torch.nn as nn

# PyTorch代碼注釋
class SimpleNet(nn.Module):
    def __init__(self):
        """
        構(gòu)造函數(shù)，定義神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)。
        """
        super(SimpleNet, self).__init__()
        self.fc = nn.Linear(3, 1)

    def forward(self, x):
        """
        前向傳播函數(shù)，定義數(shù)據(jù)如何在網(wǎng)絡(luò)中傳播。
        """
        return self.fc(x)

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