init: safetensor, bin

config.json

@@ -0,0 +1,8 @@
+{
+  "sate": "model.state_dict()",
+  "FRAMEWORK": [5, 5, 2],
+  "MODEL_CONFIG": [3, 26, 3],
+  "HYPER_PARAMETERS": {"lr":  0.0001, "weight_decay": 0.0001},
+  "TRANSFORM": "transform",
+  "METRIC": "euclidean"
+}

config.py

@@ -1,8 +0,0 @@
-HYPERPARAMETER_CONFIG = {
-  "lr": 0.0001,
-  "weight_decay": 0.0001
-} # HYPERPARAMETER_CONFIG
-TRAINING_CONFIG = {
-  "iters": 10,
-  "epochs": 30,
-} # TRAINING_CONFIG

src/model/ProtoNet.py → model.py

@@ -1,13 +1,10 @@
-import torch
-from torch import nn
-import torch.nn.functional as torch_f
-
 class ProtoNet(nn.Module):
-  def __init__(self, in_channels=3, hidden_channel=26, output_channel=3):
+  def __init__(self, in_channels, hidden_channel):
     super(ProtoNet, self).__init__()
+    # 임베딩 네트워크
     self.conv1 = nn.Conv2d(in_channels, hidden_channel, kernel_size=3, stride=1, padding=1)
     self.conv2 = nn.Conv2d(hidden_channel, hidden_channel, kernel_size=3, stride=1, padding=1)
-    self.conv3 = nn.Conv2d(hidden_channel, output_channel, kernel_size=3, stride=1, padding=1)
+    self.conv3 = nn.Conv2d(hidden_channel, in_channels, kernel_size=3, stride=1, padding=1)
     self.relu = nn.ReLU()
     self.flatten = nn.Flatten()
     self.softmax = nn.LogSoftmax(dim=1)
@@ -16,18 +13,19 @@ class ProtoNet(nn.Module):
   def prototyping(self, prototypes): self.prototypes = prototypes
 
   def cdist(self, x: torch.Tensor, metric="euclidean") -> torch.Tensor:
+    # 거리 함수
     assert self.prototypes is not None, "Prototypes must be set before calling cdist."
     assert x.size(1) == self.prototypes.size(1), "Feature dimensions must match."
     if metric == "euclidean":
       dists = torch.cdist(x, self.prototypes, p=2)  # L2 distance
     elif metric == "cosine":
-      dists = 1 - torch_f.cosine_similarity(x.unsqueeze(1), self.prototypes.unsqueeze(0), dim=2)  # 1 - cosine similarity
+      dists = 1 - F.cosine_similarity(x.unsqueeze(1), self.prototypes.unsqueeze(0), dim=2)  # 1 - cosine similarity
     else:
       raise ValueError("Unsupported distance metric. Choose 'euclidean' or 'cosine'.")
     return dists
   # cdist()
 
-  def forward(self, x):
+  def forward(self, x, metric="euclidean"):
     x = self.conv1(x)
     x = self.relu(x)
     x = self.conv2(x)
@@ -35,7 +33,7 @@ class ProtoNet(nn.Module):
     x = self.conv3(x)
     x = self.relu(x)
     x = self.flatten(x)
-    x = self.cdist(x, metric="euclidean")
+    x = self.cdist(x, metric=metric)
     return self.softmax(-x)
   # forward
 # ProtoNet

prototypical_network.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1207dad08600ea1a3f1a622d2469a3208ebc8dd007c3b6051b256d7df5103f03
+size 34442

prototypical_network.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe7d84d01a2cbd6369d78422355940f7f902eb78e9359f764d8ebc7c77eacad8
+size 30620

run.py

