[PyTorch] Neural Network Model (신경망 모델) 구성하기

⚠️ 본 내용은 PyTorch Korea의 공식 문서에 기반하여 공부한 내용을 적은것이니 양해바랍니다!

신경망 모델 구성하기

---

Neural Network Model (신경망 모델) 구성하기

• 신경망은 데이터에 대한 연산을 수행하는 계층(layer)/모듈(module)로 구성되어 있습니다.
• torch.nn 네임스페이스는 신경망을 구성하는데 필요한 모든 구성 요소를 제공합니다. PyTorch의 모든 모듈은 nn.Module 의 하위 클래스(subclass) 입니다.

• torch.nn 관련 공식문서 입니다.

torch.nn — PyTorch 2.4 documentation

• nn.Module 관련 공식문서 입니다.

 

Module — PyTorch 2.4 documentation

 

• 또한 신경망은 다른 모듈(계층, layer)로 구성된 모듈입니다.
• 이러한 중첩된 구조는 복잡한 아키텍처를 쉽게 구축하고 관리할 수 있습니다.
• 한번 이번에는 COCO Dataset으로 한번 구성해 보겠습니다.

import os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

---

학습을 위한 장치 설정

• 가능한 경우 GPU 또는 MPS와 같은 하드웨어 가속기에서 모델을 학습하려고 합니다.
• torch.cuda 또는 torch.backends.mps가 사용 가능한지 확인하고, 그렇지 않으면 CPU를 계속 사용합니다.

 

• torch.cuda 관련 공식문서 입니다.

CUDA semantics — PyTorch 2.4 documentation

 

• torch.backends.mps 관련 공식문서 입니다.

MPS backend — PyTorch 2.4 documentation

import torch

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

Using cpu device

• COCO 데이터셋을 사용하기 위해서는 pycocotools가 필요합니다.

pip install pycocotools

• 또한 데이터셋을 다운로드 해야합니다. 아래의 코드로 다운로드 및 압축을 해제 한후, 데이터 로드를 해보겠습니다.

import os

# 디렉토리 생성
os.makedirs('data/coco/images', exist_ok=True)
os.makedirs('data/coco/annotations', exist_ok=True)

# COCO 데이터셋 다운로드
!wget http://images.cocodataset.org/zips/train2017.zip -P data/coco/images/
!wget http://images.cocodataset.org/zips/val2017.zip -P data/coco/images/
!wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip -P data/coco/annotations/

# 다운로드된 파일 목록 확인
!ls data/coco/images/
!ls data/coco/annotations/

# 이미지 압축 해제
!unzip data/coco/images/train2017.zip -d data/coco/images/
!unzip data/coco/images/val2017.zip -d data/coco/images/

# 주석 파일 압축 해제
!unzip data/coco/annotations/annotations_trainval2017.zip -d data/coco/annotations/

# 압축 해제된 파일 목록 확인
!ls data/coco/images/train2017 | head -n 5  # train2017 디렉토리의 파일 목록 확인 (처음 5개 파일만)
!ls data/coco/annotations/ | head -n 5  # annotations 디렉토리의 파일 목록 확인 (처음 5개 파일만)

• 데이터가 다운로드가 완료되면, 데이터 변환 부분을 정의한후, 경로와 주석 파일의 경로를 설정한 후, 데이터를 Load 해보겠습니다.

from torchvision import datasets, transforms

# 데이터 변환 정의
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

• Dataset 불러오기

# COCO 데이터셋 경로와 주석 파일 경로 설정
train_data_path = '/content/data/coco/images/train2017'
train_ann_file = '/content/data/coco/annotations/annotations/instances_train2017.json'
val_data_path = '/content/data/coco/images/val2017'
val_ann_file = '/content/data/coco/annotations/annotations/instances_val2017.json'

# COCO 학습 데이터셋 불러오기
coco_train = datasets.CocoDetection(root=train_data_path, annFile=train_ann_file, transform=transform)

# COCO 검증 데이터셋 불러오기
coco_val = datasets.CocoDetection(root=val_data_path, annFile=val_ann_file, transform=transform)

