Pytorch Workflow with Regression

import torch from torch import nn # nn contains all of PyTorch's building blocks for neural networks import matplotlib.pyplot as plt plt.ion() # Check PyTorch version > torch.__version__ 2.4.0+cu121

# Create train/test split train_split = int(0.8 * len(X)) # 80% of data used for training set, 20% for testing X_train, y_train = X[:train_split], y[:train_split] X_test, y_test = X[train_split:], y[train_split:] > len(X_train), len(y_train), len(X_test), len(y_test) (40, 40, 10, 10)

def plot_predictions( train_data=X_train, train_labels=y_train, test_data=X_test, test_labels=y_test, predictions=None): """ Plots training data, test data and compares predictions. """ plt.figure(figsize=(10, 7)) # Plot training data in blue plt.scatter(train_data, train_labels, c="b", s=4, label="Training data") # Plot test data in green plt.scatter(test_data, test_labels, c="g", s=4, label="Testing data") if predictions is not None: # Plot the predictions in red (predictions were made on the test data) plt.scatter(test_data, predictions, c="r", s=4, label="Predictions") # Show the legend plt.legend(prop={"size": 14}); plot_predictions();

# 선형 회귀 모델 클래스를 생성 class LinearRegressionModel(nn.Module): # <- PyTorch에서 거의 모든 것은 nn.Module을 상속받아 만듦 # (신경망의 기본 블록이라고 생각할 수 있음) def __init__(self): # super().__init__() -> 부모 클래스를 인스턴스화 super().__init__() # 가중치(weights)를 초기화 -> 랜덤 값으로 생성 self.weights = nn.Parameter(torch.randn(1, # <- 학습이 진행되면서 조정될 가중치를 무작위 값으로 설정 dtype=torch.float), # <- PyTorch는 기본적으로 float32 형식을 사용 requires_grad=True) # <- 이 값을 경사하강법(gradient descent)으로 업데이트할 수 있는가? # 편향(bias)을 초기화 -> 랜덤 값으로 생성 self.bias = nn.Parameter(torch.randn(1, # <- 학습이 진행되면서 조정될 편향을 무작위 값으로 설정 dtype=torch.float), # <- PyTorch는 기본적으로 float32 형식을 사용 requires_grad=True) # <- 이 값을 경사하강법으로 업데이트할 수 있는가? # forward는 모델에서 계산 과정을 정의 def forward(self, x: torch.Tensor) -> torch.Tensor: # <- "x"는 입력 데이터 (예: 훈련 또는 테스트 데이터의 특징) # 선형 회귀 공식 pred = self.weights * x + self.bias # <- 이것은 선형 회귀 공식 (y = m*x + b) return pred # 선형 회귀 모델의 예측값을 반환

# 생성한 nn.Module 서브클래스 내의 nn.Parameter들을 확인한다 > list(model_0.parameters()) [Parameter containing: tensor([0.3367], requires_grad=True), Parameter containing: tensor([0.1288], requires_grad=True)] # List named parameters > model_0.state_dict() OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])

# Make predictions with model # with torch.no_grad()와 의미가 같다!!! # -> 모델의 파라미터가 변경되는 것을 방지한다. with torch.inference_mode(): y_preds = model_0(X_test)

# Check the predictions > print(f"Number of testing samples: {len(y_test)}") > print(f"Number of predictions made: {len(y_preds)}") Number of testing samples: 10 Number of predictions made: 10 > plot_predictions(predictions=y_preds)

# Create the loss function loss_fn = nn.L1Loss() # MAE loss is same as L1Loss >> L2Loss(Mean Squared Error): nn.MSELoss

