파이토치로 구현한 선형 회귀

선형회귀란?

선형회귀(Linear Regression)는 독립변수 X와 종속변수 Y 사이의 선형 관계를 모델링하는 가장 기본적인 머신러닝 알고리즘 중 하나입니다. 일반적으로 아래의 수식으로 표현됩니다.

여기서:

• W: 가중치(Weight)
• b: 편향(Bias)
• x: 입력 값

PyTorch를 사용해 단순 선형회귀와 다중 선형회귀를 구현해보겠습니다.

1. 선형 회귀 분석

선형 회귀 분석(Linear Regression)은 주어진 데이터에서 입력 변수(독립 변수)와 출력 변수(종속 변수) 사이의 관계를 직선(또는 다차원에서는 평면)으로 설명하고, 새로운 입력 값에 대한 출력을 예측하는 통계 및 머신러닝 기법입니다. 예를 들어, 공부 시간(입력 변수)과 시험 점수(출력 변수) 사이의 관계를 분석해 "공부 시간이 늘어날수록 시험 점수가 증가한다"는 패턴을 찾아냅니다. 이 과정에서 선형 회귀는 "Y = W X + b"라는 수식(기울기 W와 절편 b)으로 데이터를 표현하며, 최적의 기울기와 절편을 찾기 위해 비용 함수(Cost Function)를 최소화하는 경사 하강법(Gradient Descent) 등의 알고리즘을 사용합니다. 최종적으로 선형 회귀 모델은 주어진 입력 값에 대해 가장 적합한 예측 결과를 제공합니다.

 

2. 단항 선형 회귀

단항 선형 회귀(Simple Linear Regression)는 하나의 독립 변수(입력 변수, X)를 사용하여 하나의 종속 변수(출력 변수, Y)를 예측하는 통계 및 머신러닝 기법입니다. 입력 변수와 출력 변수 사이의 관계를 직선(Linear Line)으로 나타내며, 데이터의 패턴을 기반으로 가장 잘 맞는 직선을 찾아내어 새로운 입력 값에 대한 출력을 예측합니다.

 

 

먼저, 학습에 사용할 데이터를 정의합니다.

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

torch.manual_seed(2025)  # 랜덤 값 고정

x_train = torch.FloatTensor([[1], [2], [3]])  # 독립 변수
y_train = torch.FloatTensor([[2], [4], [6]])  # 종속 변수

 

• x: 1, 2, 3
• y: 2, 4, 6
• xx와 y는 각각 1차원 벡터로 PyTorch의 FloatTensor 형태로 정의됩니다

 

 

print(x_train, x_train.shape)
print(y_train, y_train.shape)

(2) 데이터 시각화

matplotlib를 이용해 데이터를 시각화합니다.

plt.figure(figsize=(6, 4))
plt.scatter(x_train, y_train)

(3) 모델 정의

PyTorch의 nn.Linear를 사용해 선형 모델을 정의합니다.

# y = Wx + b
model = nn.Linear(1,1) # 입력 특성의 수, 출력 특성의 수
print(model)

 

• 모델은 y=Wx+b 형태의 단순 선형회귀를 구현합니다.
• in_features는 입력 데이터의 차원 수, out_features는 출력 데이터의 차원 수를 의미합니다.

(4) 모델 초기 출력 확인

정의된 모델로 y 예측 값을 계산합니다.

y_pred = model(x_train)
print(y_pred)

 

초기 파라미터(W, b)는 랜덤값이므로 ypredy_predyp​red는 올바른 값과 다를 수 있습니다.

print(list(model.parameters()))  # 초기 W와 b 확인

y=0.3699 × x+0.8711

 

손실 함수