loading annotations into memory...
Done (t=21.98s)
creating index...
index created!
loading annotations into memory...
Done (t=1.12s)
creating index...
index created!

• DataLoader 생성 & Image, Annotation 시각화

import matplotlib.pyplot as plt

# 커스텀 collate_fn 정의
def collate_fn(batch):
    return tuple(zip(*batch))

# DataLoader 생성
train_loader = DataLoader(coco_train, batch_size=2, shuffle=True, num_workers=2, collate_fn=collate_fn)
val_loader = DataLoader(coco_val, batch_size=2, shuffle=False, num_workers=2, collate_fn=collate_fn)

# DataLoader에서 첫 번째 배치 가져오기
images, targets = next(iter(train_loader))

# 배치 크기 출력
print(f"Batch size: {len(images)}")

# 첫 번째 이미지와 어노테이션을 가져와서 시각화
image = images[0]
annotations = targets[0]

# 이미지 시각화
image = image.permute(1, 2, 0) / 2 + 0.5  # 정규화 해제 및 (C, H, W) -> (H, W, C) 변경
plt.imshow(image.numpy())
plt.axis("off")

# 어노테이션 출력
print("Annotations:", annotations)

# 어노테이션 시각화
for annotation in annotations:
    bbox = annotation['bbox']
    x, y, width, height = bbox
    rect = plt.Rectangle((x, y), width, height, fill=False, color='red')
    plt.gca().add_patch(rect)

plt.show()

Batch size: 2
Annotations: [{'segmentation': [[133.48, 183.91, 164.13, 188.85, 200.72, 222.47, 229.39, 232.36, 259.06, 187.87, 244.22, 179.96, 263.01, 161.17, 293.66, 162.16, 282.79, 117.66, 286.74, 104.81, 335.19, 86.02, 366.83, 111.73, 355.96, 155.24, 375.73, 176.99, 380.67, 327.28, 411.33, 434.07, 362.88, 435.06, 357.93, 414.29, 300.58, 401.44, 276.85, 433.08, 248.18, 433.08, 279.82, 356.94, 289.71, 270.92, 273.89, 213.57, 237.3, 265.98, 197.75, 260.04, 130.52, 206.65]], 'area': 38538.08794999999, 'iscrowd': 0, 'image_id': 257219, 'bbox': [130.52, 86.02, 280.81, 349.04], 'category_id': 1, 'id': 520718}, {'segmentation': [[136.45, 185.89, 128.54, 142.38, 119.64, 121.62, 109.75, 89.98, 110.74, 57.35, 113.71, 27.69, 116.67, 11.87, 128.54, 15.82, 137.44, 26.7, 137.44, 56.36, 138.43, 89.98, 141.39, 140.4, 149.3, 186.88], [141.39, 194.79, 151.28, 195.78, 158.2, 212.58, 143.37, 215.55, 147.33, 201.71, 142.38, 197.75]], 'area': 3782.494, 'iscrowd': 0, 'image_id': 257219, 'bbox': [109.75, 11.87, 48.45, 203.68], 'category_id': 43, 'id': 659445}]

---

신경망 클래스 정의하기

• 신경망 모델을 nn.Module 의 하위클래스로 정의하고, __init__ 에서 신경망 계층들을 초기화합니다. 
• nn.Module 을 상속받은 모든 클래스는 forward 메소드에 입력 데이터에 대한 연산들을 구현합니다.

# 신경망 클래스 정의
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(64 * 8 * 8, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 8 * 8)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

• NeuralNetwork 의 인스턴스(instance)를 생성하고 이를 device 로 이동한 뒤, 구조(structure)를 출력합니다.

model = NeuralNetwork().to(device)
print(model)

NeuralNetwork(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc1): Linear(in_features=4096, out_features=128, bias=True)
  (fc2): Linear(in_features=128, out_features=10, bias=True)
)

