torch.sum()이란?multiply = x * w
weighted_sum = torch.sum(multiply)
torch.sum()은 Tensor 안의 값들을 더하는 함수이다.
예:
x = [1.0, 2.0, 3.0]
w = [0.5, 0.3, 0.2]
먼저:
x * w
= [0.5, 0.6, 0.6]
그다음:
torch.sum(...)
= 0.5 + 0.6 + 0.6
= 1.7
주의:
x * w
는 행렬곱이 아니라 원소별 곱(Element-wise Multiplication)이다.
하지만:
torch.sum(x * w)
까지 하면 벡터 내적과 같은 결과가 된다.
중요한 기본 과정:
1. Input
2. Weight
3. Bias
4. Input × Weight
5. Weighted Sum
6. Bias 추가
7. Activation Function
공식:
z = Σ(x × w) + b
output = activation(z)
예:
z = torch.sum(x * w) + b
output = torch.relu(z)
전체 흐름:
Input
↓
Weight 곱하기
↓
Weighted Sum
↓
Bias 더하기
↓
z
↓
Activation Function
↓
Output
Weight는 각 Input을 얼마나 중요하게 반영할지 결정한다.
예:
x = [1, 2, 3]
w1 = [0.5, 0.3, 0.2]
w2 = [1.0, 0.3, 0.2]
첫 번째 Weight를:
0.5 → 1.0
으로 키우면 첫 번째 Input의 영향이 커져 Output도 변한다.
즉:
Weight가 크면 해당 Feature의 영향이 커진다.
업로드한 실습에서도 기존 Weight와 변경 Weight를 각각 계산하여 출력 차이를 비교한다.
예:
Weight = [1.0, 0.0, 0.0]
이면:
첫 번째 Input → 반영
두 번째 Input → 영향 없음
세 번째 Input → 영향 없음
즉:
Weight = 0이면 해당 Feature가 현재 계산에 영향을 주지 않는다.
실습에서는 여러 Weight 조합을 바꾸어 결과 차이를 확인한다.
예:
양수 Weight
[0.5, 0.3, 0.2]
음수 Weight
[-0.5, 0.3, 0.2]
Weight가 음수가 되면 해당 Input이 출력을 낮추는 방향으로 작용할 수 있다.
정리:
양수 Weight → 증가 방향
음수 Weight → 감소 방향
0 Weight → 영향 없음
실습에서도 첫 Weight만 0.5 → -0.5로 변경해 결과를 비교한다.
Bias는 Weighted Sum 전체를 이동시키는 값이다.
예:
Weighted Sum = 1.7
일 때:
Bias = -1 → 0.7
Bias = 0 → 1.7
Bias = +1 → 2.7
즉:
Weight = 각 Input의 영향력 조절
Bias = 전체 결과를 이동
실습에서는 Weighted Sum은 그대로 두고 Bias를 -1, 0, 1로 변경한다.
nn.Linear()이란?직접:
torch.sum(x * w) + b
를 계산하지 않아도 PyTorch가 Linear Layer를 제공한다.
예:
layer = nn.Linear(3, 1)
뜻:
Input Feature 3개
↓
Linear Layer
↓
Output Feature 1개
nn.Linear() 내부에서 기본적으로:
Input × Weight
→ 합
→ Bias 추가
계산을 수행한다.
nn.Linear(3, 1)에 Weight와 Bias를 직접 넣은 뒤 layer(x) 결과와 수동 계산 결과를 비교한다.기본 뉴런 계산
↓
Weight 변경
↓
여러 Weight 비교
↓
음수 Weight 확인
↓
Bias 변경
↓
Weight + Bias 조합 비교
↓
nn.Linear로 자동 계산
결국 배우는 핵심:
신경망 학습은 적절한 Weight와 Bias를 찾아가는 과정이다.
NoSQL은 주로:
사용한다.
SQL:
정해진 테이블 구조
관계와 JOIN에 강함
NoSQL:
유연한 데이터 구조
대용량/분산 처리에 유리
한 줄:
NoSQL = 구조가 유연한 대량 데이터를 저장하고 확장하기 좋음
시험용으로 반드시 기억:
이진 분류 → Sigmoid
다중 분류 → Softmax
은닉층 기본 → ReLU
암기:
둘이면 Sigmoid, 여러 개면 Softmax, 중간층은 ReLU
torch.softmax(z, dim=0)의 dimdim은:
어느 차원을 기준으로 Softmax를 적용할 것인가
를 지정한다.
1차원:
z = [2.0, 1.0, 0.1]
shape:
(3,)
축이 하나뿐이므로:
torch.softmax(z, dim=0)
사용.
결과 확률들의 합:
1.0
dim예:
[
[1, 2, 3],
[4, 5, 6]
]
shape:
(2, 3)
dim=0
세로 방향
↓ ↓ ↓
1 2 3
4 5 6
같은 열끼리 Softmax.
dim=1
[1, 2, 3] → 이 줄끼리
[4, 5, 6] → 이 줄끼리
같은 행끼리 Softmax.
분류에서는 보통:
(batch, class)
형태이므로 클래스 축에 Softmax를 적용한다.
예:
shape = (32, 10)
32 = 데이터 수
10 = 클래스 수
이면 보통:
torch.softmax(z, dim=1)
예:
Input Feature = 3
Hidden Feature = 4
Hidden Feature = 2
Output Feature = 1
모델 구조:
3 → 4 → 2 → 1
PyTorch:
layer1 = nn.Linear(3, 4)
layer2 = nn.Linear(4, 2)
layer3 = nn.Linear(2, 1)
nn.Linear(A, B)는:
A개의 Feature를 입력받아 B개의 Feature를 출력
한다.
Input Feature가 3개라면 데이터 하나당 값이 3개 있어야 한다.
x = torch.tensor([1.0, 2.0, 3.0])
shape:
(3,)
모델을 지나면:
(3,)
↓ Linear(3,4)
(4,)
↓ Linear(4,2)
(2,)
↓ Linear(2,1)
(1,)
데이터가 5개이고 각각 Feature가 3개이면:
shape = (5, 3)
뜻:
5 = 데이터 개수, Batch
3 = Feature 개수
모델을 지나면:
(5, 3)
↓
(5, 4)
↓
(5, 2)
↓
(5, 1)
Batch 크기는 그대로 있고 Feature 차원만 바뀐다.
3 → 4 → 2 → 1이 Shape인가?엄밀히는 아니다.
3 → 4 → 2 → 1
은:
각 Layer의 Feature 개수
또는:
모델의
3-4-2-1구조
라고 표현한다.
실제 Tensor Shape은:
(3,) → (4,) → (2,) → (1,)
이다.
즉:
3,4,2,1
= Feature 개수
(3,), (4,), (2,), (1,)
= 각 단계 Tensor의 Shape
보통:
3 → 4 → 2 → 1
전체를 하나의 Shape이라고 하지는 않는다.
각 단계마다 Tensor Shape가 따로 있다.
또한 각 Linear Layer의 Weight에도 별도의 Shape가 존재한다.
예:
Linear(3,4)
Weight Shape = (4,3)
Linear(4,2)
Weight Shape = (2,4)
Linear(2,1)
Weight Shape = (1,2)
순전파는:
입력값이 신경망의 앞쪽에서 뒤쪽 Output까지 전달되면서 예측값을 계산하는 과정
이다.
흐름:
Input
↓
Input × Weight
↓
Weighted Sum
↓
Bias
↓
Activation Function
↓
다음 Layer
↓
Output
여러 Layer에서는:
Input
↓
Linear
↓
ReLU
↓
Linear
↓
ReLU
↓
Linear
↓
Output
한 줄:
순전파 = 현재 Weight와 Bias를 이용해서 입력으로부터 예측값을 계산
하나의 작업이 끝날 때까지 기다린 다음 다음 작업을 수행.
A 시작
↓
A 완료까지 기다림
↓
B 시작
어떤 작업을 기다리는 동안 다른 작업을 수행할 수 있음.
A 요청
↓
A 기다리는 동안 B 수행
↓
A 완료되면 다시 처리
주로:
처럼 대기 시간이 있는 작업에서 효과적이다.
주의:
비동기 ≠ 병렬처리
비동기는 기다리는 시간을 효율적으로 사용하는 개념이다.
forward()는 언제 실행되는가?모델 클래스에:
def forward(self, x):
를 정의해도 코드에서:
forward(x)
라고 직접 호출하지 않는 경우가 많다.
대신:
y = model(x)
를 실행하면 forward()가 호출된다.
업로드한 코드에서도 실제 Forward 실행 부분은 y = model(x)이다.
nn.Module이란?class MyNet(nn.Module):
에서 nn.Module은:
PyTorch 신경망 모델과 Layer의 기본 부모 클래스
이다.
즉 MyNet이 nn.Module의 기능을 상속받는 것이다.
코드에서는 MyNet(nn.Module) 안에 fc1, ReLU, fc2, forward()를 정의한다.
model(x)가 forward()를 자동 실행하는가?핵심은 Python의:
__call__()
이다.
nn.Module에는 이미 __call__()이 구현되어 있다.
따라서:
model(x)
를 실행하면 개념적으로:
model(x)
↓
nn.Module.__call__(x)
↓
self.forward(x)
순서로 실행된다.
즉:
forward()가 저절로 실행되는 것이 아니라
nn.Module의__call__()이forward()를 호출하는 것
이다.
__init__()과 forward() 차이__init__()model = MyNet()
객체를 생성할 때 실행.
주로:
어떤 Layer를 사용할지 정의
예:
self.fc1 = nn.Linear(3, 4)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(4, 2)
업로드한 코드에서도 __init__()에서 이 세 Layer를 정의한다.
forward()y = model(x)
입력을 모델에 넣을 때 실행.
주로:
데이터를 어떤 순서로 Layer에 통과시킬지 정의
해당 코드에서는:
x
↓
fc1
↓
ReLU
↓
fc2
↓
return
순서이다.
__init__, __call__, forward 최종 관계이 부분 중요.
model = MyNet()
↓
__init__()
↓
Layer 생성
y = model(x)
↓
nn.Module.__call__()
↓
forward(x)
↓
실제 순전파 실행
암기:
__init__= 모델 구성
forward= 데이터가 흘러갈 과정
model(x)= forward 실행
__call__= model(x)를 받아 forward를 불러주는 기능
뉴런 계산
x × w → sum → +b → 활성화 함수
Weight
각 Feature의 영향력 결정
Bias
전체 계산값 이동
nn.Linear(A,B)
A개 Feature → B개 Feature
3 → 4 → 2 → 1
모델의 Feature 구조
순전파
Input → Layer → Activation → ... → Output
Softmax
다중분류
Sigmoid
이진분류
ReLU
은닉층 기본 활성화 함수
nn.Module
PyTorch 신경망의 부모 클래스
model(x)
↓
__call__()
↓
forward(x)