손실 함수(Loss Function)는 머신러닝과 딥러닝 모델이 예측한 값과 실제 값 사이의 차이를 수치적으로 나타내는 함수입니다. 모델이 학습을 통해 최적의 결과를 도출하려면 이 차이를 최소화해야 합니다. 손실 함수는 예측값과 실제값의 오차를 계산하여 하나의 숫자(스칼라 값)로 반환하며, 이 값은 비용(Cost) 또는 오차(Error)라고도 불립니다. 예를 들어, 회귀 문제에서는 주로 평균 제곱 오차(MSE, Mean Squared Error)를 사용하여 예측값과 실제값 간의 평균적인 차이를 측정하고, 분류 문제에서는 교차 엔트로피 손실(Cross-Entropy Loss)을 사용해 예측 확률 분포와 실제 레이블 분포 간의 차이를 계산합니다. 손실 함수가 반환한 값은 역전파(Backpropagation)를 통해 모델의 가중치와 편향을 조정하는 데 사용됩니다. 즉, 손실 함수는 모델이 학습 과정에서 목표로 삼아야 할 방향을 알려주는 나침반 역할을 합니다.

위 MSE 수식대로 계산하면 손실값은 아래와 같다 

((y_pred - y_train)**2).mean()

Mean Squared Error (MSE)를 사용해 손실을 계산합니다.

loss = nn.MSELoss()(y_pred, y_train)
loss

최적화

최적화(Optimization)는 주어진 목표를 달성하기 위해 최상의 해결책(Optimal Solution)을 찾아가는 과정입니다. 머신러닝과 딥러닝에서는 주로 모델이 예측한 값과 실제 값 사이의 오차(손실 함수 값)를 최소화하는 것을 목표로 합니다. 이 과정에서 모델의 학습 가능한 파라미터(가중치와 편향)를 조정하여 손실 함수의 값을 점점 더 작게 만들어갑니다. 최적화는 주로 경사 하강법(Gradient Descent)과 같은 알고리즘을 사용해 수행되며, 손실 함수의 기울기(Gradient)를 따라가며 최저점(또는 최적점)을 찾습니다. 이 과정은 마치 산에서 가장 낮은 지점을 찾아 내려가는 것과 비슷합니다. 최적화는 단순히 손실을 줄이는 것뿐만 아니라, 학습 속도, 안정성, 과적합 방지와 같은 다양한 요소를 고려해야 하는 복합적인 과정입니다. 즉, 최적화는 모델이 데이터로부터 가장 정확하고 효율적인 예측을 할 수 있도록 파라미터를 조정하는 핵심 과정입니다.

경사하강법

경사하강법(Gradient Descent)은 머신러닝과 딥러닝 모델이 최적의 가중치(Weights)와 편향(Biases)를 찾기 위해 손실 함수(Loss Function)를 최소화하는 방법입니다. 이 알고리즘은 마치 산 꼭대기에서 출발해 가장 낮은 지점(최솟값)을 찾아 내려가는 과정과 비슷합니다. 먼저, 모델은 손실 함수의 기울기(Gradient)를 계산합니다. 이 기울기는 현재 지점에서 손실이 가장 빠르게 감소하는 방향을 나타냅니다. 이후, 모델은 기울기의 반대 방향으로 가중치와 편향 값을 조금씩 업데이트합니다. 이때 학습률(Learning Rate)은 한 번에 이동하는 "걸음의 크기"를 결정합니다. 학습률이 너무 크면 최적의 지점을 지나칠 수 있고, 너무 작으면 학습 속도가 매우 느려질 수 있습니다. 이 과정을 반복하면서 손실 함수 값이 점점 작아지고, 결국 최적의 가중치와 편향을 찾아내게 됩니다. 즉, 경사하강법은 모델이 더 나은 예측을 할 수 있도록 가중치를 조정해주는 핵심 최적화 알고리즘입니다.

경사하강법은 데이터를 어떻게 나눠서 학습하느냐에 따라 배치(Batch), 확률적(Stochastic), 미니배치(Mini-Batch)로 나뉩니다.

학습률