• 모델을 사용하기 위해 입력 데이터를 전달합니다.
• 이는 일부 백그라운드 연산들과 함께 모델의 forward 를 실행합니다. model.forward() 를 직접 호출하지 마세요!
• 모델에 입력을 전달하여 호출하면 2차원 텐서를 반환합니다.
• 2차원 텐서의 dim=0은 각 분류(class)에 대한 원시(raw) 예측값 10개가, dim=1에는 각 출력의 개별 값들이 해당합니다.
• 원시 예측값을 nn.Softmax 모듈의 인스턴스에 통과시켜 예측 확률을 얻습니다.

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

# 테스트용 랜덤 데이터 생성 (3채널, 32x32 크기)
X = torch.rand(1, 3, 32, 32, device=device)

# 모델에 입력 전달하여 원시 예측값(logits) 얻기
logits = model(X)

# 원시 예측값을 Softmax 함수에 통과시켜 예측 확률을 계산
pred_probab = nn.Softmax(dim=1)(logits)

# 가장 높은 확률을 가진 클래스를 예측
y_pred = pred_probab.argmax(1)

print(f"Predicted class: {y_pred}")

Predicted class: tensor([5])

• 위의 코드에서 우리가 알 수 있는건, logits의 차원이 [batch_size, num_classes]임을 확인할 수 있습니다.
• 여기서 batch_size는 1이고, num_classes는 10입니다. 따라서 nn.Softmax(dim=1)을 사용하여 각 클래스에 대한 예측 확률을 계산하고, argmax(1)을 사용하여 가장 높은 확률을 가진 클래스를 예측합니다.

---

모델 계층(Layer)

• COCO Dataset으로 구성한 모델의 계층들을 살펴보겠습니다.
• 이를 설명하기 위해, 32x32 크기의 이미지 3개로 구성된 3개의 미니배치를 가져와, 신경망을 통과할 때 어떤 일이 발생하는지 알아보겠습니다.

input_image = torch.rand(3, 3, 32, 32).to(device)  # 예시 이미지 (batch_size=3, 채널=3, 높이=32, 너비=32)
print(f"Input image size: {input_image.size()}")

Input image size: torch.Size([3, 3, 32, 32])

---

nn.Flatten

• nn.Flatten 계층을 초기화하여 각 32x32의 3개 2D 이미지를 1024 픽셀 값을 갖는 연속된 배열로 변환합니다.
• (dim=0의 미니배치 차원은 유지됩니다.)

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.size())

torch.Size([3, 3072])

• 아래는 Flatten 관련 공식문서 입니다.

Flatten — PyTorch 2.4 documentation

---

nn.Linear

• Linear(선형)은 저장된 가중치(weight)와 편향(bias)을 사용하여 입력에 선형 변환(linear transformation)을 적용하는 모듈입니다.

layer1 = nn.Linear(in_features=3*32*32, out_features=20)
hidden1 = layer1(flat_image)
print(hidden1.size())

torch.Size([3, 20])

• 아래는 Linear 관련 공식문서 입니다.

Linear — PyTorch 2.4 documentation

---

nn.ReLU

• 비선형 활성화(activation)는 모델의 입력과 출력 사이에 복잡한 관계(mapping)를 만듭니다.
• 비선형 활성화는 선형 변환 후에 적용되어 비선형성(nonlinearity) 을 도입하고, 신경망이 다양한 현상을 학습할 수 있도록 돕습니다.
• 이 모델에서는 nn.ReLU 를 선형 계층들 사이에 사용하지만, 모델을 만들 때는 비선형성을 가진 다른 활성화를 도입할 수도 있습니다.

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")

Before ReLU: tensor([[ 0.0573, -0.4209,  0.1609,  0.0883, -0.2229, -0.2041,  0.4565, -0.5007,
          0.4450,  0.1568,  0.5146, -0.0457,  0.2785,  0.1053,  0.2393,  0.0431,
         -0.2777,  0.4349,  0.5298,  0.2587],
        [ 0.2132, -0.5740,  0.4295, -0.0561, -0.2113,  0.1131,  0.2910, -0.1083,
          0.8356,  0.1414,  0.6412,  0.0399, -0.1169,  0.2886, -0.1195, -0.1499,
         -0.2063,  0.1675,  0.5169,  0.1049],
        [-0.0463, -0.5933,  0.3965, -0.0786,  0.2606, -0.0190,  0.0483, -0.1813,
          0.1006,  0.1953,  0.5511, -0.0894,  0.0535,  0.0100, -0.1465,  0.3288,
         -0.6016,  0.4170,  0.4967, -0.0904]], grad_fn=<AddmmBackward0>)


