Upload 8 files

FOOD_GUIDE.md

@@ -0,0 +1,142 @@
+# 🍽️ 음식 이미지 분류 프로젝트 가이드
+
+## 📂 파일 구성
+
+| 파일 | 역할 | 필수? |
+|------|------|-------|
+| `app.py` | Gradio 웹 데모 | ✅ Space 필수 |
+| `README.md` | Space 설정 (YAML) | ✅ Space 필수 |
+| `requirements.txt` | 의존성 | ✅ Space 필수 |
+| `configuration_myresnet.py` | MyResNet Config | 옵션 B에서만 필요 |
+| `modeling_myresnet.py` | MyResNet 모델 | 옵션 B에서만 필요 |
+| `train_food.py` | Food-101 학습 스크립트 | 로컬 학습용 |
+
+## 🎯 두 가지 사용 시나리오
+
+### 시나리오 1: 학습 없이 바로 데모 실행 (추천) ⭐
+
+`app.py`는 기본적으로 **허깅페이스 허브의 공개 모델 `nateraw/food`**를 사용합니다.
+이 모델은 이미 Food-101에서 학습되어 약 90% 정확도를 보여요.
+
+**Space 업로드 파일 (3개면 충분):**
+1. `app.py`
+2. `README.md`
+3. `requirements.txt`
+
+즉, 이 시나리오에서는 `configuration_myresnet.py`, `modeling_myresnet.py`를
+Space에 올릴 필요가 없습니다!
+
+### 시나리오 2: 자체 학습한 MyResNet 사용
+
+직접 ResNet을 학습시켜서 그 모델로 데모를 돌리고 싶다면:
+
+**Step 1: 로컬에서 학습**
+```bash
+pip install torch torchvision transformers datasets accelerate
+python train_food.py
+```
+→ `./my-resnet18-food101/` 폴더에 학습된 모델 저장됨
+
+**Step 2: 모델 허브에 업로드**
+```bash
+huggingface-cli login
+
+python -c "
+from modeling_myresnet import MyResNetForImageClassification
+from configuration_myresnet import MyResNetConfig
+
+MyResNetConfig.register_for_auto_class()
+MyResNetForImageClassification.register_for_auto_class('AutoModelForImageClassification')
+
+model = MyResNetForImageClassification.from_pretrained('./my-resnet18-food101')
+model.push_to_hub('your-username/my-resnet18-food101')
+"
+```
+
+**Step 3: Space `app.py`에서 옵션 전환**
+```python
+# 옵션 A 부분을 주석 처리
+# from transformers import AutoImageProcessor, AutoModelForImageClassification
+# ...
+
+# 옵션 B 주석 해제
+from configuration_myresnet import MyResNetConfig
+from modeling_myresnet import MyResNetForImageClassification
+
+MODEL_ID = "your-username/my-resnet18-food101"
+model = MyResNetForImageClassification.from_pretrained(MODEL_ID)
+model.eval()
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model = model.to(device)
+id2label = model.config.id2label
+```
+
+**Step 4: 전처리 함수도 수동 버전으로 변경**
+```python
+from torchvision.transforms import Compose, Resize, ToTensor, Normalize
+
+_transform = Compose([
+    Resize((224, 224)),
+    ToTensor(),
+    Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
+
+def preprocess(image):
+    return _transform(image.convert("RGB")).unsqueeze(0).to(device)
+```
+
+## 🍜 Food-101의 101개 클래스
+
+```
+apple_pie, baby_back_ribs, baklava, beef_carpaccio, beef_tartare,
+beet_salad, beignets, bibimbap, bread_pudding, breakfast_burrito,
+bruschetta, caesar_salad, cannoli, caprese_salad, carrot_cake,
+ceviche, cheesecake, cheese_plate, chicken_curry, chicken_quesadilla,
+chicken_wings, chocolate_cake, chocolate_mousse, churros, clam_chowder,
+club_sandwich, crab_cakes, creme_brulee, croque_madame, cup_cakes,
+deviled_eggs, donuts, dumplings, edamame, eggs_benedict,
+escargots, falafel, filet_mignon, fish_and_chips, foie_gras,
+french_fries, french_onion_soup, french_toast, fried_calamari, fried_rice,
+frozen_yogurt, garlic_bread, gnocchi, greek_salad, grilled_cheese_sandwich,
+grilled_salmon, guacamole, gyoza, hamburger, hot_and_sour_soup,
+hot_dog, huevos_rancheros, hummus, ice_cream, lasagna,
+lobster_bisque, lobster_roll_sandwich, macaroni_and_cheese, macarons, miso_soup,
+mussels, nachos, omelette, onion_rings, oysters,
+pad_thai, paella, pancakes, panna_cotta, peking_duck,
+pho, pizza, pork_chop, poutine, prime_rib,
+pulled_pork_sandwich, ramen, ravioli, red_velvet_cake, risotto,
+samosa, sashimi, scallops, seaweed_salad, shrimp_and_grits,
+spaghetti_bolognese, spaghetti_carbonara, spring_rolls, steak, strawberry_shortcake,
+sushi, tacos, takoyaki, tiramisu, tuna_tartare, waffles
+```
+
+**재미있는 사실**: 🥘 **bibimbap (비빔밥)**, 🍣 **sushi**, 🥟 **gyoza (만두)**,
+🍜 **ramen**, 🌮 **tacos** 등 한식/일식/중식/멕시칸 등 다양한 국가 요리가 포함되어 있어요!
+
+## 💡 학습 시간/정확도 참고
+
+| 방식 | 시간 (GPU 1장) | 정확도 |
+|------|---------------|--------|
+| Scratch 학습 (30 epochs) | 약 6-10시간 | 약 60-70% |
+| Pretrained + Fine-tuning (10 epochs) | 약 2-4시간 | 약 80-85% |
+| 공개 모델 `nateraw/food` 사용 | 0 | ~90% |
+
+**초보자 추천**: 시나리오 1 (공개 모델 사용)로 먼저 Space를 띄워보고,
+나중에 관심 있으면 시나리오 2로 직접 학습해보세요!
+
+## 🐛 자주 겪는 문제
+
+### 1. 학습 시 OutOfMemory
+```python
+per_device_train_batch_size=64  # 32 또는 16으로 줄이기
+gradient_accumulation_steps=2   # 이걸 대신 추��
+```
+
+### 2. Food-101 다운로드가 느림
+- Food-101은 약 5GB입니다
+- 첫 다운로드 후에는 `~/.cache/huggingface/datasets/`에 캐시됨
+- 다운로드는 한 번만 하면 됩니다
+
+### 3. "KeyError: '0'" 에러
+- CIFAR 버전과 동일한 문제. `id2label[str(i)]` → `id2label[i]`로 수정
+- 이 프로젝트의 `app.py`는 이미 올바르게 되어 있음

