update

README.md

@@ -1,81 +1,113 @@
----
-datasets:
-- GATE-engine/omniglot
-language:
-- ko
-pipeline_tag: image-classification
-tags:
-- pytorch
-- few-shot-learning
-- one-shot-learning
-- meta-learning
----
-`torch` `torchvision` `tqdm`
+This implementation is inspired by [**"Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks"**](https://arxiv.org/abs/1703.05175) (2017) by Jake Snell, Kevin Swersky, Richard S. Zemel.
+* **Note & Reference:** [GitBook](https://lif31up.gitbook.io/lif31up/few-shot-learning/model-agnostic-meta-learning-for-fast-adaptation-of-deep-networks)
+* **Quickstart on Colab:** [Colab]()
 
-This implementation is inspired by **"Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks" (2017)**.
-* **task**: classifying image with few dataset.
-* **dataset**: downloaded from `torch` dataset library.
+|            | 5 Way ACC (5 shot) | 5 Way ACC(1 shot) |
+|------------|--------------------|------------------|
+|**Omniglot**|`100%` **(100/100)**|`96%` **(96/100)**|
 
 ## Model-Agnostic Meta-Learning for Few-Shot Image Classification
-This repository implements a Model-Agnostic Meta-Learning (MAML) algorithm for few-shot image classification tasks using PyTorch. MAML is designed to address the challenge of adapting to new tasks with limited examples by learning an initialization that enables fast adaptation with minimal gradient steps.
+This repository implements a Model-Agnostic Meta-Learning (MAML) algorithm for few-shot image classification tasks using PyTorch.
 
-Few-shot learning focuses on enabling models to generalize to new tasks with only a few labeled examples. MAML achieves this by optimizing for a set of parameters that can quickly adapt to new tasks through gradient-based updates, allowing the model to efficiently learn from limited data.
+* **Task**: classifying image with few dataset.
+* **Dataset**: `omniglot futurama`
 
-> You can access the full documentation here: [gitbook](https://lif31up.gitbook.io/lif31up/meta-learning/model-agnostic-meta-learning-for-fast-adaption-of-deep-networks)
+Few-shot learning focuses on enabling models to generalize to new tasks with only a few labeled examples. MAML achieves this by optimizing for a set of parameters that can quickly adapt to new tasks through gradient-based updates, allowing the model to efficiently learn from limited data.
 
-> You can access the test result on colab here: [colab](https://colab.research.google.com/drive/1ZmtP8rMZsSN_yA6tz3IKQU0ECXeAI018#scrollTo=iMjrWpR0FxHn)
+* **Inner-Loop Fast Adaption:** For each task, the model is fine-tuned on a small support set using a few gradient steps to minimize task-specific loss.
+* **Meta-Update (Outer Loop):** After task-specific updates, gradients are computed based on query set performance, and the initial model parameters are updated to improve adaptability across tasks.
 
-## Instruction
-Organize your dataset into a structure compatible with PyTorch's ImageFolder:
+---
+### Configuration
+confing.py contains the configuration settings for the model, including the framework, dimensions, learning rate, and other hyperparameters
+```python
+CONFIG = {
+  "version": "1.0.1",
+  # framework
+  "n_way": 5,
+  "k_shot": 1,
+  "n_query": 2,
+  # model
+  "inpt_dim": 3,
+  "hidn_dim": 6,
+  "oupt_dim": 5,
+  # hp
+  "iters": 5,
+  "epochs": 10,
+  "batch_size": 8,
+  "inner_batch_size": 5,
+  "alpha": 1e-2,
+  "beta": 1e-4,
+} # CONFIG
 ```
-dataset/
-  ├── class1/
-  │   ├── img1.jpg
-  │   ├── img2.jpg
-  │   └── ...
-  ├── class2/
-  │   ├── img1.jpg
-  │   ├── img2.jpg
-  │   └── ...
-  └── ...
- ```
-
 ### Training
-Run the training script with desired parameters:
-```Shell
-python run.py train --dataset_path path/to/your/dataset --save_to /path/to/save/model --n_way 5 --k_shot 2 --n_query 4 --epochs 1 --iters 4
-```
-* `path`: Path to your dataset.
-* `save_to`: path to save the trained model.
-* `n_way`: number of classes in each episode.
-* `k_shot`: Number of support samples per class.
-* `n-_query`: Number of query samples per class.
-
-> change training configuration from `config.py`
-
+train.py is a script to train the model on the omniglot dataset. It includes the training loop, evaluation, and saving the model checkpoints.
+```python
+if __name__ == "__main__":
+  from config import CONFIG
 
+  train(DATASET="../data/omniglot-py/images_background/Futurama", SAVE_TO="./model/5w1s", config=CONFIG)
+# if __name__ == "__main__":
+```
 ### Evaluation
-```Shell
-python run.py --dataset path/to/your/dataset --model path/to/saved/model.pth --n_way 5
+eval.py is used to evaluate the trained model on the omniglot dataset. It loads the model and tokenizer, processes the dataset, and computes the accuracy of the model.
+```python
+if __name__ == "__main__": evaluate("./model/5w1s.pth", "../data/omniglot-py/images_background/Futurama")
 # output example:
-# seen classes: [10, 11, 18, 1, 3]
-# unseen classes: [19, 1, 4, 2, 13]
-# accuracy: 1.0000(10/10)
+# seen classes: [1, 15, 6, 20, 12]
+# unseen classes: [22, 3, 16, 20, 18]
+# accuracy: 0.9000(9/10)
+```
+---
+## Technical Highlights
+Although MAML is one of the most prominent few-shot learning algorithms, it's mathematically complex even compared to other modern deep learning approaches. Both the learning and evaluation processes consist of two stages.
+
+### Inner Loop
+The inner loop is the first stage of MAML's algorithm where task-specific adaptations occur. It involves taking a small number of examples (support set) from a new task and creating parameters for each task. It then performs gradient updates to quickly adapt the model parameters for that specific task.
+
+```python
+def inner_update(self, task):
+  local_params = {name: param.clone() for name, param in self.named_parameters()}
+  for _ in range(self.epochs):
+    for feature, label in DataLoader(task, batch_size=self.batch_size, shuffle=True, num_workers=4, pin_memory=True):
+      feature, label = feature.to(self.device, non_blocking=True), label.to(self.device, non_blocking=True)
+      pred = self.forward(feature, local_params)
+      loss = nn.MSELoss()(pred, label)
+      grads = torch.autograd.grad(loss, list(local_params.values()), create_graph=True)
+      local_params = {name: param - (self.alpha * grad) for (name, param), grad in zip(local_params.items(), grads)}
+  # for for
+  return local_params
+# inner_update()
 ```
-* `model`: Path to your model.
-* `dataset`: Path to your dataset.
+### Outer Loop
+The outer-loop is the second stage of MAML's algorithm where meta-learning occurs. It optimizes the initial model parameters to ensure they can be quickly adapted to new tasks with minimal data. This stage uses performance on the query set to update the model's starting point.
 
-### Download Omniglot Dataset
-```Shell
-pyhton download --path ./somewhre/your/dataset/
+```python
+tasks, query_set = episoder.get_episode()
+local_params = list()
+for task in tasks: local_params.append(maml.inner_update(task))
+for feature, label in DataLoader(query_set, batch_size=CONFIG["batch_size"], shuffle=True, pin_memory=True, num_workers=4):
+  feature, label = feature.to(device, non_blocking=True), label.to(device, non_blocking=True)
+  for local_param in local_params:
+    pred = maml.forward(feature, local_param)
+    print(f"pred shape: {pred.shape} feature shape: {feature.shape} label shape: {label.shape}")
+  # for
+  break
+# for
 ```
-* `path`: Path to your dataset.
 
----
-### More Explanation
-**Model-Agnostic Meta-Learning(MAML)** is a powerful approach for few-shot learning, where the objective is to enable rapid adaptation to new tasks with very few labeled examples. The key idea behind MAML is to learn a model initialization that can be quickly fine-tuned on new tasks using only a small number of gradient updates, allowing efficient generalization to unseen data.
+### Forward
+The forward process in MAML differs significantly from other deep neural networks. First, it adapts to tasks from the query set. Then, it forwards each parameter per task and calculates probabilities.
 
-* **Task-Specific Adaptation:** Instead of learning fixed representations, MAML optimizes model parameters that can be rapidly adapted to different tasks with gradient-based updates.
-* **Inner-Loop Optimization:** For each task, the model is fine-tuned on a small support set using a few gradient steps to minimize task-specific loss.
-* **Meta-Update (Outer Loop):** After task-specific updates, gradients are computed based on query set performance, and the initial model parameters are updated to improve adaptability across tasks.
-* **Optimization:** The model is trained using second-order gradient updates (or first-order approximations) to optimize for fast adaptation while maintaining generalization ability.
+```python
+def forward(self, x, params=None):
+  if not params: params = dict(self.named_parameters())
+  x = F.conv2d(x, params['conv1.weight'], bias=params['conv1.bias'], stride=1, padding=1)
+  x = self.swish(x)
+  x = F.conv2d(x, params['conv2.weight'], bias=params['conv2.bias'], stride=1, padding=1)
+  x = self.pool(x)
+  x = self.flatten(x)
+  x = F.linear(x, weight=params['l1.weight'], bias=params['l1.bias'])
+  return self.softmax(x)
+# forward()
+```

config.py

@@ -0,0 +1,18 @@
+CONFIG = {
+  "version": "1.0.1",
+  # framework
+  "n_way": 5,
+  "k_shot": 1,
+  "n_query": 2,
+  # model
+  "inpt_dim": 3,
+  "hidn_dim": 6,
+  "oupt_dim": 5,
+  # hp
+  "iters": 5,
+  "epochs": 10,
+  "batch_size": 8,
+  "inner_batch_size": 5,
+  "alpha": 1e-2,
+  "beta": 1e-4,
+} # CONFIG