After ReLU: tensor([[0.0573, 0.0000, 0.1609, 0.0883, 0.0000, 0.0000, 0.4565, 0.0000, 0.4450,
         0.1568, 0.5146, 0.0000, 0.2785, 0.1053, 0.2393, 0.0431, 0.0000, 0.4349,
         0.5298, 0.2587],
        [0.2132, 0.0000, 0.4295, 0.0000, 0.0000, 0.1131, 0.2910, 0.0000, 0.8356,
         0.1414, 0.6412, 0.0399, 0.0000, 0.2886, 0.0000, 0.0000, 0.0000, 0.1675,
         0.5169, 0.1049],
        [0.0000, 0.0000, 0.3965, 0.0000, 0.2606, 0.0000, 0.0483, 0.0000, 0.1006,
         0.1953, 0.5511, 0.0000, 0.0535, 0.0100, 0.0000, 0.3288, 0.0000, 0.4170,
         0.4967, 0.0000]], grad_fn=<ReluBackward0>)

• 아래는 ReLU 관련 공식문서 입니다.

ReLU — PyTorch 2.4 documentation

---

nn.Sequential

• nn.Sequential은 순서를 갖는 모듈의 컨테이너입니다. 데이터는 정의된 것과 같은 순서로 모든 모듈들을 통해 전달됩니다.
• 순차 컨테이너(sequential container)를 사용하여 아래의 seq_modules와 같은 신경망을 빠르게 만들 수 있습니다.

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
)
input_image = torch.rand(3,3,32,32)
logits = seq_modules(input_image)

• 아래는 Sequential 관련 공식문서 입니다.

Sequential — PyTorch 2.4 documentation

---

nn.Softmax

• 신경망의 마지막 선형 계층은 nn.Softmax 모듈에 전달될 ([-\infty, \infty] 범위의 원시 값(raw value)인) logits를 반환합니다.
• logits는 모델의 각 분류(class)에 대한 예측 확률을 나타내도록 [0, 1] 범위로 비례하여 조정(scale)됩니다.
• dim 매개변수는 값의 합이 1이 되는 차원을 나타냅니다.

softmax = nn.Softmax(dim=1)
pred_probab = softmax(logits)

• 아래는 Softmax 관련 공식문서 입니다.

Softmax — PyTorch 2.4 documentation

---

Model Parameter (모델 매개변수)

• 신경망 내부의 많은 계층들은 매개변수화되어 있습니다. 즉, 학습 중에 최적화되는 가중치와 편향과 연관지어집니다.
• nn.Module을 상속하면 모델 객체 내부의 모든 필드가 자동으로 추적되며, 모델의 parameters() 및 named_parameters() 메소드로 모든 매개변수에 접근할 수 있습니다.

print(f"Model structure: {model}\n\n")

for name, param in model.named_parameters():
    print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

Model structure: NeuralNetwork(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc1): Linear(in_features=4096, out_features=128, bias=True)
  (fc2): Linear(in_features=128, out_features=10, bias=True)
)


Layer: conv1.weight | Size: torch.Size([32, 3, 3, 3]) | Values : tensor([[[[ 0.1862,  0.0348, -0.0016],
          [ 0.1516,  0.0909,  0.1756],
          [ 0.0587,  0.0633, -0.1128]],

         [[-0.0136, -0.1710, -0.0311],
          [ 0.0688,  0.1021, -0.1459],
          [ 0.0731, -0.0228,  0.1869]],

         [[-0.0159, -0.1800,  0.0410],
          [ 0.0596, -0.1067,  0.1680],
          [ 0.0100,  0.0703,  0.1224]]],


        [[[ 0.1516, -0.0855,  0.1784],
          [-0.0829,  0.1167,  0.0004],
          [ 0.1342, -0.1512,  0.1785]],

         [[ 0.1377,  0.0012,  0.1171],
          [-0.0868,  0.1479, -0.0939],
          [ 0.1452, -0.0420,  0.0158]],

         [[ 0.1411,  0.1788, -0.1186],
          [-0.0699, -0.0885, -0.1091],
          [-0.1139, -0.1580, -0.0119]]]], grad_fn=<SliceBackward0>) 

