import torch
 from torch.utils.data import DataLoader
 from torchvision import datasets, transforms
 
 # 定義圖像轉換
 transform = transforms.Compose([
     transforms.Resize((256, 256)),
     transforms.ToTensor(),
 ])
 
 # 加載數據集
 dataset = datasets.ImageFolder(root='path/to/data', transform=transform)
 
 # 使用 pin_memory=True 的 DataLoader  
 dataloader = DataLoader(
     dataset,
     batch_size=64,
     shuffle=True,
     num_workers=4,
     pin_memory=True  # 加快數據向 GPU 的傳輸速度  
 )
 
 # 數據傳輸至 GPU
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 for batch in dataloader:
     images, labels = batch
     images = images.to(device, non_blocking=True)  # 更快的傳輸
     # 訓練循環代碼

import torch
 from torch import nn  
 from torch.utils.data import DataLoader
 from torchvision import datasets, transforms
 
 # 多 GPU 設置
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
 # 示例網絡和 DataLoader 設置
 model = nn.DataParallel(nn.Linear(256*256*3, 10)).to(device)
 dataloader = DataLoader(
     datasets.ImageFolder('path/to/data', transform=transform),
     batch_size=64,
     shuffle=True,
     num_workers=4,
     pin_memory=True  # 為跨 GPU 的快速傳輸啟用
 )
 
 # 多 GPU 訓練循環
 for batch in dataloader:
     inputs, targets = batch
     inputs, targets = inputs.to(device, non_blocking=True), targets.to(device)
     outputs = model(inputs)
     # 其他訓練步驟

import torch  
 from torchvision import transforms
 from PIL import Image
 
 # 定義實時推理的圖像轉換
 transform = transforms.Compose([
     transforms.Resize((256, 256)),
     transforms.ToTensor()
 ])
 
 # 加載圖像并固定內存  
 def load_image(image_path):
     image = Image.open(image_path)
     image = transform(image).unsqueeze(0)
     return image.pin_memory()  # 為推理顯式固定內存
 
 # 實時推理
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  
 model = torch.load('model.pth').to(device).eval()
 
 def infer(image_path):
     image = load_image(image_path)
     with torch.no_grad():
         image = image.to(device, non_blocking=True)
         output = model(image)
     return output
 
 # 運行推理
 output = infer('path/to/image.jpg')
 print("推理結果:", output)

import torch
 from torch.utils.data import DataLoader, TensorDataset
 
 # 小數據集示例
 data = torch.randn(100, 10)  # 100 個樣本, 10 個特征
 labels = torch.randint(0, 2, (100,))
 
 # 數據集和 DataLoader 設置
 dataset = TensorDataset(data, labels)  
 dataloader = DataLoader(dataset, batch_size=10, shuffle=True, pin_memory=True)
 
 # 簡單的基于 CPU 的模型
 model = torch.nn.Linear(10, 2)
 
 # 在 CPU 上的訓練循環  
 device = torch.device('cpu')
 for batch_data, batch_labels in dataloader:
     batch_data, batch_labels = batch_data.to(device), batch_labels.to(device)
     # 前向傳遞
     outputs = model(batch_data)
     # 執行其他訓練步驟

import torch
 from torch.utils.data import DataLoader, TensorDataset  
 import torch.utils.benchmark as benchmark
 
 # 用于基準測試的大型數據集
 data = torch.randn(10000, 256)
 labels = torch.randint(0, 10, (10000,))
 dataset = TensorDataset(data, labels)
 
 # 使用 pin_memory=True 和 pin_memory=False 進行基準測試
 def benchmark_loader(pin_memory):
     dataloader = DataLoader(dataset, batch_size=128, pin_memory=pin_memory)
     device = torch.device('cuda')
         
     def load_batch():
         for batch_data, _ in dataloader:
             batch_data = batch_data.to(device, non_blocking=True)
 
     return benchmark.Timer(stmt="load_batch()", globals={"load_batch": load_batch}).timeit(10)
 
 # 結果  
 time_with_pin_memory = benchmark_loader(pin_memory=True)
 time_without_pin_memory = benchmark_loader(pin_memory=False)
 
 print(f"使用 pin_memory=True 的時間: {time_with_pin_memory}")
 print(f"使用 pin_memory=False 的時間: {time_without_pin_memory}")

import torch
 from torch.utils.data import DataLoader, TensorDataset
 from torch.autograd import profiler
 
 # 示例數據集
 data = torch.randn(10000, 256)  
 labels = torch.randint(0, 10, (10000,))
 dataset = TensorDataset(data, labels)
 dataloader = DataLoader(dataset, batch_size=128, pin_memory=True)
 
 # 使用 pin_memory=True 分析數據傳輸
 device = torch.device('cuda')
 
 def load_and_transfer():
     for batch_data, _ in dataloader:
         batch_data = batch_data.to(device, non_blocking=True)
 
 with profiler.profile(record_shapes=True) as prof:  
     load_and_transfer()
 
 # 顯示分析結果
 print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))