AI-Powered Code Reading Platform

AI/ML 코드를 읽는 힘을 키우세요

실전 코드에서 AI가 문제를 생성하고, 틀린 부분을 분석해 맞춤 복습을 제안합니다.

208개 레슨6개 문제 유형AI 음성 강의

이런 문제를 풀어볼 수 있어요

AI가 실전 코드에서 자동 생성한 문제입니다

위 코드에서 보여주는 시퀀스 데이터(순서 있는 데이터)의 가장 핵심적인 특징은 무엇인가?

import torch
import torch.nn as nn

# 시퀀스 데이터 예시
sentence = ['안녕', '하세요', '오늘', '날씨가', '좋네요']  # 문장 데이터
stock_prices = [100, 102, 98, 105, 107, 103]  # 주식 가격 시계열
music_notes = ['도', '레', '미', '파', '솔']  # 음악 노트 시퀀스

# 일반 데이터와 시퀀스 데이터 비교
regular_data = torch.tensor([[1, 2], [3, 4], [5, 6]])  # 독립적인 샘플들
sequence_data = torch.tensor([1, 2, 3, 4, 5])  # 순서가 중요한 데이터

print(f"일반 데이터 shape: {regular_data.shape}")
print(f"시퀀스 데이터 shape: {sequence_data.shape}")
print(f"시퀀스에서 순서 바꾸면: {torch.tensor([5, 1, 3, 2, 4])}")

1.데이터의 크기가 일반 데이터보다 항상 작아야 한다

2.데이터 요소들 간의 순서와 위치가 의미를 가지며, 순서가 바뀌면 전체 의미가 달라진다

3.반드시 숫자로만 구성되어야 하고 문자열은 포함될 수 없다

4.텐서의 차원이 1차원으로 제한된다

Q2고급

풀어보기 →

아래 코드는 간소화된 인셉션 모듈을 정의하고, 임의의 입력을 통과시킵니다. forward 메서드 실행 후 `out.shape`의 채널(dim=1) 값은 무엇이며, 그 이유는 무엇인가요?

import torch
import torch.nn as nn

class MiniInception(nn.Module):
    def __init__(self, in_ch):                          # 입력 채널 수를 받는 생성자
        super().__init__()
        self.branch1 = nn.Conv2d(in_ch, 64, kernel_size=1)   # 경로1: 1×1 conv → 64채널
        self.branch2 = nn.Sequential(                         # 경로2: 1×1 축소 후 3×3 conv
            nn.Conv2d(in_ch, 96, kernel_size=1),              # 병목: 96채널로 축소
            nn.Conv2d(96, 128, kernel_size=3, padding=1)      # 3×3 conv → 128채널
        )
        self.branch3 = nn.Sequential(                         # 경로3: 1×1 축소 후 5×5 conv
            nn.Conv2d(in_ch, 16, kernel_size=1),              # 병목: 16채널로 축소
            nn.Conv2d(16, 32, kernel_size=3, padding=1),      # 첫 번째 3×3 conv → 32채널
            nn.Conv2d(32, 32, kernel_size=3, padding=1)       # 두 번째 3×3 conv → 32채널
        )
        self.branch4 = nn.Sequential(                         # 경로4: 풀링 후 1×1 conv
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1), # 3×3 맥스풀링 (크기 유지)
            nn.Conv2d(in_ch, 32, kernel_size=1)               # 1×1 conv → 32채널
        )

    def forward(self, x):                                     # 4경로 병렬 실행 후 합침
        b1 = self.branch1(x)                                  # 경로1 출력
        b2 = self.branch2(x)                                  # 경로2 출력
        b3 = self.branch3(x)                                  # 경로3 출력
        b4 = self.branch4(x)                                  # 경로4 출력
        return torch.cat([b1, b2, b3, b4], dim=1)            # 채널 축으로 연결

model = MiniInception(in_ch=192)                              # 입력 192채널로 모듈 생성
x = torch.randn(1, 192, 28, 28)                               # 배치1, 192채널, 28×28
out = model(x)                                                # forward 실행
print(out.shape)                                              # 출력 shape 확인

