Pytorch 활용

01

nn.Linear — 선형 레이어

🔗

torch.nn.Linear(in_features, out_features)

선형 레이어 (Linear Layer)

입력 텐서에 가중치 행렬(W)을 곱하고 편향(b)을 더하는 선형 변환 연산을 수행한다.
수식으로는 y = xWᵀ + b 로 정의되며, 가중치와 편향 파라미터는 모듈 내부에서 자동으로 초기화 및 학습된다.
개발자가 행렬 연산과 변수를 수동으로 관리할 필요 없이 nn.Linear 모듈 하나로 완전히 해결된다.

in_features

입력 벡터의 크기 (이 층의 입력 특징 노드 수)

out_features

출력 벡터의 크기 (이 층의 출력 특징 노드 수)

nn.Linear(5, 3) — 신경망 시각화

nn_linear.py

import torch
import torch.nn as nn

# 입력 특징 노드 5개, 출력 특징 노드 3개의 선형 레이어 생성
layer = nn.Linear(5, 3)

x = torch.randn(1, 5) # 배치 크기 1, 입력 특징 노드 수 5인 입력 텐서 생성
y = layer(x) # 순전파 연산 수행. 출력 형상은 (1, 3)

# 가중치(Weight) 및 편향(Bias) 파라미터 형상 확인
print(layer.weight.shape) # torch.Size([3, 5]) ← [output_dim, input_dim] 구조
print(layer.bias.shape) # torch.Size([3])

02

nn.Sequential — 층을 순서대로 쌓기

🥞

torch.nn.Sequential(*layers)

순차적 레이어 컨테이너

여러 레이어를 결합하여 단일 흐름으로 묶어주는 순차적 모듈 컨테이너이다.
model(x)를 호출하면 첫 번째 레이어부터 마지막 레이어까지 자동으로 순전파 연산이 수행된다.
분기가 없는 단순 선형 구조의 모델을 신속하게 정의할 때 매우 유용하다.

nn.Sequential — Linear(4,5) → ReLU → Linear(5,3)

nn_sequential.py

import torch
import torch.nn as nn

# 입력 특징 수 4, 은닉 노드 5, 출력 특징 수 3의 순차 모델 생성
model = nn.Sequential(
    nn.Linear(4, 5), # 입력층(4) → 은닉층(5) 선형 변환 레이어
    nn.ReLU(), # 활성화 함수 (비선형성 부여)
    nn.Linear(5, 3), # 은닉층(5) → 출력층(3) 선형 변환 레이어
)

x = torch.randn(1, 4) # 배치 크기 1, 입력 특징 노드 수 4인 입력 텐서 생성
y = model(x) # 순전파 연산 수행. 출력 형상은 (1, 3)

✅

Sequential의 장점

forward() 연산 로직을 개발자가 별도로 작성할 필요 없이, 선언 시점의 레이어 순서대로 데이터가 자동 연쇄 통과된다.
단, 복잡한 구조(분기, 스킵 연결 등)를 설계할 때는 nn.Module이 필수적이다.

03

nn.Module — 모든 신경망의 기반 클래스

🧱

torch.nn.Module

신경망 모듈의 최상위 기반 클래스

PyTorch에서 신경망 구성을 설계할 때 상속받는 기본 클래스이다.
nn.Linear와 nn.Sequential을 포함한 모든 신경망 컴포넌트가 이를 상속받는다.

커스텀 모델 정의 시 nn.Module을 상속받은 뒤, ① 생성자(__init__)에서 필요한 파라미터와 레이어를 정의하고, ② forward() 메서드에서 입력 텐서의 순전파 흐름을 기술한다. 역전파(backward)는 Autograd 엔진에 의해 자동으로 계산되고 최적화된다.

MyModel (nn.Module 상속)
├── self.fc1 = nn.Linear(784, 128)
├── self.relu = nn.ReLU()
└── self.fc2 = nn.Linear(128, 10)

forward(x) ← 순전파 연산 직접 기술
backward() ← PyTorch 자동 역전파 미분 수행

MyModel(nn.Module) — fc1(4→5) → ReLU → fc2(5→3)

nn_module.py

import torch
import torch.nn as nn
import torch.nn.functional as F

class MyModel(nn.Module):
    def __init__(self):
        super().__init__() # nn.Module 초기화 함수 호출 (필수)
        self.fc1 = nn.Linear(4, 5) # 입력 노드 수 4, 은닉 노드 수 5인 선형 변환 레이어 생성
        self.fc2 = nn.Linear(5, 3) # 은닉 노드 수 5, 출력 노드 수 3인 선형 변환 레이어 생성

    def forward(self, x): # 순전파 연산 정의
        x = F.relu(self.fc1(x)) # 은닉층 통과 후 ReLU 활성화 함수 적용
        x = self.fc2(x)
        return x

# 학습 루프
model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
loss_fn = nn.CrossEntropyLoss()

x = torch.randn(1, 4) # 배치 크기 1, 입력 특징 노드 수 4인 입력 텐서 생성
pred = model(x) # ① 순전파 연산 수행. 출력 형상은 (1, 3)
loss = loss_fn(pred, y) # ② Loss 계산
loss.backward() # ③ 역전파 연산 수행. 미분값 자동 계산
optimizer.step() # ④ 가중치 업데이트

파라미터 자동 추적 model.parameters() 자동 역전파 모델 저장/불러오기

🧠

Sequential vs Module — 활용 기준

nn.Sequential — 단순히 레이어를 일렬로 쌓는 직관적인 단방향 구조에 적합하다.
nn.Module — 다중 분기, 스킵 연결(Residual Connection), 반복 순환 구조(RNN) 등 복잡한 아키텍처를 구현할 때 필수적이다.
현업 실무 및 연구용 딥러닝 프로젝트에서는 대다수 nn.Module 기반 커스텀 클래스를 구축한다.