1.우선 가상환경 설치

• 설치 참고링크 https://eunji7267.tistory.com/6

#텐서x가 성공적으로 생성
#requires_grad 속성이 True로 설정
#이 텐서에 대한 연산이 추적되며, 기울기 계산이 가능
x = torch.tensor(3.5, requires_grad= True) # grad는 gradient 기울기
print(x)
#출력
# tensor(3.5000, requires_grad=True)




y = (x-1) * (x-2) * (x-3)
print(y)
#출력
# tensor(1.8750, grad_fn=<MulBackward0>)




#잡한 신경망에서 기울기를 계산할 때 매우 유용
y.backward()# y에 대한 역전파(backpropagation)를 수행  모든 텐서에 대한 기울기가 계산

x.grad # y.backward()가 호출되기 전까지는 None이며, y.backward() 호출 후에는 x에 대한 y의 기울기 값이 저장


#요약 backward는 y에 대한 기울기 계산하는 명령어
#grad는 x의 기울기 값을 조회
#출력 tensor(5.7500)


-------------------------------



a = torch.tensor(2.0, requires_grad= True)
b = torch.tensor(1.0, requires_grad= True)

x = 2*a + 3*b
y = 5*a*a + 3*b*b*b
z = 2*x + 3*y


z.backward() #a.grad는 z를 a로 편미분한 값
print(a.grad)
#tensor(64.)


print(b.grad)#b.grad는 z를 b
#출력 tensor(33.)

2. pytorch를 이용한 mnist 데이터 분류

1. 임폴트
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim  # 수정된 부분
from torchvision import datasets, transforms
import matplotlib.pyplot as plt







2. 컴퓨팅 디바이스를 설정
is_cuda = torch.cuda.is_available() #CUDA가 사용 가능한 GPU가 있는지 확인
device = torch.device('cuda' if is_cuda else 'cpu')

print(device)





3.딥러닝 모델을 학습시키기 위해 필요한 하이퍼파라미터들을 설정
batch_size = 50#한 번의 학습(iteration)에 사용될 데이터의 수를 설정합니다. 즉, 네트워크를 통해 한 번에 50개의 데이터 샘플이 전파
learning_rate = 0.0001 #습률은 옵티마이저가 모델의 가중치를 업데이트할 때 얼마나 큰 단계를 밟을지를 결정
#옵티마이저는 딥러닝에서 모델의 가중치를 업데이트하는 방법을 정의하는 컴포넌트

epoch_num = 15






4.PyTorch의 torchvision 라이브러리를 사용하여 MNIST 데이터셋을 다운로드
train_data = datasets.MNIST(root = './data',
                            train = True,
                            download = True,
                            transform = transforms.ToTensor())

test_data = datasets.MNIST(root = './data',
                           train = False,
                           download = True,
                           transform = transforms.ToTensor())



5. 길이 확인
len(train_data), len(test_data)
# 결과 (60000, 10000)



6. 이미지 출력
image, label = train_data[0]#첫 번째 이미지와 레이블을 가져 가져온다.
plt.imshow(image.squeeze().numpy(), cmap = 'gray')
#imshow 함수는 이미지를 화면에 출력
#image.squeeze()는 차원이 1인 축을 제거하여 이미지 텐서의 차원을 줄인다.
#축을 제거하는 이유는 데이터의 형태를 간소화하고, 시각화나 다른 연산을 수행

#데이터가 배치 크기, 높이, 너비, 채널 수를 포함하는 4차원 텐서로 저장되어 있을 때,
#단일 이미지를 선택하면 그 결과는 [1, 높이, 너비, 채널 수]와 같은 4차원 텐서가 된다.. 여기서 첫 번째 차원의 크기는 1



plt.title('Label : %s'% label)
plt.show()




7.DataLoader 클래스를 사용하여 train_data와 test_data 데이터셋을 위한 데이터 로더
train_loader = torch.utils.data.DataLoader(dataset = train_data,
                                           batch_size = batch_size,#한 번에 로드할 데이터의 수를 지정, 변수의 값을 사용
                                           shuffle = True)#데이터를 로드할 때 데이터셋을 무작위로 섞을지 여부를 결정

test_loader = torch.utils.data.DataLoader(dataset = test_data,
                                          batch_size = batch_size,
                                          shuffle = True)
                                          
 
 8.train_loader에서 첫 번째 배치를 가져오는 과정
#train_loader는 PyTorch의 DataLoader 객체이며, 이터레이터로 변환한 후 __next__() 메서드를 사용하여 첫 번째 배치를 가져온다,.
first_batch = train_loader.__iter__().__next__()



9.len(train_loader)
#출력 1200


10. 타입확인
type(first_batch[0])
# 출력 torch.Tensor

11.len(first_batch[0])
#출력 50



12.레이블의 차원과 크기를 확인
first_batch[0].shape, first_batch[1].shape

#텐서는 배치 내의 이미지 데이터
#50은 배치 크기를 의미하며, 한 번에 로드된 이미지의 수
#1은 이미지의 채널 수
#28, 28은 각 이미지의 높이와 너비




13.PyTorch를 사용하여 Convolutional Neural Network (CNN) 모델을 정의하는 예제
import torch
import torch.nn as nn
import torch.nn.functional as F