# 재현성을 위해 랜덤 시드를 설정한다 torch.manual_seed(42) # 에폭 수를 설정한다 (모델이 학습 데이터를 몇 번 반복해서 학습할지 결정한다) epochs = 100 # 손실 값을 추적하기 위해 빈 리스트를 생성한다 train_loss_values = [] test_loss_values = [] epoch_count = [] for epoch in range(epochs): ######################################################################### ### 학습 루프 ######################################################################### # 모델을 학습 모드로 전환한다 (모델의 기본 상태이다) model_0.train() # 1. 학습 데이터에 대해 순전파를 수행한다 (forward() 메서드를 사용한다) y_pred = model_0(X_train) # print(y_pred) # 2. 손실을 계산한다 (모델의 예측과 실제 값의 차이를 측정한다) loss = loss_fn(y_pred, y_train) # 3. 옵티마이저의 기울기를 초기화한다 optimizer.zero_grad() # 4. 손실에 대해 역전파를 수행한다 loss.backward() # 5. 옵티마이저를 업데이트한다 optimizer.step() ######################################################################### ### 테스트 루프 ######################################################################### # 모델을 평가 모드로 전환한다 model_0.eval() with torch.inference_mode(): # 1. 테스트 데이터에 대해 순전파를 수행한다 test_pred = model_0(X_test) # 2. 테스트 데이터에 대한 손실을 계산한다 test_loss = loss_fn(test_pred, y_test.type(torch.float)) # 예측값은 torch.float 데이터 타입으로 나오므로, 비교는 동일한 타입의 텐서로 수행해야 한다 # 진행 상황을 출력한다 if epoch % 10 == 0: epoch_count.append(epoch) # loss.detach() -> loss가 포함된 텐서를 현재 디바이스에서 분리한다 # loss.detach().numpy() -> torch 텐서를 numpy 배열로 변환한다 train_loss_values.append(loss.detach().numpy()) test_loss_values.append(test_loss.detach().numpy()) print(f"Epoch: {epoch} | MAE Train Loss: {loss} | MAE Test Loss: {test_loss} ")

# Plot the loss curves plt.plot(epoch_count, train_loss_values, label="Train loss") plt.plot(epoch_count, test_loss_values, label="Test loss") plt.title("Training and test loss curves") plt.ylabel("Loss") plt.xlabel("Epochs") plt.legend();

# Find our model's learned parameters print("The model learned the following values for weights and bias:") print(model_0.state_dict()) print("\nAnd the original values for weights and bias are:") print(f"weights: {weight}, bias: {bias}")

The model learned the following values for weights and bias: OrderedDict([('weights', tensor([0.5784])), ('bias', tensor([0.3513]))]) And the original values for weights and bias are: weights: 0.7, bias: 0.3

# 1. 모델을 평가 모드로 전환한다 model_0.eval() # 2. 추론 모드 컨텍스트 매니저를 설정한다 with torch.inference_mode(): # 3. 모델과 데이터가 동일한 디바이스에서 계산되도록 한다 # 현재는 디바이스에 독립적인 코드를 설정하지 않았으므로, 데이터와 모델은 기본적으로 CPU에 있다 # model_0.to(device) # X_test = X_test.to(device) y_preds = model_0(X_test) > y_preds[:5] tensor([[0.8141], [0.8256], [0.8372], [0.8488], [0.8603]]) > plot_predictions(predictions=y_preds)

from pathlib import Path # 1. 모델 디렉토리를 생성한다 MODEL_PATH = Path("models") MODEL_PATH.mkdir(parents=True, exist_ok=True) # mkdir: 디렉토리를 생성한다 # 2. 모델 저장 경로를 생성한다 MODEL_NAME = "01_pytorch_workflow_model_0.pth" MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME # 3. 모델의 상태 사전을 저장한다 print(f"모델을 다음 경로에 저장한다: {MODEL_SAVE_PATH}") torch.save(obj=model_0.state_dict(), # state_dict()만 저장하면 모델이 학습한 파라미터들만 저장된다 f=MODEL_SAVE_PATH)

> model_0.state_dict() OrderedDict([('weights', tensor([0.5784])), ('bias', tensor([0.3513]))])

# Instantiate a new instance of our model (this will be instantiated with random weights) # 학습하지 않은 모델 생성 loaded_model_0 = LinearRegressionModel() # 학습하지 않은 모델의 파라미터 확인 > loaded_model_0.state_dict() OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])

# Load the state_dict of our saved model (this will update the new instance of our model with trained weights) # 이미 학습된 모델의 파라미터 적용 loaded_model_0.load_state_dict(torch.load(f=MODEL_SAVE_PATH)) # 이미 학습된 모델 파라미터 적용 확인 > loaded_model_0.state_dict() OrderedDict([('weights', tensor([0.5784])), ('bias', tensor([0.3513]))])

# 1. 로드한 모델을 평가 모드로 전환한다 loaded_model_0.eval() # 2. 추론 모드 컨텍스트 매니저를 사용하여 예측을 수행한다 with torch.inference_mode(): loaded_model_preds = loaded_model_0(X_test) # 로드한 모델로 테스트 데이터에 대해 순전파를 수행한다 # Compare previous model predictions with loaded model predictions (these should be the same) > y_preds == loaded_model_preds tensor([[True], [True], [True], [True], [True], [True], [True], [True], [True], [True]])