Layer: conv1.bias | Size: torch.Size([32]) | Values : tensor([0.0369, 0.0015], grad_fn=<SliceBackward0>) 

Layer: conv2.weight | Size: torch.Size([64, 32, 3, 3]) | Values : tensor([[[[ 0.0261, -0.0033,  0.0156],
          [-0.0116, -0.0022, -0.0400],
          [ 0.0550, -0.0473, -0.0462]],

         [[-0.0382,  0.0463,  0.0364],
          [-0.0196, -0.0553,  0.0280],
          [ 0.0524, -0.0005,  0.0318]],

         [[-0.0081, -0.0541,  0.0227],
          [-0.0107, -0.0046, -0.0394],
          [ 0.0346, -0.0484,  0.0203]],

         [[ 0.0248,  0.0074, -0.0435],
          [ 0.0494, -0.0539, -0.0313],
          [-0.0139,  0.0093,  0.0336]],

         [[ 0.0106,  0.0555, -0.0151],
          [-0.0106,  0.0161, -0.0478],
          [-0.0356,  0.0211, -0.0143]],

         [[ 0.0135, -0.0491,  0.0255],
          [-0.0516, -0.0486, -0.0282],
          [-0.0481, -0.0337, -0.0122]],

         [[-0.0450,  0.0032, -0.0472],
          [ 0.0033,  0.0053, -0.0034],
          [ 0.0570, -0.0098,  0.0086]],

         [[ 0.0385, -0.0578, -0.0576],
          [-0.0207,  0.0442,  0.0084],
          [-0.0220, -0.0454, -0.0353]],

         [[-0.0533, -0.0340,  0.0005],
          [ 0.0214,  0.0571,  0.0404],
          [ 0.0541, -0.0429,  0.0041]],

         [[-0.0509,  0.0586,  0.0317],
          [-0.0149,  0.0130,  0.0563],
          [-0.0043, -0.0228, -0.0563]],

         [[ 0.0543, -0.0420, -0.0074],
          [-0.0381,  0.0271,  0.0301],
          [ 0.0370,  0.0410, -0.0316]],

         [[ 0.0021,  0.0214,  0.0581],
          [-0.0217,  0.0067, -0.0300],
          [-0.0211,  0.0366, -0.0019]],

         [[-0.0322,  0.0204, -0.0094],
          [-0.0565,  0.0257, -0.0122],
          [-0.0130, -0.0266,  0.0578]],

         [[ 0.0239, -0.0355, -0.0376],
          [-0.0540, -0.0484,  0.0044],
          [ 0.0365,  0.0062,  0.0125]],

         [[-0.0328, -0.0446, -0.0387],
          [-0.0175,  0.0550, -0.0388],
          [-0.0031, -0.0325,  0.0301]],

         [[-0.0568,  0.0489,  0.0270],
          [ 0.0042, -0.0009, -0.0015],
          [ 0.0099, -0.0251, -0.0406]],

         [[ 0.0460, -0.0018, -0.0092],
          [-0.0310, -0.0528, -0.0348],
          [ 0.0435,  0.0479, -0.0393]],

         [[ 0.0181, -0.0132,  0.0326],
          [-0.0507, -0.0439,  0.0052],
          [-0.0025,  0.0068,  0.0248]],

         [[-0.0230, -0.0340, -0.0012],
          [ 0.0510,  0.0510,  0.0431],
          [ 0.0512, -0.0428, -0.0508]],

         [[ 0.0119, -0.0538,  0.0500],
          [-0.0086,  0.0308,  0.0172],
          [ 0.0502, -0.0181,  0.0502]],

         [[ 0.0187, -0.0369,  0.0261],
          [-0.0415,  0.0309, -0.0035],
          [ 0.0058,  0.0536, -0.0583]],

         [[-0.0217, -0.0399,  0.0368],
          [ 0.0092, -0.0585, -0.0009],
          [-0.0216,  0.0067, -0.0349]],

         [[-0.0355,  0.0068,  0.0549],
          [ 0.0041,  0.0237,  0.0102],
          [-0.0146, -0.0274,  0.0007]],

         [[ 0.0155,  0.0301, -0.0056],
          [ 0.0213,  0.0533, -0.0066],
          [ 0.0281, -0.0354,  0.0441]],

         [[ 0.0214, -0.0189,  0.0268],
          [-0.0203,  0.0103, -0.0122],
          [-0.0404, -0.0540, -0.0231]],

         [[ 0.0250, -0.0109, -0.0444],
          [-0.0113,  0.0586, -0.0411],
          [ 0.0061, -0.0321,  0.0382]],

         [[-0.0398,  0.0332, -0.0158],
          [ 0.0252,  0.0501,  0.0411],
          [-0.0523, -0.0247, -0.0231]],

         [[ 0.0333, -0.0042,  0.0410],
          [ 0.0511, -0.0215, -0.0217],
          [ 0.0438, -0.0457,  0.0523]],

         [[ 0.0555, -0.0308, -0.0160],
          [ 0.0074, -0.0546,  0.0205],
          [-0.0022,  0.0011,  0.0252]],

         [[-0.0271, -0.0518,  0.0335],
          [-0.0443, -0.0261,  0.0511],
          [ 0.0046,  0.0201,  0.0094]],

         [[-0.0394,  0.0041, -0.0435],
          [-0.0553,  0.0472,  0.0565],
          [-0.0239, -0.0169, -0.0285]],

         [[-0.0039, -0.0521,  0.0482],
          [-0.0156,  0.0064,  0.0396],
          [-0.0213,  0.0476, -0.0256]]],


        [[[-0.0046,  0.0145, -0.0351],
          [ 0.0564, -0.0398,  0.0059],
          [ 0.0561, -0.0317,  0.0107]],

         [[ 0.0096,  0.0249,  0.0532],
          [-0.0453,  0.0322,  0.0254],
          [-0.0229,  0.0005, -0.0043]],

         [[ 0.0281, -0.0389,  0.0429],
          [-0.0140, -0.0191, -0.0558],
          [-0.0169, -0.0095,  0.0411]],

         [[-0.0243, -0.0522, -0.0273],
          [-0.0224,  0.0407, -0.0153],
          [ 0.0296,  0.0472,  0.0269]],

         [[-0.0263, -0.0583,  0.0072],
          [-0.0126,  0.0386,  0.0588],
          [ 0.0572,  0.0260,  0.0397]],

         [[ 0.0055, -0.0057,  0.0373],
          [ 0.0238,  0.0137, -0.0032],
          [-0.0514,  0.0505,  0.0456]],

         [[-0.0052,  0.0263, -0.0408],
          [-0.0184,  0.0117,  0.0134],
          [ 0.0475,  0.0481, -0.0333]],

         [[ 0.0055, -0.0045,  0.0471],
          [-0.0450,  0.0412, -0.0281],
          [ 0.0115, -0.0316, -0.0519]],

         [[ 0.0589, -0.0305, -0.0120],
          [ 0.0583,  0.0129, -0.0020],
          [-0.0315,  0.0077, -0.0470]],

         [[ 0.0085,  0.0025,  0.0049],
          [-0.0427,  0.0585, -0.0448],
          [ 0.0425, -0.0255,  0.0457]],

         [[-0.0528, -0.0304,  0.0579],
          [ 0.0587,  0.0509, -0.0329],
          [-0.0472,  0.0526, -0.0013]],

         [[ 0.0328,  0.0343,  0.0536],
          [ 0.0441, -0.0492, -0.0204],
          [-0.0176, -0.0359, -0.0517]],

         [[ 0.0475,  0.0533, -0.0492],
          [ 0.0375,  0.0327,  0.0192],
          [ 0.0313,  0.0143, -0.0359]],

         [[-0.0457,  0.0343, -0.0035],
          [ 0.0054,  0.0266, -0.0178],
          [ 0.0465, -0.0529,  0.0227]],

         [[ 0.0222,  0.0580,  0.0492],
          [-0.0518, -0.0102,  0.0129],
          [ 0.0024, -0.0120, -0.0244]],

         [[ 0.0328,  0.0052, -0.0091],
          [ 0.0147, -0.0322,  0.0079],
          [ 0.0581,  0.0536,  0.0395]],

         [[ 0.0571,  0.0274, -0.0572],
          [-0.0291, -0.0071,  0.0309],
          [-0.0275, -0.0344, -0.0133]],

         [[ 0.0083, -0.0212, -0.0163],
          [ 0.0016,  0.0081, -0.0539],
          [ 0.0514,  0.0232, -0.0131]],

         [[-0.0459,  0.0439, -0.0050],
          [ 0.0580, -0.0120,  0.0053],
          [-0.0080, -0.0338, -0.0377]],

         [[-0.0240, -0.0519,  0.0208],
          [ 0.0300,  0.0120, -0.0509],
          [ 0.0177, -0.0357,  0.0280]],

         [[ 0.0411,  0.0466,  0.0216],
          [-0.0384, -0.0498, -0.0453],
          [ 0.0241, -0.0505,  0.0160]],

         [[ 0.0215, -0.0070, -0.0181],
          [-0.0092,  0.0424,  0.0435],
          [ 0.0562,  0.0579,  0.0340]],

         [[ 0.0467, -0.0024,  0.0314],
          [-0.0296,  0.0027, -0.0065],
          [ 0.0082,  0.0352, -0.0466]],

         [[ 0.0436,  0.0248,  0.0524],
          [-0.0072,  0.0512,  0.0185],
          [-0.0121, -0.0014,  0.0202]],

         [[-0.0540, -0.0575,  0.0341],
          [-0.0342,  0.0018, -0.0057],
          [ 0.0339,  0.0207, -0.0463]],

         [[ 0.0514,  0.0430,  0.0307],
          [ 0.0415, -0.0236, -0.0101],
          [-0.0385,  0.0199, -0.0051]],

         [[-0.0059,  0.0523, -0.0029],
          [-0.0448,  0.0465,  0.0226],
          [ 0.0475, -0.0575,  0.0475]],

         [[-0.0255,  0.0292,  0.0408],
          [-0.0033, -0.0244,  0.0022],
          [ 0.0374,  0.0469, -0.0379]],

         [[-0.0435,  0.0137,  0.0501],
          [ 0.0573, -0.0491, -0.0328],
          [ 0.0438, -0.0108,  0.0485]],

         [[-0.0228,  0.0402,  0.0572],
          [ 0.0113,  0.0134,  0.0338],
          [-0.0061, -0.0067,  0.0375]],

         [[-0.0228, -0.0290, -0.0110],
          [-0.0108,  0.0270, -0.0585],
          [ 0.0146, -0.0237,  0.0506]],

         [[ 0.0435, -0.0279,  0.0165],
          [ 0.0082, -0.0263,  0.0276],
          [-0.0117, -0.0587, -0.0093]]]], grad_fn=<SliceBackward0>) 