@@ -1,41 +0,0 @@
-import argparse
-import torchvision as tv
-from src.train import train
-from src.evaluate import evaluate
-
-def main():
-  # eval(default)
-  parser = argparse.ArgumentParser(description="Few-shot learning using Prototypical Network")
-  parser.add_argument("--model", type=str, help="path of your model")
-  parser.add_argument("--dataset", type=str, help="path of your dataset")
-
-  # train
-  subparser = parser.add_subparsers(title="subcommands", dest="subcommand")
-  parser_train = subparser.add_parser("train", help="train your model")
-  parser_train.add_argument("--dataset", type=str, help="path to your dataset")
-  parser_train.add_argument("--save_to", type=str, help="path to save your model")
-  parser_train.add_argument("--n_way", type=int, help="number of classes per episode")
-  parser_train.add_argument("--k_shot", type=int, help="number of support samples per class")
-  parser_train.add_argument("--n_query", type=int, help="number of query samples per class")
-  parser_train.add_argument("--iters", type=int, help="how much iteration your model does for an episode")
-  parser_train.add_argument("--epochs", type=int, help="how much epochs your model does for training")
-  parser_train.set_defaults(func=lambda kwargs: train(
-    DATASET=kwargs.dataset,
-    SAVE_TO=kwargs.save_to,
-    N_WAY=kwargs.n_way,
-    K_SHOT=kwargs.k_shot,
-    N_QUERY=kwargs.n_query)
-  ) # parser_train.set_defaults()
-
-  # download dataset
-  parser_download = subparser.add_parser("download", help="download dataset")
-  parser_download.add_argument("--path", type=str, help="path to download dataset")
-  parser_download.set_defaults(func=lambda kwargs: tv.datasets.Omniglot(root=kwargs.path, background=True, download=True))
-
-  # parse logic
-  args = parser.parse_args()
-  if hasattr(args, 'func'): args.func(args)
-  else: evaluate(MODEL=args.model, DATASET=args.dataset)
-# main():
-
-if __name__ == "__main__": main()

src/FewShotEpisoder.py

