1.1번만 돌리는 ai
흐름
1)데이터x,y입력
2)w초기화
3)예측값
4)손실함수
5)역전파 -> 기울기계산
6.w초기화 -> w업데이트(기울기 계산한거 바탕으로)
코드
import torch
#1.x,y 입력
x = torch.tensor([1.0,2.0,3.0])
y_true = torch.tensor([2.0,4.0,6.0])
#2.w 초기화
w = torch.tensor([0.1],requires_grad=True)
#3.예측값 만들기 w * x
y_pred = w * x
#4.손실값 계산
loss = torch.mean((y_pred - y_true) ** 2)
#(w,예측값,손실값 출력)
print(f"현재 w: {w.item():.4f}")
print(f"예측값:{y_pred}")
print(f"손실값:{loss.item():.4f}")
#5.역전파
loss.backward()
print(f"손실함수를 w에 대해 미분한 기울기:{w.grad.item():.4f}")
#6.경사하강법 (w 업데이트 및 기울기 초기화)
learning_rate = 0.1
w_updated = w - learning_rate * w.grad
print(f"업데이트된 w:{w_updated.item():.4f}")
2.여러번 돌리는 ai
흐름
1.x,y값 넣기
2.w값 초기화
3.학습율 설정
4.반복문
4-1.예측값 설정
4-2.손실함수
4-3.역전파
4-4.경사하강법(w업데이트)(no_grad)
5.기울기 초기화
6.로그출력
코드
import torch
# 1) 데이터 입력
x = torch.tensor([1.0, 2.0, 3.0])
y_true = torch.tensor([2.0, 4.0, 6.0]) # 정답: y = 2x
# 2) 파라미터 초기화
w = torch.tensor([1.0], requires_grad=True)
# 3) 학습률 설정
learning_rate = 0.1
# 4) 반복문으로 학습 (epoch)
for epoch in range(20):
# 1) 예측값
y_pred = w * x
# 2) 손실함수
loss = torch.mean((y_pred - y_true) ** 2)
# 3) 역전파로 기울기 계산
loss.backward()
# 4) 파라미터 업데이트 (경사하강법)
with torch.no_grad(): # autograd 추적 끊기
w -= learning_rate * w.grad
# 5) 기울기 초기화
w.grad.zero_()
# 6) 로그 출력
print(f"Epoch {epoch+1:2d} | w: {w.item():.4f} | Loss: {loss.item():.4f}")
3.옵티마이저 사용(파라미터 업데이트식 대체)
흐름
1.x,y 설정
2.w값 초기화
3.옵티마이저 설정
4.반복문
4-1.예측값
4-2.손실함수
4-3.역전파
4-4.경사하강법 및 기울기 초기화(옵티마이저)
4-5.출력
코드
import torch
#1.x,y값 넣기
x = torch.tensor([1.0,2.0,3.0])
y_true = torch.tensor([2.0,4.0,6.0])
#2.w값초기화
w = torch.tensor([0.1],requires_grad=True)
#3.옵티마이저 생성(lr,opt)
learning_rate = 0.1
optimizer = torch.optim.SGD([w],lr=learning_rate)
#4.반복
for epoch in range(20):
#4-1.예측값설정
y_pred = w * x
#4-2.손실함수
loss = torch.mean((y_pred - y_true) ** 2)
#4-3.역전파
loss.backward()
#4-4.손실함수 및 기울기 초기화(옵티마이저)
optimizer.step()
optimizer.zero_grad()
#4-5.출력
print(f"epoch:{epoch+1:2d} | w:{w.item():.4f} | loss:{loss.item():.4f}")
4.편향(b) 추가
기존 것에 수정해보기
코드
import torch
#1.x,y값 넣기
x = torch.tensor([1.0,2.0,3.0])
y_true = torch.tensor([2.0,4.0,6.0])
#2.w값초기화
w = torch.tensor([0.1],requires_grad=True)
b = torch.tensor([0.0],requires_grad=True)
#3.옵티마이저 생성(lr,opt)
learning_rate = 0.1
optimizer = torch.optim.SGD([w,b],lr=learning_rate)
#4.반복
for epoch in range(10):
#4-1.예측값설정
y_pred = w * x + b
#4-2.손실함수
loss = torch.mean((y_pred - y_true) ** 2)
#4-3.역전파
loss.backward()
#4-4.손실함수 및 기울기 초기화(옵티마이저)
optimizer.step()
optimizer.zero_grad()
#4-5.출력
print(f"epoch:{epoch+1:2d} | w:{w.item():.4f} | b:{b.item():.4f} | loss:{loss.item():.4f}")
결과
epoch: 1 | w:1.8733 | b:0.7600 | loss:16.8467
epoch: 2 | w:1.6876 | b:0.6587 | loss:0.2674
epoch: 3 | w:1.7157 | b:0.6519 | loss:0.0662
epoch: 4 | w:1.7203 | b:0.6352 | loss:0.0608
epoch: 5 | w:1.7273 | b:0.6201 | loss:0.0579
epoch: 6 | w:1.7338 | b:0.6052 | loss:0.0552
epoch: 7 | w:1.7402 | b:0.5906 | loss:0.0525
epoch: 8 | w:1.7464 | b:0.5764 | loss:0.0500
epoch: 9 | w:1.7525 | b:0.5626 | loss:0.0477
epoch:10 | w:1.7585 | b:0.5490 | loss:0.0454
5.nn.Module(모델 관련 클래스)
흐름
1.데이터
2.모델 클래스 정의
3.모델 객체 생성
4.옵티마이저랑 lr
5.반복
5-1.순전파(예측값)
5-2.손실함수
5-3.역전파
5-4.파라미터 업데이트 + 기울기 초기화 (옵티마이저)
5-5.출력
코드
import torch
import torch.nn as nn
# 1) 데이터
x = torch.tensor([1.0, 2.0, 3.0])
y_true = torch.tensor([2.0, 4.0, 6.0])
# 2) 모델 클래스 정의
class LinearRegressionModel(nn.Module): #torch.nn클래스안에 Module클래스 존재
def __init__(self):
super().__init__()
self.w = nn.Parameter(torch.tensor([0.1]))
self.b = nn.Parameter(torch.tensor([0.0]))
def forward(self, x):
return self.w * x + self.b
# 3) 모델 인스턴스 생성
model = LinearRegressionModel()
# 4) 옵티마이저
learning_rate = 0.1
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
# 5) 반복문 (Epoch)
for epoch in range(20):
# 순전파 (예측)
y_pred = model(x)
# 손실함수 (MSE)
loss = torch.mean((y_pred - y_true) ** 2)
#
loss.backward()
# 파라미터 업데이트 & 기울기 초기화
optimizer.step()
optimizer.zero_grad()
# 로그 출력
print(f"epoch:{epoch+1:2d} | w:{model.w.item():.4f} | b:{model.b.item():.4f} | loss:{loss.item():.4f}")