Layer: conv2.bias | Size: torch.Size([64]) | Values : tensor([0.0459, 0.0281], grad_fn=<SliceBackward0>) 

Layer: fc1.weight | Size: torch.Size([128, 4096]) | Values : tensor([[ 0.0027,  0.0142,  0.0116,  ..., -0.0154, -0.0137,  0.0089],
        [-0.0085,  0.0151, -0.0105,  ...,  0.0156,  0.0036, -0.0009]],
       grad_fn=<SliceBackward0>) 

Layer: fc1.bias | Size: torch.Size([128]) | Values : tensor([ 0.0078, -0.0027], grad_fn=<SliceBackward0>) 

Layer: fc2.weight | Size: torch.Size([10, 128]) | Values : tensor([[-0.0851,  0.0683,  0.0769, -0.0242, -0.0485, -0.0455,  0.0060, -0.0253,
         -0.0572, -0.0365,  0.0849,  0.0399,  0.0157,  0.0204,  0.0319, -0.0372,
         -0.0494,  0.0634,  0.0423, -0.0338,  0.0369,  0.0409,  0.0178,  0.0684,
          0.0281,  0.0873,  0.0663, -0.0873,  0.0347,  0.0824, -0.0862,  0.0227,
          0.0617, -0.0119,  0.0280, -0.0161, -0.0133,  0.0130,  0.0692,  0.0263,
          0.0263, -0.0480,  0.0850, -0.0179, -0.0554,  0.0884, -0.0409,  0.0543,
         -0.0825, -0.0377, -0.0680, -0.0828,  0.0304,  0.0386, -0.0743, -0.0141,
         -0.0210,  0.0412, -0.0695, -0.0612,  0.0089,  0.0348, -0.0394, -0.0589,
         -0.0567,  0.0732, -0.0868,  0.0110, -0.0298,  0.0296, -0.0836, -0.0622,
          0.0703, -0.0871,  0.0445, -0.0328,  0.0007, -0.0167, -0.0450,  0.0015,
          0.0158, -0.0162,  0.0810, -0.0437, -0.0159, -0.0166, -0.0782, -0.0789,
          0.0116,  0.0774,  0.0143,  0.0677,  0.0234,  0.0194,  0.0540, -0.0581,
         -0.0653, -0.0875, -0.0568,  0.0002, -0.0132,  0.0447,  0.0854,  0.0395,
          0.0877,  0.0092,  0.0413,  0.0386, -0.0218,  0.0191,  0.0814,  0.0778,
          0.0066, -0.0696, -0.0212, -0.0205, -0.0504,  0.0609, -0.0035,  0.0474,
         -0.0036, -0.0858,  0.0570,  0.0103,  0.0613, -0.0809, -0.0502,  0.0717],
        [-0.0091, -0.0816,  0.0686,  0.0110, -0.0248,  0.0754, -0.0131,  0.0510,
          0.0722,  0.0730, -0.0234, -0.0703,  0.0167, -0.0108, -0.0445, -0.0461,
         -0.0363, -0.0355, -0.0004,  0.0655, -0.0189,  0.0531,  0.0087,  0.0299,
          0.0200,  0.0815, -0.0547,  0.0513, -0.0094, -0.0386,  0.0424,  0.0031,
         -0.0328, -0.0378, -0.0621,  0.0712,  0.0810, -0.0394, -0.0790,  0.0012,
          0.0828,  0.0331,  0.0110, -0.0693,  0.0290, -0.0009,  0.0421,  0.0749,
          0.0463, -0.0605, -0.0233, -0.0585,  0.0719,  0.0710, -0.0057, -0.0842,
         -0.0150, -0.0310, -0.0813,  0.0693, -0.0095, -0.0017, -0.0735, -0.0168,
         -0.0459, -0.0039,  0.0684,  0.0805, -0.0185, -0.0492,  0.0621, -0.0356,
         -0.0129,  0.0469,  0.0093, -0.0339, -0.0582,  0.0289,  0.0318, -0.0200,
          0.0064, -0.0593,  0.0564, -0.0241, -0.0087, -0.0299, -0.0273, -0.0353,
          0.0287, -0.0618,  0.0057, -0.0189, -0.0270,  0.0270, -0.0456,  0.0602,
         -0.0198,  0.0471, -0.0039,  0.0838, -0.0289, -0.0536, -0.0015, -0.0819,
          0.0193,  0.0430,  0.0797,  0.0279,  0.0719,  0.0276, -0.0168,  0.0597,
         -0.0049, -0.0140, -0.0434,  0.0210, -0.0388, -0.0803, -0.0560, -0.0640,
         -0.0567, -0.0504, -0.0409, -0.0306,  0.0519,  0.0862, -0.0011,  0.0158]],
       grad_fn=<SliceBackward0>) 

Layer: fc2.bias | Size: torch.Size([10]) | Values : tensor([-0.0226,  0.0007], grad_fn=<SliceBackward0>)

---

더 자세한 내용을 보고 싶으시면 아래 링크에 들어가서 공식 문서를 참고하세요!

• torch.nn API 관련 공식문서

torch.nn — PyTorch 2.4 documentation