README.md

@@ -0,0 +1,43 @@
+---
+title: Food Image Classifier
+emoji: 🍽
+colorFrom: red
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.29.0
+python_version: "3.10"
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# 🍽️ Food Image Classifier (Food-101)
+
+음식 이미지를 업로드하면 101개 음식 클래스 중 가장 유사한 것을 찾아주는 데모입니다.
+
+## 📂 데이터셋: Food-101
+
+- **101개 음식 클래스**
+- **101,000장 이미지** (클래스당 1,000장)
+- 라벨: pizza, sushi, hamburger, steak, pancakes, ramen, ice_cream, ...
+
+## 🏗️ 모델 구조
+
+ResNet ([He et al., 2015](https://arxiv.org/abs/1512.03385)) 논문을 기반으로 한
+이미지 분류 모델입니다.
+
+- Architecture: ResNet-18 / ResNet-50
+- Input size: 224×224 RGB
+- Transfer learning from ImageNet
+
+## 🎯 사용법
+
+1. 음식 이미지를 업로드하거나 드래그
+2. Top-5 예측 결과가 확률과 함께 표시됩니다
+
+## 📚 Reference
+
+- Paper: https://arxiv.org/abs/1512.03385
+- Dataset: https://data.vision.ee.ethz.ch/cvl/datasets_extra/food-101/
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,110 @@
+"""Gradio 웹 데모: Food-101 101개 음식 클래스 분류기.
+
+이 파일은 Hugging Face Spaces에서 자동 실행됩니다 (app_file: app.py).
+
+작동 방식:
+    1) 기본값: 허브의 'nateraw/food' 공개 모델 사용
+       (Pretrained ResNet + Food-101 fine-tuning으로 ~90% 정확도)
+    2) 직접 학습한 MyResNet이 있다면 아래 USE_CUSTOM_RESNET=True로 변경
+"""
+import torch
+import torch.nn.functional as F
+import gradio as gr
+
+
+# ============================================================
+# 설정
+# ============================================================
+USE_CUSTOM_RESNET = False                 # True: 자체 MyResNet 사용
+MODEL_ID = "nateraw/food"                 # 또는 "your-username/my-resnet18-food101"
+
+
+# ============================================================
+# 모델 로딩
+# ============================================================
+print(f"모델 로딩 중: {MODEL_ID}")
+
+if USE_CUSTOM_RESNET:
+    # 자체 학습한 MyResNet 불러오기
+    from configuration_myresnet import MyResNetConfig
+    from modeling_myresnet import MyResNetForImageClassification
+    from torchvision.transforms import Compose, Resize, ToTensor, Normalize
+
+    model = MyResNetForImageClassification.from_pretrained(MODEL_ID)
+    _transform = Compose([
+        Resize((224, 224)),
+        ToTensor(),
+        Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+
+    def preprocess(image):
+        return _transform(image.convert("RGB")).unsqueeze(0)
+
+else:
+    # 공개 모델 불러오기 (AutoImageProcessor가 전처리 자동 처리)
+    from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+    processor = AutoImageProcessor.from_pretrained(MODEL_ID)
+    model = AutoModelForImageClassification.from_pretrained(MODEL_ID)
+
+    def preprocess(image):
+        inputs = processor(images=image.convert("RGB"), return_tensors="pt")
+        return inputs["pixel_values"]
+
+
+model.eval()
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model = model.to(device)
+id2label = model.config.id2label
+
+print(f"디바이스: {device}")
+print(f"클래스 수: {len(id2label)}")
+
+
+# ============================================================
+# 예측 함수
+# ============================================================
+def classify(image):
+    """이미지를 Top-5 음식 클래스로 분류합니다."""
+    if image is None:
+        return {}
+
+    pixel_values = preprocess(image).to(device)
+
+    with torch.no_grad():
+        logits = model(pixel_values=pixel_values).logits
+    probs = F.softmax(logits, dim=-1)[0].cpu()
+
+    top5_probs, top5_idx = torch.topk(probs, k=5)
+
+    return {
+        id2label[idx.item()].replace("_", " ").title(): float(prob)
+        for prob, idx in zip(top5_probs, top5_idx)
+    }
+
+
+# ============================================================
+# Gradio UI
+# ============================================================
+TITLE = "🍽️ Food Image Classifier"
+
+DESCRIPTION = """
+음식 사진을 업로드하면 **Food-101** 데이터셋의 101개 음식 중 가장 유사한 것을 찾아 **Top-5** 결과로 보여줍니다.
+
+**지원 음식 예시:** 🍕 Pizza · 🍣 Sushi · 🍔 Hamburger · 🥩 Steak · 🥞 Pancakes · 🍜 Ramen · 🍦 Ice Cream · 🥘 Bibimbap · 🌮 Tacos · 🥟 Gyoza · ...
+
+**모델:** ResNet-18 (Pretrained on ImageNet, Fine-tuned on Food-101)
+"""
+
+demo = gr.Interface(
+    fn=classify,
+    inputs=gr.Image(type="pil", label="음식 이미지 업로드"),
+    outputs=gr.Label(num_top_classes=5, label="예측 결과"),
+    title=TITLE,
+    description=DESCRIPTION,
+    flagging_mode="never",
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

configuration_myresnet.py

@@ -0,0 +1,58 @@
+"""MyResNet 모델 설정 클래스.
+
+ResNet (He et al., 2015) 논문을 바탕으로 구현한 커스텀 모델의 설정입니다.
+허깅페이스 PretrainedConfig를 상속받아 save_pretrained / from_pretrained 호환됩니다.
+"""
+from typing import List, Optional
+
+from transformers import PretrainedConfig
+
+
+class MyResNetConfig(PretrainedConfig):
+    """
+    MyResNet 모델의 하이퍼파라미터를 저장하는 Config 클래스.
+
+    Args:
+        num_channels (int): 입력 이미지 채널 수 (RGB=3, grayscale=1).
+        num_labels (int): 분류할 클래스 개수.
+        block_type (str): 'basic' (ResNet-18/34) 또는 'bottleneck' (ResNet-50/101/152).
+        layers (List[int]): 각 stage(conv2_x ~ conv5_x)에 들어갈 블록 개수.
+            - ResNet-18:  [2, 2, 2, 2]
+            - ResNet-34:  [3, 4, 6, 3]
+            - ResNet-50:  [3, 4, 6, 3] (bottleneck)
+            - ResNet-101: [3, 4, 23, 3] (bottleneck)
+            - ResNet-152: [3, 8, 36, 3] (bottleneck)
+        hidden_sizes (List[int]): 각 stage의 기본 채널 수. 기본값 [64, 128, 256, 512].
+        image_size (int): 입력 이미지 크기 (정사각형 기준).
+
+    Example:
+        >>> from configuration_myresnet import MyResNetConfig
+        >>> config = MyResNetConfig(num_labels=10, layers=[2, 2, 2, 2])
+    """
+
+    model_type = "myresnet"
+
+    def __init__(
+        self,
+        num_channels: int = 3,
+        num_labels: int = 1000,
+        block_type: str = "basic",
+        layers: Optional[List[int]] = None,
+        hidden_sizes: Optional[List[int]] = None,
+        image_size: int = 224,
+        **kwargs,
+    ):
+        super().__init__(num_labels=num_labels, **kwargs)
+        self.num_channels = num_channels
+        self.block_type = block_type
+        self.layers = layers if layers is not None else [3, 4, 6, 3]
+        self.hidden_sizes = hidden_sizes if hidden_sizes is not None else [64, 128, 256, 512]
+        self.image_size = image_size
+
+        # 검증
+        if block_type not in ("basic", "bottleneck"):
+            raise ValueError(f"block_type must be 'basic' or 'bottleneck', got {block_type}")
+        if len(self.layers) != 4:
+            raise ValueError(f"layers must have length 4, got {len(self.layers)}")
+        if len(self.hidden_sizes) != 4:
+            raise ValueError(f"hidden_sizes must have length 4, got {len(self.hidden_sizes)}")

modeling_myresnet.py

@@ -0,0 +1,245 @@
+"""MyResNet 모델 구현.
+
+ResNet (Deep Residual Learning for Image Recognition, He et al., 2015)
+논문을 PyTorch + 허깅페이스 transformers 포맷으로 구현한 파일입니다.
+"""
+from typing import Optional, Union, Tuple
+
+import torch
+import torch.nn as nn
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import ImageClassifierOutput
+
+from configuration_myresnet import MyResNetConfig
+
+
+# ============================================================
+# Basic Block (ResNet-18/34용) - 논문 Fig 2
+# ============================================================
+class BasicBlock(nn.Module):
+    """2개의 3x3 conv로 이루어진 기본 residual block.
+
+    y = ReLU( BN(conv(ReLU(BN(conv(x))))) + shortcut(x) )
+    """
+
+    expansion = 1  # 출력 채널 배수
+
+    def __init__(self, in_channels: int, out_channels: int, stride: int = 1):
+        super().__init__()
+        # 첫 번째 3x3 conv (stride로 다운샘플링 가능)
+        self.conv1 = nn.Conv2d(
+            in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False
+        )
+        self.bn1 = nn.BatchNorm2d(out_channels)
+
+        # 두 번째 3x3 conv (stride=1 고정)
+        self.conv2 = nn.Conv2d(
+            out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False
+        )
+        self.bn2 = nn.BatchNorm2d(out_channels)
+        self.relu = nn.ReLU(inplace=True)
+
+        # Shortcut: 차원이 바뀔 때만 projection (1x1 conv) 사용 (논문 Eqn.2, Option B)
+        if stride != 1 or in_channels != out_channels * self.expansion:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(
+                    in_channels,
+                    out_channels * self.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False,
+                ),
+                nn.BatchNorm2d(out_channels * self.expansion),
+            )
+        else:
+            self.shortcut = nn.Identity()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        identity = self.shortcut(x)
+        out = self.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out = out + identity           # 논문 Eqn.1: F(x) + x
+        return self.relu(out)          # addition 후 ReLU (논문 Sec 3.2)
+
+
+# ============================================================
+# Bottleneck Block (ResNet-50/101/152용) - 논문 Fig 5 오른쪽
+# ============================================================
+class BottleneckBlock(nn.Module):
+    """1x1 -> 3x3 -> 1x1 구조로 채널을 줄였다가 다시 늘리는 bottleneck block.
+
+    마지막 1x1 conv에서 채널을 expansion(=4)배로 확장합니다.
+    """
+
+    expansion = 4
+
+    def __init__(self, in_channels: int, out_channels: int, stride: int = 1):
+        super().__init__()
+        # 1x1 conv: 채널 축소
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+
+        # 3x3 conv: 실제 연산 (bottleneck 중심)
+        self.conv2 = nn.Conv2d(
+            out_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False
+        )
+        self.bn2 = nn.BatchNorm2d(out_channels)
+
+        # 1x1 conv: 채널 복원 (4배로 확장)
+        self.conv3 = nn.Conv2d(
+            out_channels, out_channels * self.expansion, kernel_size=1, bias=False
+        )
+        self.bn3 = nn.BatchNorm2d(out_channels * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+
+        if stride != 1 or in_channels != out_channels * self.expansion:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(
+                    in_channels,
+                    out_channels * self.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False,
+                ),
+                nn.BatchNorm2d(out_channels * self.expansion),
+            )
+        else:
+            self.shortcut = nn.Identity()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        identity = self.shortcut(x)
+        out = self.relu(self.bn1(self.conv1(x)))
+        out = self.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        out = out + identity
+        return self.relu(out)
+
+
+# ============================================================
+# PreTrainedModel 베이스 클래스
+# ============================================================
+class MyResNetPreTrainedModel(PreTrainedModel):
+    """from_pretrained / save_pretrained 등을 지원하는 베이스 클래스."""
+
+    config_class = MyResNetConfig
+    base_model_prefix = "myresnet"
+    main_input_name = "pixel_values"
+    supports_gradient_checkpointing = False
+
+    def _init_weights(self, module):
+        """논문 Sec 3.4: He initialization 사용."""
+        if isinstance(module, nn.Conv2d):
+            nn.init.kaiming_normal_(module.weight, mode="fan_out", nonlinearity="relu")
+        elif isinstance(module, nn.BatchNorm2d):
+            nn.init.constant_(module.weight, 1)
+            nn.init.constant_(module.bias, 0)
+        elif isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=0.01)
+            if module.bias is not None:
+                nn.init.constant_(module.bias, 0)
+
+
+# ============================================================
+# 이미지 분류용 ResNet
+# ============================================================
+class MyResNetForImageClassification(MyResNetPreTrainedModel):
+    """이미지 분류용 ResNet 모델.
+
+    입력: pixel_values (batch, num_channels, H, W)
+    출력: ImageClassifierOutput(loss, logits)
+
+    논문 Table 1의 구조를 따릅니다:
+        conv1 (7x7, stride=2) -> maxpool -> stage1~4 -> avgpool -> fc
+    """
+
+    def __init__(self, config: MyResNetConfig):
+        super().__init__(config)
+        self.config = config
+
+        # 블록 종류 선택
+        block = BasicBlock if config.block_type == "basic" else BottleneckBlock
+        self.in_channels = 64
+
+        # ---- Stem (논문 Table 1 conv1) ----
+        # 7x7 conv, 64 channels, stride=2 + BN + ReLU + maxpool
+        self.stem = nn.Sequential(
+            nn.Conv2d(
+                config.num_channels, 64, kernel_size=7, stride=2, padding=3, bias=False
+            ),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+        )
+
+        # ---- 4 stages (conv2_x ~ conv5_x) ----
+        self.stage1 = self._make_stage(
+            block, config.hidden_sizes[0], config.layers[0], stride=1
+        )
+        self.stage2 = self._make_stage(
+            block, config.hidden_sizes[1], config.layers[1], stride=2
+        )
+        self.stage3 = self._make_stage(
+            block, config.hidden_sizes[2], config.layers[2], stride=2
+        )
+        self.stage4 = self._make_stage(
+            block, config.hidden_sizes[3], config.layers[3], stride=2
+        )
+
+        # ---- Classification head ----
+        self.avgpool = nn.AdaptiveAvgPool2d(output_size=1)
+        self.classifier = nn.Linear(
+            config.hidden_sizes[3] * block.expansion, config.num_labels
+        )
+
+        # 가중치 초기화 적용
+        self.post_init()
+
+    def _make_stage(self, block, out_channels: int, num_blocks: int, stride: int):
+        """하나의 stage(동일 해상도의 블록들)를 만드는 헬퍼.
+
+        첫 블록만 stride로 다운샘플링하고, 나머지는 stride=1.
+        """
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for s in strides:
+            layers.append(block(self.in_channels, out_channels, stride=s))
+            self.in_channels = out_channels * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(
+        self,
+        pixel_values: torch.Tensor,
+        labels: Optional[torch.Tensor] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, ImageClassifierOutput]:
+        """순전파.
+
+        Args:
+            pixel_values: (batch, num_channels, H, W) 형태의 이미지 텐서.
+            labels: (batch,) 형태의 정답 레이블. 주어지면 loss도 함께 반환.
+            return_dict: True면 ImageClassifierOutput, False면 튜플 반환.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # Shape 흐름: (B, 3, 224, 224)
+        x = self.stem(pixel_values)    # -> (B, 64, 56, 56)
+        x = self.stage1(x)             # -> (B, 64*e, 56, 56)
+        x = self.stage2(x)             # -> (B, 128*e, 28, 28)
+        x = self.stage3(x)             # -> (B, 256*e, 14, 14)
+        x = self.stage4(x)             # -> (B, 512*e, 7, 7)
+
+        x = self.avgpool(x)            # -> (B, 512*e, 1, 1)
+        x = torch.flatten(x, 1)        # -> (B, 512*e)
+        logits = self.classifier(x)    # -> (B, num_labels)
+
+        # Loss 계산 (Trainer 호환)
+        loss = None
+        if labels is not None:
+            loss_fn = nn.CrossEntropyLoss()
+            loss = loss_fn(logits, labels)
+
+        if not return_dict:
+            output = (logits,)
+            return ((loss,) + output) if loss is not None else output
+
+        return ImageClassifierOutput(loss=loss, logits=logits)

requirements.txt

@@ -0,0 +1,6 @@
+gradio==5.29.0
+torch
+torchvision
+transformers
+Pillow
+numpy

train_food.py

@@ -0,0 +1,226 @@
+"""Food-101 데이터셋으로 MyResNet을 학습하는 스크립트.
+
+torchvision의 ImageNet pretrained ResNet-18 가중치를 가져와서
+MyResNet에 로드한 후 Food-101에 fine-tuning합니다.
+
+사용법:
+    python train_food.py
+
+요구사항:
+    pip install torch torchvision transformers datasets accelerate
+
+학습 시간 (GPU 1장 기준):
+    - Food-101 full (101종): 약 2~4시간 (10 epoch)
+    - 빠른 테스트: epochs=3으로 줄이면 1시간 내
+"""
+import numpy as np
+import torch
+import torch.nn as nn
+import torchvision.models as tv_models
+from datasets import load_dataset
+from torchvision.transforms import (
+    Compose,
+    Normalize,
+    RandomCrop,
+    RandomHorizontalFlip,
+    Resize,
+    ToTensor,
+)
+from transformers import DefaultDataCollator, Trainer, TrainingArguments
+
+from configuration_myresnet import MyResNetConfig
+from modeling_myresnet import MyResNetForImageClassification
+
+
+# ============================================================
+# 1) 데이터셋 로딩
+# ============================================================
+print("Food-101 데이터셋 로딩 중...")
+dataset = load_dataset("food101")
+
+# Food-101의 101개 클래스명 가져오기
+food_classes = dataset["train"].features["label"].names
+NUM_CLASSES = len(food_classes)
+print(f"총 클래스 수: {NUM_CLASSES}")
+print(f"학습 이미지: {len(dataset['train']):,}장")
+print(f"검증 이미지: {len(dataset['validation']):,}장")
+
+
+# ============================================================
+# 2) 모델 준비 - ResNet-18 + Pretrained 가중치 로드
+# ============================================================
+config = MyResNetConfig(
+    num_channels=3,
+    num_labels=NUM_CLASSES,
+    block_type="basic",
+    layers=[2, 2, 2, 2],                # ResNet-18
+    hidden_sizes=[64, 128, 256, 512],
+    image_size=224,
+    id2label={i: name for i, name in enumerate(food_classes)},
+    label2id={name: i for i, name in enumerate(food_classes)},
+)
+model = MyResNetForImageClassification(config)
+
+
+def load_pretrained_resnet18(model):
+    """torchvision의 ImageNet pretrained ResNet-18 가중치를 MyResNet에 복사.
+
+    두 모델의 레이어 이름이 다르므로 매핑해줍니다.
+    마지막 FC 레이어(classifier)는 클래스 수가 다르므로 스킵.
+    """
+    print("ImageNet pretrained ResNet-18 가중치 로딩...")
+    tv_resnet = tv_models.resnet18(weights=tv_models.ResNet18_Weights.IMAGENET1K_V1)
+    tv_state = tv_resnet.state_dict()
+
+    # torchvision -> MyResNet 레이어 이름 매핑
+    # tv_resnet:  conv1, bn1, layer1~4, fc
+    # MyResNet:   stem.0 (conv1), stem.1 (bn1), stage1~4, classifier
+    mapping = {
+        "conv1.": "stem.0.",
+        "bn1.": "stem.1.",
+        "layer1.": "stage1.",
+        "layer2.": "stage2.",
+        "layer3.": "stage3.",
+        "layer4.": "stage4.",
+    }
+
+    # downsample은 shortcut으로 매핑 (각 stage의 첫 블록에만 있음)
+    new_state = {}
+    for k, v in tv_state.items():
+        if k.startswith("fc."):
+            continue  # FC 레이어는 스킵 (클래스 수가 다름)
+
+        new_k = k
+        for old, new in mapping.items():
+            if new_k.startswith(old):
+                new_k = new_k.replace(old, new, 1)
+                break
+
+        # layer1.0.downsample.0 -> stage1.0.shortcut.0
+        new_k = new_k.replace(".downsample.", ".shortcut.")
+        new_state[new_k] = v
+
+    # strict=False로 부분 로드 (classifier는 학습 필요)
+    missing, unexpected = model.load_state_dict(new_state, strict=False)
+    print(f"로드 성공. 누락된 키 {len(missing)}개 (classifier 등), "
+          f"예상치 못한 키 {len(unexpected)}개")
+    return model
+
+
+model = load_pretrained_resnet18(model)
+print(f"모델 파라미터 수: {sum(p.numel() for p in model.parameters()):,}")
+
+
+# ============================================================
+# 3) 데이터 전처리
+# ============================================================
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD = [0.229, 0.224, 0.225]
+
+train_transform = Compose([
+    Resize(256),
+    RandomCrop(224),
+    RandomHorizontalFlip(),
+    ToTensor(),
+    Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+])
+eval_transform = Compose([
+    Resize((224, 224)),
+    ToTensor(),
+    Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+])
+
+
+def preprocess_train(batch):
+    batch["pixel_values"] = [
+        train_transform(img.convert("RGB")) for img in batch["image"]
+    ]
+    batch["labels"] = batch["label"]
+    return batch
+
+
+def preprocess_eval(batch):
+    batch["pixel_values"] = [
+        eval_transform(img.convert("RGB")) for img in batch["image"]
+    ]
+    batch["labels"] = batch["label"]
+    return batch
+
+
+train_ds = dataset["train"].with_transform(preprocess_train)
+eval_ds = dataset["validation"].with_transform(preprocess_eval)
+
+
+# ============================================================
+# 4) 평가 지표 (top-1 + top-5 accuracy)
+# ============================================================
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    # Top-1 accuracy
+    top1_preds = np.argmax(logits, axis=-1)
+    top1_acc = (top1_preds == labels).mean()
+
+    # Top-5 accuracy
+    top5_preds = np.argsort(-logits, axis=-1)[:, :5]
+    top5_correct = np.any(top5_preds == labels[:, None], axis=-1)
+    top5_acc = top5_correct.mean()
+
+    return {
+        "accuracy": float(top1_acc),
+        "top5_accuracy": float(top5_acc),
+    }
+
+
+# ============================================================
+# 5) Trainer 설정
+# ============================================================
+training_args = TrainingArguments(
+    output_dir="./my-resnet18-food101",
+    num_train_epochs=10,                    # 10 epoch 권장 (pretrained이므로 적게)
+    per_device_train_batch_size=64,
+    per_device_eval_batch_size=64,
+    learning_rate=1e-3,                     # pretrained이므로 더 작게 시작
+    weight_decay=1e-4,
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.05,
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    save_total_limit=2,
+    logging_steps=50,
+    load_best_model_at_end=True,
+    metric_for_best_model="accuracy",
+    greater_is_better=True,
+    fp16=torch.cuda.is_available(),
+    remove_unused_columns=False,
+    dataloader_num_workers=4,
+    report_to="none",
+    push_to_hub=False,                      # True로 바꾸면 자동 업로드
+    # hub_model_id="your-username/my-resnet18-food101",
+)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_ds,
+    eval_dataset=eval_ds,
+    data_collator=DefaultDataCollator(),
+    compute_metrics=compute_metrics,
+)
+
+
+# ============================================================
+# 6) 학습 실행
+# ============================================================
+if __name__ == "__main__":
+    print("\n=== Food-101 학습 시작 ===")
+    trainer.train()
+
+    metrics = trainer.evaluate()
+    print(f"\n최종 Top-1 정확도: {metrics['eval_accuracy']:.4f}")
+    print(f"최종 Top-5 정확도: {metrics['eval_top5_accuracy']:.4f}")
+
+    trainer.save_model("./my-resnet18-food101")
+    print("모델 저장 완료: ./my-resnet18-food101")
+
+    # 허브 업로드:
+    # trainer.push_to_hub()