1.torch.Size([1, 192, 28, 28]) — 입력 채널과 동일

2.torch.Size([1, 288, 28, 28]) — 병목 채널 합산 포함

3.torch.Size([1, 256, 28, 28]) — 각 경로 출력 채널 합산

4.torch.Size([1, 320, 28, 28]) — 풀링 경로가 192채널 유지

Q3고급

풀어보기 →

다음은 GoogLeNet 스타일의 네트워크에서 보조 분류기(auxiliary classifier)를 구현한 코드입니다. 학습 시 `total_loss`가 역전파될 때, 보조 분류기가 그래디언트 흐름에 미치는 효과로 가장 정확한 설명은 무엇입니까?

import torch
import torch.nn as nn

class InceptionAux(nn.Module):
    def __init__(self, in_channels, num_classes):  # 보조 분류기 모듈 정의
        super().__init__()
        self.pool = nn.AdaptiveAvgPool2d((4, 4))   # 특성맵을 4×4로 축소
        self.conv = nn.Conv2d(in_channels, 128, 1)  # 1×1 합성곱으로 채널 축소
        self.fc1 = nn.Linear(128 * 4 * 4, 1024)     # 완전연결층
        self.fc2 = nn.Linear(1024, num_classes)      # 클래스 수만큼 출력

    def forward(self, x):                            # 보조 분류기 순전파
        x = self.pool(x)                             # 공간 차원 축소
        x = torch.relu(self.conv(x))                 # 1×1 합성곱 + 활성화
        x = x.view(x.size(0), -1)                    # 평탄화
        x = torch.relu(self.fc1(x))                  # 은닉층 + 활성화
        return self.fc2(x)                           # 로짓 출력

class SimpleInception(nn.Module):
    def __init__(self, num_classes=1000):             # 메인 네트워크 정의
        super().__init__()
        self.stem = nn.Sequential(                   # 초기 합성곱 블록
            nn.Conv2d(3, 64, 7, stride=2, padding=3),
            nn.ReLU(), nn.MaxPool2d(3, 2, 1))
        self.block_a = nn.Conv2d(64, 256, 3, padding=1)   # 중간 블록 A
        self.block_b = nn.Conv2d(256, 512, 3, padding=1)  # 중간 블록 B
        self.block_c = nn.Conv2d(512, 512, 3, padding=1)  # 후반 블록 C
        self.aux1 = InceptionAux(256, num_classes)   # block_a 출력에 연결된 보조 분류기
        self.aux2 = InceptionAux(512, num_classes)   # block_b 출력에 연결된 보조 분류기
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # 전역 평균 풀링
        self.fc = nn.Linear(512, num_classes)         # 최종 분류기

    def forward(self, x):                            # 메인 순전파
        x = self.stem(x)                             # 초기 특성 추출
        x = torch.relu(self.block_a(x))              # 블록 A 통과
        aux_out1 = self.aux1(x)                      # 보조 분류기 1: 블록 A 출력 사용
        x = torch.relu(self.block_b(x))              # 블록 B 통과
        aux_out2 = self.aux2(x)                      # 보조 분류기 2: 블록 B 출력 사용
        x = torch.relu(self.block_c(x))              # 블록 C 통과
        x = self.avgpool(x).flatten(1)               # 전역 풀링 후 평탄화
        main_out = self.fc(x)                        # 메인 분류기 출력
        return main_out, aux_out1, aux_out2          # 세 출력 모두 반환

model = SimpleInception(num_classes=10)               # 모델 생성
criterion = nn.CrossEntropyLoss()                     # 손실 함수 정의
x = torch.randn(2, 3, 224, 224)                       # 더미 입력
y = torch.tensor([3, 7])                              # 더미 레이블
main_out, aux1, aux2 = model(x)                       # 순전파 실행
total_loss = criterion(main_out, y) + 0.3 * criterion(aux1, y) + 0.3 * criterion(aux2, y)  # 가중 합산 손실
total_loss.backward()                                 # 역전파 실행