학습률(Learning Rate)은 머신러닝과 딥러닝 모델이 학습할 때 가중치(Weights)와 편향(Biases)를 얼마나 크게 조정할지를 결정하는 하이퍼파라미터입니다. 경사하강법(Gradient Descent)과 같은 최적화 알고리즘에서 손실 함수(Loss Function)의 기울기(Gradient)를 따라 최적의 가중치를 찾아갈 때, 학습률은 한 번의 업데이트에서 이동하는 "걸음의 크기"를 의미합니다. 학습률이 너무 크면 최적의 가중치를 지나쳐 버리거나 학습이 불안정해질 수 있고, 너무 작으면 학습 속도가 매우 느려져 최적값에 도달하기 어려울 수 있습니다. 따라서 적절한 학습률을 선택하는 것은 모델의 학습 속도와 최적화 성능을 결정하는 중요한 요소입니다. 일반적으로 고정된 학습률을 사용하기도 하지만, 상황에 따라 학습률을 점진적으로 줄이거나 동적으로 조정하는 방법(예: Adam, Step Decay, Cyclical Learning Rate 등)이 사용되기도 합니다.

확률적 경사하강법

SGD(Stochastic Gradient Descent, 확률적 경사하강법)는 모델의 가중치(Weights)와 편향(Biases)를 최적화하기 위해 손실 함수(Loss Function)의 기울기(Gradient)를 따라 반복적으로 업데이트하는 가장 기본적인 옵티마이저입니다. 일반적인 경사하강법은 전체 데이터셋을 한 번에 사용해 기울기를 계산하지만, SGD는 무작위로 선택된 하나의 데이터 포인트(순수 SGD) 또는 작은 그룹(미니배치 SGD)을 사용해 기울기를 계산하고 가중치를 조정합니다. 이로 인해 학습 속도가 빨라지고 메모리 사용량이 줄어들지만, 진동이 발생할 수 있어 학습이 불안정할 수도 있습니다. PyTorch에서 SGD는 optim.SGD로 구현되며, 학습률(lr)과 모멘텀(momentum) 등의 매개변수를 통해 조정할 수 있습니다. 주로 작은 데이터셋이나 빠른 반복 학습이 필요한 경우 사용되며, 학습률이 적절하게 설정되면 강력하고 효율적인 최적화 결과를 제공합니다.

optimizer = optim.SGD(model.parameters(), lr=0.01) #model.parameters : 웨이트(w), 바이오스(b)  #lr = 학습률

# gradient를 초기화
optimizer.zero_grad()

# 역전파: 비용 함수를 미분하여 gradient(기울기) 계산
loss.backward()

# W와 b를 업데이트
optimizer.step()


#[Parameter containing:
# tensor([[0.4872]], requires_grad=True), Parameter containing:
# tensor([0.9188], requires_grad=True)]
print(list(model.parameters())) # W: 0.2177, b: 0.7267

경사 하강법(Gradient Descent)을 구현하기 위해 SGD(Stochastic Gradient Descent)를 사용합니다.

optimizer = optim.SGD(model.parameters(), lr=0.01)

• lr: 학습률(learning rate), W와 b를 업데이트하는 스텝 크기

(7) 학습 과정

1회 업데이트 과정을 다음과 같이 진행합니다.

optimizer.zero_grad()  # Gradient 초기화
loss.backward()        # 손실 함수 미분 (역전파)
optimizer.step()       # W와 b 업데이트

업데이트 후 파라미터를 확인합니다.

print(list(model.parameters()))

3. 학습 반복 및 결과 확인

1000번의 반복 학습을 통해 W와 b를 점진적으로 최적화합니다.

epochs = 1000
for epoch in range(epochs+1):
  y_pred = model(x_train)
  loss = nn.MSELoss()(y_pred, y_train)#nn.MSELoss 오차값 내주는 함수로 오차값 구하기

  optimizer.zero_grad()# 초기화
  loss.backward()# 오차값을 낸 함수에 미분해서 w,b값을 구하고
  optimizer.step()#그 구한값으로 w,b업데이트

  if epoch % 100 == 0:
    print(f'Epoch: {epoch}/{epochs} Loss: {loss:.6f}')# loss mse구한값 : 얼마나 오차가 있는지

최종 파라미터를 확인합니다

print(list(model.parameters()))
# W : tensor([[1.9475]], requires_grad=True)
# b : tensor([0.1193], requires_grad=True)

학습된 모델로 x=5를 예측합니다.

x_test = torch.FloatTensor([[5]])
y_pred = model(x_test)
print(y_pred)

3. 다중 선형 회귀