@@ -1,84 +0,0 @@
-import random
-import typing
-import torch
-from torch.utils.data import Dataset
-import torch.nn.functional as F
-
-class FewShotDataset(Dataset):
-  """ A custom Dataset class for Few-Shot Learning tasks.
-    This dataset can operate in two modes: "support" (for prototype calculation) and "query" (for evaluation). """
-  def __init__(self, dataset, indices: list, classes: list, transform:typing.Callable, mode="support"):
-    """ Args:
-        dataset (list): List of (feature, label) pairs.
-        indices (list): List of indices to be used for the dataset.
-        transform (callable): Transform to be applied to the features.
-        mode (str): Mode of operation, either "support" or "query". Default is "support". """
-    assert mode in ["support", "query"], "Invalid mode. Must be either 'support' or 'query'." # check if mode is valid
-    assert dataset and indices and classes is not None, "Dataset or indices cannot be None." # check if dataset is not None
-
-    self.dataset, self.indices, self.classes = dataset, indices, classes
-    self.mode, self.transform = mode, transform
-  # __init__():
-
-  def __getitem__(self, index: int):
-    """ Returns a sample from the dataset at the given index.
-        Args: index of the sample to be retrieved.
-        Returns: tuple of the transformed feature and the label. """
-    if index >= len(self.indices):
-      raise IndexError("Index out of bounds") # check if index is out of bounds
-    feature, label = self.dataset[self.indices[index]]
-    # apply transformation
-    feature = self.transform(feature)
-    if self.mode == "query": # if mode is query, convert label to one-hot vector
-      label = F.one_hot(torch.tensor(self.classes.index(label)), num_classes=len(self.classes)).float()
-    return feature, label
-  # __getitem__():
-
-  def __len__(self): return len(self.indices)
-# FSLDataset()
-
-class FewShotEpisoder:
-  """ A class to generate episodes for Few-Shot Learning.
-  Each episode consists of a support set and a query set. """
-  def __init__(self, dataset, classes: list, k_shot: int, n_query: int, transform: typing.Callable):
-    """ Args:
-        dataset (Dataset): The base dataset to generate episodes from.
-        k_shot (int): Number of support samples per class.
-        n_query (int): Number of query samples per class.
-        transform (callable): Transform to be applied to the features. """
-    assert k_shot > 0 and n_query > 0, "k_shot and n_query must be greater than 0."  # check if k_shot and n_query are valid
-
-    self.k_shot, self.n_query, self.classes = k_shot, n_query, classes
-    self.dataset, self.transform = dataset, transform
-    self.indices_c = self.get_class_indices()
-  # __init__()
-
-  def get_class_indices(self) -> dict:
-    """ Initialize the class indices for the dataset.
-        Returns: tuple of Number of classes and a list of indices grouped by class. """
-    indices_c = {label: [] for label in range(self.classes.__len__())}
-    for index, (_, label) in enumerate(self.dataset):
-      if label in self.classes: indices_c[self.classes.index(label)].append(index)
-    for label, _indices_c in indices_c.items():
-      indices_c[label] = random.sample(_indices_c, self.k_shot + self.n_query)
-    return indices_c
-  # get_indices():
-
-  def get_episode(self) -> tuple:  # select classes using list of chosen indexes
-    """ Generate an episode consisting of a support set and a query set.
-        Returns: tuple of A FewShotDataset for the support set and a FewShotDataset for the query set. """
-    # get support and query examples
-    support_examples, query_examples = [], []
-    for class_label in range(self.classes.__len__()):
-      if len(self.indices_c[class_label]) < self.k_shot + self.n_query: continue  # skip class if it doesn't have enough samples
-      selected_indices = random.sample(self.indices_c[class_label], self.k_shot + self.n_query)
-      support_examples.extend(selected_indices[:self.k_shot])
-      query_examples.extend(selected_indices)
-
-    # init support and query datasets
-    support_set = FewShotDataset(self.dataset, support_examples, self.classes, self.transform, "support")
-    query_set = FewShotDataset(self.dataset, query_examples, self.classes, self.transform, "query")
-
-    return support_set, query_set
-  # get_episode()
-# Episoder()

src/evaluate.py

@@ -1,48 +0,0 @@
-import random
-import torch
-from torch import nn
-from torch.utils.data import DataLoader
-import torchvision as tv
-from src.model.ProtoNet import ProtoNet
-from src.FewShotEpisoder import FewShotEpisoder
-
-def evaluate(MODEL: str, DATASET: str):
-  device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # select device
-
-  # load model
-  data = torch.load(MODEL)
-  n_way, k_shot, n_query = data["framework"]
-
-  # load model
-  model = ProtoNet(*data["model_config"].values()).to(device)
-  model.load_state_dict(data["state"])
-  model.eval()
-
-  # create FSL episode generator
-  imageset = tv.datasets.ImageFolder(root=DATASET)
-  unseen_classes = [_ for _ in random.sample(list(imageset.class_to_idx.values()), n_way)]
-  episoder = FewShotEpisoder(imageset, unseen_classes, k_shot, n_query, data["transform"])
-
-  # compute prototype from support examples
-  support_set, query_set = episoder.get_episode()
-  prototypes = list()
-  embedded_features_list = [[] for _ in range(len(support_set.classes))]
-  for embedded_feature, label in support_set: embedded_features_list[unseen_classes.index(label)].append(embedded_feature)
-  for embedded_features in embedded_features_list:
-    class_prototype = torch.stack(embedded_features).mean(dim=0)
-    prototypes.append(class_prototype.flatten())
-  prototypes = torch.stack(prototypes)
-  model.prototyping(prototypes)
-
-  # eval model
-  total_loss, count, n_problem = 0., 0, len(query_set)
-  criterion = nn.CrossEntropyLoss()
-  for feature, label in DataLoader(query_set, shuffle=True):
-    pred = model.forward(feature)
-    loss = criterion(pred, label)
-    total_loss += loss.item()
-    if torch.argmax(pred) == torch.argmax(label): count += 1
-  print(f"seen classes: {data['seen_classes']}\nunseen classes: {unseen_classes}\naccuracy: {count / n_problem:.4f}({count}/{n_problem})")
-# main()
-
-if __name__ == "__main__": evaluate("./model/model.pth", "../data/omniglot-py/images_background/Futurama")