class CNN(nn.Module):
    def __init__(self): #모델의 구조를 정의
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1, padding='same')
        # 1개의 채널을 입력으로 받고, 32개의 필터를 가진 3x3 커널을 사용하는 convolutional layer

        self.conv2 = nn.Conv2d(32, 64, 3, 1, padding = 'same')
        #32개의 채널을 입력으로 받고, 64개의 필터를 가진 3x3 커널을 사용하는 또 다른 convolutional layer 패딩은 역시 'same'

        self.dropout = nn.Dropout2d(0.25)
        #드롭아웃을 적용하는 레이어로, 오버피팅을 방지하기 위해 사용

        self.fc1 = nn.Linear(3136, 1000)
        #Fully connected layer로, 입력 뉴런의 수는 3136개, 출력 뉴런의 수는 1000개
        
        self.fc2 = nn.Linear(1000, 10)
        #또 다른 fully connected layer로, 입력 뉴런의 수는 1000개, 출력 뉴런의 수는 10개


    def forward(self, x):#경망에서 입력 데이터를 받아 순방향으로 처리하여 최종 출력
        x = self.conv1(x)
        x = F.relu(x)
        #는 첫 번째 convolutional layer self.conv1를 통과. 이후, ReLU 활성화 함수

        x = F.max_pool2d(x, 2)
        #공간 차원을 줄이기 위해 2x2 크기의 max pooling을 적용


        x = self.conv2(x)
        x = F.relu(x)
        #Convolutional Layer: 데이터는 두 번째 convolutional layer self.conv2를 통과하고, 다시 ReLU 활성화 함수를 적용
    

        x = F.max_pool2d(x, 2)
           #다시 2x2 크기의 max pooling을 적용하여 공간 차원을 줄인다.

        x = self.dropout(x)
        #  #Dropout: 드롭아웃을 적용하여 오버피팅을 방지

        x = torch.flatten(x, 1)
        #Flatten: 데이터를 1차원으로 펼친다. 이는 fully connected layer에 입력하기 위한 준비 단계

        x = self.fc1(x)
        x = F.relu(x)
        #첫 번째 Fully Connected Layer: 데이터는 첫 번째 fully connected layer self.fc1를 통과하고, ReLU 활성화 함수를 적용

        x = self.fc2(x)

        output = F.log_softmax(x, dim = 1)
        # 마지막으로 log softmax 함수를 적용하여 클래스에 대한 로그 확률을 계산

        return output
                           
                           
                           
14. PyTorch를 사용하여 신경망 모델을 초기화하고, 학습에 필요한 설정
model = CNN().to(device)
#CNN()은 위에서 정의한 신경망 모델의 인스턴스를 생성
#.to(device)는 모델의 모든 파라미터와 버퍼를 지정된 디바이스(device)로 이동
#device는 "cuda" (GPU를 사용) 또는 "cpu"일 수 있다  나는 GPU cuda 사용

optimizer = optim.Adam(model.parameters(), lr = learning_rate)
#ptim.Adam은 Adam 최적화 알고리즘을 사용하는 옵티마이저를 생성
#. Adam은 모멘텀과 RMSProp의 아이디어를 결합하여 효율적인 경사 하강 알고리즘을 제공
#lr=learning_rate는 학습률을 설정

criterion = nn.CrossEntropyLoss()
#nn.CrossEntropyLoss()는 크로스 엔트로피 손실 함수를 생성 이는 분류 문제에서 주로 사용되며, 모델의 출력과 실제 레이블 간의 차이를 계산



15. PyTorch를 사용하여 신경망 모델을 학습하는 과정을 구현. 주요 목적은 모델의 파라미터를 업데이트하여 손실 함수의 값을 최소화
model.train()
i = 1

for epoch in range(epoch_num):#외부 루프(for epoch in range(epoch_num):)는 에포크를 반복
    for data, target in train_loader:#내부 루프(for data, target in train_loader:)는 데이터 로더에서 배치를 반복

        data = data.to(device)
        #data와 target을 지정된 디바이스(device)로 이동

        target = target.to(device)
        optimizer.zero_grad()
        #옵티마이저의 기울기 버퍼를 0으로 초기화

        output = model(data)
        #모델을 통해 data를 전달하여 출력을 계산

        loss = criterion(output, target)
        #손실 함수를 사용하여 출력과 타겟 간의 손실을 계산
        loss.backward()
        #손실에 대한 기울기를 계산
        optimizer.step()
        #옵티마이저를 사용하여 모델의 파라미터를 업데이트

        if i%1000 ==0:
            print(i, loss.item())

        i +=1

        #1000 0.19806066155433655는 1000번째 배치에서의 손실 값이 약 0.198
        #2000 0.037925850600004196는 2000번 째 배치에서의 손실 값이 약 0.037925
        
        
        
16.PyTorch를 사용하여 학습된 신경망 모델의 성능을 테스트하는 과정
model.eval()#model.eval()은 모델을 평가 모드로 설정

correct = 0

for data, target in test_loader:
    data = data.to(device)#data와 target을 지정된 디바이스(device)로 이동
    target = target.to(device)
    output = model(data) #모델을 통해 data를 전달하여 출력을 계산
    prediction = output.data.max(1)[1] #모델 출력에서 가장 높은 값을 가진 인덱스를 반환
    # 1은 이 연산이 행(차원 1)을 따라 수행되어야 함을 의미
    #[1]은 인덱스를 선택

    correct += prediction.eq(target.data).sum() #변수는 총 맞은 예측의 수를 저장
    #eq는 "equal"의 줄임말로, 텐서의 각 요소가 다른 텐서의 해당 요소와 동일한지 여부를 나타내는 새로운 텐서를 반환

print(correct / 10000)



#출력 
#tensor(0.9918, device='cuda:0')