다중 선형 회귀(Multiple Linear Regression)는 여러 개의 독립 변수(입력 변수)를 사용해 하나의 종속 변수(출력 변수)를 예측하는 통계 및 머신러닝 기법입니다. 단순 선형 회귀가 하나의 독립 변수와 하나의 종속 변수 간의 선형 관계를 설명하는 반면, 다중 선형 회귀는 두 개 이상의 입력 변수가 출력 변수에 어떻게 영향을 미치는지를 분석합니다. 이 관계는 수식으로 표현되며, 예를 들어 Y=W1X1+W2X2+...+WnXn+b와 같이 나타납니다. 여기서 Y는 예측 값, X1,X2,...Xn ​은 입력 변수, W1,W2,...Wn ​은 각 변수의 가중치, b는 절편입니다. 다중 선형 회귀는 입력 변수들이 독립적이고, 종속 변수와 선형 관계를 가진다는 가정 하에 작동하며, 주로 경제학, 의료, 마케팅 등 다양한 분야에서 복합적인 요인의 영향을 분석하고 예측하는 데 사용됩니다.

 

디바이스 설정 (CPU,GPU)

device = torch.device("cuda"if torch.cuda.is_available() else "cpu")
print(f"device : {device}")

데이터 준비

다중 선형회귀의 경우 입력 특성 3개를 사용하였습니다

X_train = torch.FloatTensor([[73, 80, 75],
                             [93, 88, 93],
                             [89, 91, 90],
                             [96, 98, 100],
                             [73, 66, 70],
                             [85, 90, 88],
                             [78, 85, 82]]).to(device) #to(device)로 보내서 연산

y_train = torch.FloatTensor([[152], [185], [180], [196], [142], [175], [155]]).to(device) # 학습하기위한 데이터
# y = w1*73 + w2*80 + w3*75 +b
#일때 y가 152가 되어야한다는것

입력과 출력 차원 확인

print(X_train, y_train.shape)
print(y_train, y_train.shape)

모델 정의

model = nn.Linear(3,1).to(device)
#Linear(3,1) W3개 b1개
print(model)

입력 특성이 3개이므로 nn.Linear(3, 1)로 모델을 정의

옵티마이저 정의

Adam 옵티마이저를 사용합니다.

# optimizer = optim.SGD(model.parameters(), lr=0.00001)
optimizer = optim.Adam(model.parameters(), lr=0.01)
loss_fn = nn.MSELoss()

Adam

Adam(Adaptive Moment Estimation)은 경사하강법(Gradient Descent)을 개선한 최적화 알고리즘으로, 머신러닝과 딥러닝 모델 학습에서 널리 사용됩니다. Adam은 SGD(Stochastic Gradient Descent)의 단점을 보완하기 위해 개발되었으며, 각 가중치(Weight)와 편향(Bias)마다 다른 학습률(Learning Rate)을 적용해 더욱 효율적이고 안정적으로 최적화를 수행합니다. 이 알고리즘은 기울기의 평균(1차 모멘트, First Moment)과 기울기 제곱의 평균(2차 모멘트, Second Moment)을 모두 활용하여 학습률을 동적으로 조정합니다. 학습 초반에는 빠르게 학습하고, 학습 후반에는 안정적으로 수렴하도록 설계되었습니다. Adam은 계산 비용이 적고, 메모리 사용량이 효율적이며, 하이퍼파라미터를 따로 튜닝하지 않아도 대부분의 문제에서 좋은 성능을 보여줍니다.

학습 과정

epochs = 1000
for epoch in range(epochs + 1):
    y_pred = model(X_train)
    loss = loss_fn(y_pred, y_train)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print(f'Epoch: {epoch}/{epochs} ,Loss: {loss.item():.6f}')

 

학습된 모델로 x=[93,93,93]를 예측합니다.

x_test = torch.FloatTensor([[93, 93, 93]])
y_pred = model(x_test)
print(y_pred)

 

이번 글에서는 PyTorch를 사용해 단순 선형회귀와 다중 선형회귀를 구현했습니다.

코드와 결과를 통해 y=Wx+b의 학습 과정을 이해할 수 있었습니다.