src/train.py

@@ -1,73 +0,0 @@
-import random
-import torch.cuda
-import torchvision as tv
-from torch import nn
-from tqdm import tqdm
-from torch.utils.data import DataLoader
-from src.FewShotEpisoder import FewShotEpisoder
-from src.model.ProtoNet import ProtoNet
-from config import TRAINING_CONFIG, HYPERPARAMETER_CONFIG
-
-def train(DATASET:str, SAVE_TO:str, N_WAY:int, K_SHOT:int, N_QUERY:int, ITERS=TRAINING_CONFIG["iters"], EPOCHS=TRAINING_CONFIG["epochs"]):
-  device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # init device
-
-  # define transform
-  transform = tv.transforms.Compose([
-    tv.transforms.Resize((224, 224)),
-    tv.transforms.ToTensor(),
-    tv.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-  ]) # transform
-
-  # init episode generator
-  imageset = tv.datasets.ImageFolder(root=DATASET)
-  seen_classes = [_ for _ in random.sample(list(imageset.class_to_idx.values()), N_WAY)]
-  episoder = FewShotEpisoder(imageset, seen_classes, K_SHOT, N_QUERY, transform)
-
-  # init model
-  model_config = {"in_channels": 3, "hidden_channels": 26, "output_channels": 3}
-  model = ProtoNet(*model_config.values()).to(device)
-  optim = torch.optim.Adam(model.parameters(), lr=HYPERPARAMETER_CONFIG["lr"], weight_decay=HYPERPARAMETER_CONFIG["weight_decay"])
-  criterion = nn.CrossEntropyLoss()
-
-  progress_bar, whole_loss = tqdm(range(EPOCHS)), float()
-  support_set, query_set = episoder.get_episode()
-  for _ in progress_bar:
-    # STAGE1: compute prototype from support examples
-    prototypes = list()
-    embedded_features_list = [[] for _ in range(len(support_set.classes))]
-    for embedded_feature, label in support_set: embedded_features_list[seen_classes.index(label)].append(embedded_feature)
-    for embedded_features in embedded_features_list:
-      class_prototype = torch.stack(embedded_features).mean(dim=0)
-      prototypes.append(class_prototype.flatten())
-    # for
-    prototypes = torch.stack(prototypes)
-    model.prototyping(prototypes)
-    # STAGE2: update parameters form loss associated with prototypes
-    epochs_loss = 0.0
-    for _ in range(ITERS):
-      iter_loss = 0.0
-      for feature, label in DataLoader(query_set, shuffle=True):
-        loss = criterion(model.forward(feature), label)
-        iter_loss += loss.item()
-        optim.zero_grad()
-        loss.backward()
-        optim.step()
-      epochs_loss += iter_loss / len(query_set)
-    # for # for
-    epochs_loss = epochs_loss / ITERS
-    progress_bar.set_postfix(loss=epochs_loss)
-  # for
-
-  # saving the model's parameters and the other data
-  features = {
-    "state": model.state_dict(),
-    "model_config": model_config,
-    "transform": transform,
-    "seen_classes": seen_classes,
-    "framework": (N_WAY, K_SHOT, N_QUERY)
-  }  # features
-  torch.save(features, SAVE_TO)
-  print(f"model save to {SAVE_TO}")
-# main()
-
-if __name__ == "__main__": train("../data/omniglot-py/images_background/Futurama", "./model/model.pth", 5, 5, 2)