source_code/train_episodic.py

import random
from statistics import mean

import numpy as np
import torch
from torch import nn
from tqdm import tqdm
from torch.utils.data import DataLoader
from easyfsl.utils import evaluate

import argparse
import os
import time
from torch.optim import SGD, Optimizer
from torch.optim.lr_scheduler import MultiStepLR
from glob import glob

torch.autograd.set_detect_anomaly(True)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)
parser = argparse.ArgumentParser()
parser.add_argument('--run_num', help='Number for Identifying created folders', required=False, default=0)
parser.add_argument('--timestamps', help='Frequency for saving Weights and Validation', required=False, default=40)
parser.add_argument('--epochs', help='Number of epochs', required=False, default=200)
parser.add_argument('--net', help='Net to use', required=False, default="resnet")
parser.add_argument('--norm', help='0: No norm, 1: Subtract minimum to get positive values', required=False, default="1")
parser.add_argument('--fewshot', help='Fewshot method to use', required=False, default="prototypical")
parser.add_argument('--seed', help='Seed for the randomness', required=False, default="0")
parser.add_argument('--multi', help='If 1, use multiclass training else use binary', required=False, default="1")
parser.add_argument('--addlayer', help='layer(s) to add after resnet', required=False, default="None")
parser.add_argument('--triplets', help='Whether to use triplet loss 0: No, 1: Yes, 2: Quadruplet loss', required=False, default="0")
parser.add_argument('--margin', help='Margin to use for triplets', required=False, default="2.0")
parser.add_argument('--margin2', help='Margin 2 to use for quadruplets', required=False, default="10.0")

args = parser.parse_args()
run_num = int(args.run_num)
timestamps = int(args.timestamps)
epochs = int(args.epochs)
net_name = args.net
norm_type = int(args.norm)
random_seed = int(args.seed)
fewshot_method = args.fewshot
use_multi = int(args.multi)
additional_layer = args.addlayer
use_triplets = int(args.triplets)
margin = float(args.margin)
margin2 = float(args.margin2)

if fewshot_method in ["simpleshot", "relation", "bdcspn", "laplacianshot"] and use_triplets > 0:
    raise Exception("Invalid combination of few-shot method and loss function ! (Not implemented)")
if fewshot_method == "relation" and additional_layer != None:
    raise Exception("Invalid combination of few-shot method and additional layer ! (Not implemented)")
if fewshot_method == "matchingnetworks" and additional_layer in ["TSiT", "gMLP"]:
    raise Exception("Invalid combination of few-shot method and additional layer ! (Not implemented)")

base_path_data = "../../Spectrum_Highway1/"
base_path = "./"
train_file = base_path_data + "GNSS_dataset/train.txt"
if norm_type == 0:
    norm_data = None
elif norm_type == 1:
    norm_data = [-135.99690198, 0.]
time_size = 243
# ----------- #

# Create Folders
# The training weights and logs will be saved in the base_path + "results_episodic + x" depending on the traiing type (multi, triplet, quadruplet)
train_output_folder = "results_episodic"
if additional_layer != "None":
    train_output_folder += "_" + additional_layer
if not use_multi:
    train_output_folder += "_binary"
if use_triplets == 1:
    train_output_folder += "_triplet"
elif use_triplets == 2:
    train_output_folder += "_quadruplet"
print("Running: ", run_num, timestamps, epochs, time_size, net_name, fewshot_method, random_seed, additional_layer)
currentDate = time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime())
if not os.path.exists(base_path + train_output_folder):
    os.mkdir(base_path + train_output_folder)
res_path = base_path + train_output_folder + ("/%06d_" % run_num) + str(currentDate) + "_" + str(random_seed) + "_" + str(int(margin*10)) + "_" + str(int(margin2*10)) + "_" + fewshot_method + "_" + str(norm_type) + "_" + net_name
os.mkdir(res_path)
os.mkdir(res_path + "/weights/")
outputWeightspath = res_path + "/weights/"
log_loss = open(res_path + "/loss.txt", "w")
log = open(res_path + "/log.txt", "w")
# ------------ #

# Make deterministic #
np.random.seed(random_seed)
torch.manual_seed(random_seed)
random.seed(random_seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
# ------------------ #

# Create Train Test data lists
print("Train File: ", train_file)
with open(train_file, "r") as f:
    train_info = f.readlines()
train_info = [x.split("\n")[0].split("\t") for x in train_info]
import utilities
if use_multi:
    train_list_raw, valid_list_raw, train_y_raw, valid_y_raw, num_classes = utilities.get_training_data(train_info)
else:
    train_list_raw, valid_list_raw, train_y_raw, valid_y_raw, num_classes = utilities.get_training_data(train_info, reduce_to_binary=True)
train_list = []
valid_list = []
train_y = []
valid_y = []
print(np.unique(train_y_raw))
"""
Extract tar files and keep them in the subfolder 00-13
"""
for ti, tlr in enumerate(train_list_raw):
    # add_folder = ("data/%02d" % (int(tlr.split("/")[-1].split(".npy")[0]) // 15000)) + "/" + tlr.split("/")[-1]
    add_folder = ("data/" + tlr.split("/")[-1]
    for i in range(4):
        train_list.append([base_path_data + "GNSS_dataset/" + add_folder, i])
        train_y.append(train_y_raw[ti])
for vi, vlr in enumerate(valid_list_raw):
    # add_folder = ("data/%02d" % (int(vlr.split("/")[-1].split(".npy")[0]) // 15000)) + "/" + vlr.split("/")[-1]
    add_folder = ("data/" + vlr.split("/")[-1]
    for i in range(4):
        valid_list.append([base_path_data + "GNSS_dataset/" + add_folder, i])
        valid_y.append(valid_y_raw[vi])
# -------------------------- #

class tripletloss(nn.Module):
    def __init__(self, margin=1.):
        super().__init__()
        self.margin = margin
        self.eps = 10e-8

    def forward(self, embeddings, labels):
        # Embeddings are of shape (n_way * n_querry, n_way)
        # Labels are of shape (n_way * n_querry)
        pos_mask = torch.zeros_like(embeddings, dtype=bool).to(device)
        inds = (torch.arange(labels.size(-1)) * embeddings.size(-1)).to(device)
        inds = inds + labels
        pos_mask.flatten().scatter_(dim=0, index=inds, value=True).reshape_as(embeddings)
        anchor_positive_dists = embeddings[pos_mask].reshape((embeddings.size(0), 1))
        anchor_negative_dists = embeddings[~pos_mask].reshape((embeddings.size(0), -1))
        triplet_loss = torch.clamp(anchor_negative_dists - anchor_positive_dists + self.margin, min=0.0).reshape((embeddings.size(0), -1))
        num_positive_losses = (triplet_loss > self.eps).float().sum(1)
        triplet_loss = triplet_loss.sum(1) / (num_positive_losses + self.eps)
        return triplet_loss.sum()


class quadrupleloss3(nn.Module):
    def __init__(self, class_mask, margin1=1., margin2=2.):
        super().__init__()
        self.class_mask = class_mask.to(device)
        self.margin1 = margin1
        self.margin2 = margin2
        self.eps = 10e-8
        self.tensor_eye = (~(torch.eye(7).bool())).unsqueeze(1).to(device)

    def forward(self, embeddings, labels):
        # Embeddings are of shape (n_way * n_querry, n_way)
        # Labels are of shape (n_way * n_querry)
        mask_0 = (labels == 0).unsqueeze(1).repeat((1, embeddings.size(-1)))
        mask_1 = (labels == 1).unsqueeze(1).repeat((1, embeddings.size(-1)))
        mask_2 = (labels == 2).unsqueeze(1).repeat((1, embeddings.size(-1)))
        mask_3 = (labels == 3).unsqueeze(1).repeat((1, embeddings.size(-1)))
        mask_4 = (labels == 4).unsqueeze(1).repeat((1, embeddings.size(-1)))
        mask_5 = (labels == 5).unsqueeze(1).repeat((1, embeddings.size(-1)))
        mask_6 = (labels == 6).unsqueeze(1).repeat((1, embeddings.size(-1)))
        embeddings_0 = embeddings[mask_0].reshape((-1, embeddings.size(-1)))
        embeddings_1 = embeddings[mask_1].reshape((-1, embeddings.size(-1)))
        embeddings_2 = embeddings[mask_2].reshape((-1, embeddings.size(-1)))
        embeddings_3 = embeddings[mask_3].reshape((-1, embeddings.size(-1)))
        embeddings_4 = embeddings[mask_4].reshape((-1, embeddings.size(-1)))
        embeddings_5 = embeddings[mask_5].reshape((-1, embeddings.size(-1)))
        embeddings_6 = embeddings[mask_6].reshape((-1, embeddings.size(-1)))

        anchor_positive_dists_0 = embeddings_0[:, 0].reshape((embeddings_0.size(0), 1))
        anchor_positive_dists_1 = embeddings_1[:, 1].reshape((embeddings_1.size(0), 1))
        anchor_positive_dists_2 = embeddings_2[:, 2].reshape((embeddings_2.size(0), 1))
        anchor_positive_dists_3 = embeddings_3[:, 3].reshape((embeddings_3.size(0), 1))
        anchor_positive_dists_4 = embeddings_4[:, 4].reshape((embeddings_4.size(0), 1))
        anchor_positive_dists_5 = embeddings_5[:, 5].reshape((embeddings_5.size(0), 1))
        anchor_positive_dists_6 = embeddings_6[:, 6].reshape((embeddings_6.size(0), 1))

        anchor_similar_dists_0 = embeddings_0[self.class_mask[0].unsqueeze(0).repeat((embeddings_0.size(0), 1))].reshape((embeddings_0.size(0), -1))
        anchor_similar_dists_1 = embeddings_1[self.class_mask[1].unsqueeze(0).repeat((embeddings_1.size(0), 1))].reshape((embeddings_1.size(0), -1))
        anchor_similar_dists_2 = embeddings_2[self.class_mask[2].unsqueeze(0).repeat((embeddings_2.size(0), 1))].reshape((embeddings_2.size(0), -1))
        anchor_similar_dists_3 = embeddings_3[self.class_mask[3].unsqueeze(0).repeat((embeddings_3.size(0), 1))].reshape((embeddings_3.size(0), -1))
        anchor_similar_dists_4 = embeddings_4[self.class_mask[4].unsqueeze(0).repeat((embeddings_4.size(0), 1))].reshape((embeddings_4.size(0), -1))
        anchor_similar_dists_5 = embeddings_5[self.class_mask[5].unsqueeze(0).repeat((embeddings_5.size(0), 1))].reshape((embeddings_5.size(0), -1))
        anchor_similar_dists_6 = embeddings_6[self.class_mask[6].unsqueeze(0).repeat((embeddings_6.size(0), 1))].reshape((embeddings_6.size(0), -1))

        anchor_negative_dists_0 = embeddings_0[self.tensor_eye[0].repeat((embeddings_0.size(0), 1)) * ~self.class_mask[0][None, :]].reshape((embeddings_0.size(0), -1))
        anchor_negative_dists_1 = embeddings_1[self.tensor_eye[1].repeat((embeddings_1.size(0), 1)) * ~self.class_mask[1][None, :]].reshape((embeddings_1.size(0), -1))
        anchor_negative_dists_2 = embeddings_2[self.tensor_eye[2].repeat((embeddings_2.size(0), 1)) * ~self.class_mask[2][None, :]].reshape((embeddings_2.size(0), -1))
        anchor_negative_dists_3 = embeddings_3[self.tensor_eye[3].repeat((embeddings_3.size(0), 1)) * ~self.class_mask[3][None, :]].reshape((embeddings_3.size(0), -1))
        anchor_negative_dists_4 = embeddings_4[self.tensor_eye[4].repeat((embeddings_4.size(0), 1)) * ~self.class_mask[4][None, :]].reshape((embeddings_4.size(0), -1))
        anchor_negative_dists_5 = embeddings_5[self.tensor_eye[5].repeat((embeddings_5.size(0), 1)) * ~self.class_mask[5][None, :]].reshape((embeddings_5.size(0), -1))
        anchor_negative_dists_6 = embeddings_6[self.tensor_eye[6].repeat((embeddings_6.size(0), 1)) * ~self.class_mask[6][None, :]].reshape((embeddings_6.size(0), -1))

        pos_sim_loss_0 = torch.clamp(anchor_similar_dists_0 - anchor_positive_dists_0 + self.margin1, min=0.0).reshape((embeddings_0.size(0), -1))
        pos_sim_loss_1 = torch.clamp(anchor_similar_dists_1 - anchor_positive_dists_1 + self.margin1, min=0.0).reshape((embeddings_1.size(0), -1))
        pos_sim_loss_2 = torch.clamp(anchor_similar_dists_2 - anchor_positive_dists_2 + self.margin1, min=0.0).reshape((embeddings_2.size(0), -1))
        pos_sim_loss_3 = torch.clamp(anchor_similar_dists_3 - anchor_positive_dists_3 + self.margin1, min=0.0).reshape((embeddings_3.size(0), -1))
        pos_sim_loss_4 = torch.clamp(anchor_similar_dists_4 - anchor_positive_dists_4 + self.margin1, min=0.0).reshape((embeddings_4.size(0), -1))
        pos_sim_loss_5 = torch.clamp(anchor_similar_dists_5 - anchor_positive_dists_5 + self.margin1, min=0.0).reshape((embeddings_5.size(0), -1))
        pos_sim_loss_6 = torch.clamp(anchor_similar_dists_6 - anchor_positive_dists_6 + self.margin1, min=0.0).reshape((embeddings_6.size(0), -1))
        sim_neg_loss_0 = torch.clamp(anchor_negative_dists_0[:, None, :] - anchor_similar_dists_0[:, :, None] + self.margin2, min=0.0).reshape((embeddings_0.size(0), anchor_similar_dists_0.size(-1), -1))
        sim_neg_loss_1 = torch.clamp(anchor_negative_dists_1[:, None, :] - anchor_similar_dists_1[:, :, None] + self.margin2, min=0.0).reshape((embeddings_1.size(0), anchor_similar_dists_1.size(-1), -1))
        sim_neg_loss_2 = torch.clamp(anchor_negative_dists_2[:, None, :] - anchor_similar_dists_2[:, :, None] + self.margin2, min=0.0).reshape((embeddings_2.size(0), anchor_similar_dists_2.size(-1), -1))
        sim_neg_loss_3 = torch.clamp(anchor_negative_dists_3[:, None, :] - anchor_similar_dists_3[:, :, None] + self.margin2, min=0.0).reshape((embeddings_3.size(0), anchor_similar_dists_3.size(-1), -1))
        sim_neg_loss_4 = torch.clamp(anchor_negative_dists_4[:, None, :] - anchor_similar_dists_4[:, :, None] + self.margin2, min=0.0).reshape((embeddings_4.size(0), anchor_similar_dists_4.size(-1), -1))
        sim_neg_loss_5 = torch.clamp(anchor_negative_dists_5[:, None, :] - anchor_similar_dists_5[:, :, None] + self.margin2, min=0.0).reshape((embeddings_5.size(0), anchor_similar_dists_5.size(-1), -1))
        sim_neg_loss_6 = torch.clamp(anchor_negative_dists_6[:, None, :] - anchor_similar_dists_6[:, :, None] + self.margin2, min=0.0).reshape((embeddings_6.size(0), anchor_similar_dists_6.size(-1), -1))

        quadruple_loss_0 = pos_sim_loss_0[:, :, None] + sim_neg_loss_0
        quadruple_loss_1 = pos_sim_loss_1[:, :, None] + sim_neg_loss_1
        quadruple_loss_2 = pos_sim_loss_2[:, :, None] + sim_neg_loss_2
        quadruple_loss_3 = pos_sim_loss_3[:, :, None] + sim_neg_loss_3
        quadruple_loss_4 = pos_sim_loss_4[:, :, None] + sim_neg_loss_4
        quadruple_loss_5 = pos_sim_loss_5[:, :, None] + sim_neg_loss_5
        quadruple_loss_6 = pos_sim_loss_6[:, :, None] + sim_neg_loss_6

        num_positive_0 = (quadruple_loss_0 > self.eps).float().sum(1).sum(1)
        num_positive_1 = (quadruple_loss_1 > self.eps).float().sum(1).sum(1)
        num_positive_2 = (quadruple_loss_2 > self.eps).float().sum(1).sum(1)
        num_positive_3 = (quadruple_loss_3 > self.eps).float().sum(1).sum(1)
        num_positive_4 = (quadruple_loss_4 > self.eps).float().sum(1).sum(1)
        num_positive_5 = (quadruple_loss_5 > self.eps).float().sum(1).sum(1)
        num_positive_6 = (quadruple_loss_6 > self.eps).float().sum(1).sum(1)

        quadruple_0 = quadruple_loss_0.sum(1).sum(1) / (num_positive_0 + self.eps)
        quadruple_1 = quadruple_loss_1.sum(1).sum(1) / (num_positive_1 + self.eps)
        quadruple_2 = quadruple_loss_2.sum(1).sum(1) / (num_positive_2 + self.eps)
        quadruple_3 = quadruple_loss_3.sum(1).sum(1) / (num_positive_3 + self.eps)
        quadruple_4 = quadruple_loss_4.sum(1).sum(1) / (num_positive_4 + self.eps)
        quadruple_5 = quadruple_loss_5.sum(1).sum(1) / (num_positive_5 + self.eps)
        quadruple_6 = quadruple_loss_6.sum(1).sum(1) / (num_positive_6 + self.eps)
        return quadruple_0.sum() + quadruple_1.sum() + quadruple_2.sum() + quadruple_3.sum() + quadruple_4.sum() + quadruple_5.sum() + quadruple_6.sum()

class extract_tensor(nn.Module):
    # For extracting the tensor from an lstm output
    def forward(self,x):
        # Output shape (batch, features, hidden)
        tensor, _ = x
        return tensor

class TransposeB(torch.nn.Module):
    def forward(self, x):
        x = torch.transpose(x, 1, 0)
        return x

class TransposeT(torch.nn.Module):
    def forward(self, x):
        x = torch.transpose(x, 2, 1)
        return x

class multihead_Attention(nn.Module):
    def __init__(self, embeded_dim, num_heads):
        super().__init__()
        self.attention = nn.MultiheadAttention(embeded_dim, num_heads, batch_first=True)

    def forward(self,x):
        x, _ = self.attention(x, x, x)
        return x

# Create Model
if net_name == "resnet" and fewshot_method != "FEAT":
    from torchvision.models import resnet18
    model = resnet18(weights='IMAGENET1K_V1')
    if additional_layer == "dense":
        model.fc = nn.Linear(512, 512)
    elif additional_layer == "lstm":
        model.avgpool = nn.AdaptiveAvgPool2d((8, 1))
        model.use_flatten = False
        model.fc = nn.Sequential(nn.Flatten(start_dim=-2),
                                 nn.LSTM(8, 8, batch_first=True),
                                 extract_tensor(),
                                 nn.AdaptiveAvgPool1d(1),
                                 nn.Flatten())
    elif additional_layer == "multiheadattention":
        model.avgpool = nn.AdaptiveAvgPool2d((8, 1))
        model.use_flatten = False
        model.fc = nn.Sequential(nn.Flatten(start_dim=-2),
                                 multihead_Attention(8, 8),
                                 nn.AdaptiveAvgPool1d(1),
                                 nn.Flatten())
    elif additional_layer == "conv":
        model.avgpool = nn.AdaptiveAvgPool2d((16, 1))  # Shape: (BS, 512, 16, 1)
        model.use_flatten = False
        model.fc = nn.Sequential(nn.Flatten(start_dim=-2),
                                 nn.Conv1d(512, 512, 4),
                                 nn.AdaptiveAvgPool1d(1),
                                 nn.Flatten())
    elif additional_layer == "TSiT":
        from tsai.models.TSiTPlus import TSiTPlus
        model.avgpool = nn.AdaptiveAvgPool2d((16, 1))  # -> (BS, 512, 16, 1)
        model.use_flatten = False
        model.fc = nn.Sequential(nn.Flatten(start_dim=-2),  # -> (BS, 512, 16)
                                 TransposeT(),  # -> (BS, 16, 512)
                                 TSiTPlus(16, 16, seq_len=512, d_model=32, depth=3))  # -> (BS, 16)
    elif additional_layer == "gMLP":
        from tsai.models.gMLP import gMLP
        model.avgpool = nn.AdaptiveAvgPool2d((16, 1))  # -> (BS, 512, 16, 1)
        model.use_flatten = False
        model.fc = nn.Sequential(nn.Flatten(start_dim=-2),  # -> (BS, 512, 16)
                                 TransposeT(),  # -> (BS, 16, 512)
                                 gMLP(16, 16, seq_len=512, d_model=32, depth=3))  # -> (BS, 16)
    elif additional_layer == "autoencoder":
        model.fc = nn.Sequential(nn.Linear(512, 128),
                                 nn.ReLU(),
                                 nn.Linear(128, 32),
                                 nn.ReLU(),
                                 nn.Linear(32, 8),
                                 nn.Linear(8, 32),
                                 nn.ReLU(),
                                 nn.Linear(32, 128),
                                 nn.ReLU(),
                                 nn.Linear(128, 512))
    else:
        model.use_fc = False
    if fewshot_method == "relation":
        model.use_flatten = False
    model.train()
    model = model.to(device)
# ---------- #

# For validation -------------------------------------------------------------------- #
from easyfsl.samplers import TaskSampler

n_way = num_classes
n_shot = 2
if use_multi:
    n_query = 5
else:
    n_query = 20
n_validation_tasks = 250

val_set = utilities.val_set(valid_list, valid_y, time_size, norm=norm_data, norm_type=norm_type)
val_sampler = TaskSampler(
    val_set, n_way=n_way, n_shot=n_shot, n_query=n_query, n_tasks=n_validation_tasks
)
val_loader = DataLoader(
    val_set,
    batch_sampler=val_sampler,
    num_workers=1,
    pin_memory=True,
    collate_fn=val_sampler.episodic_collate_fn,
)
# ----------------------------------------------------------------------------------- #

# Create FewShotClassifier on top of the model -------------------------------------- #
from easyfsl.methods import FewShotClassifier
if fewshot_method == "prototypical":
    from easyfsl.methods import PrototypicalNetworks
    few_shot_classifier = PrototypicalNetworks(model).to(device)
elif fewshot_method == "simpleshot":
    from easyfsl.methods import SimpleShot
    few_shot_classifier = SimpleShot(model).to(device)
elif fewshot_method == "relation":
    from easyfsl.methods import RelationNetworks
    few_shot_classifier = RelationNetworks(backbone=model, feature_dimension=512).to(device)
elif fewshot_method == "bdcspn":
    from easyfsl.methods import BDCSPN
    few_shot_classifier = BDCSPN(model).to(device)
elif fewshot_method == "FEAT":
    from easyfsl.methods import FEAT
    wp = "./feat-1-shot.pth"  # Pre trainewd weights for FEAT
    few_shot_classifier = FEAT.from_resnet12_checkpoint(checkpoint_path=wp).to(device)
elif fewshot_method == "laplacianshot":
    from easyfsl.methods import LaplacianShot
    few_shot_classifier = LaplacianShot(model).to(device)
elif fewshot_method == "matchingnetworks":
    from easyfsl.methods import MatchingNetworks
    few_shot_classifier = MatchingNetworks(model, feature_dimension=512).to(device)
else:
    print("Invalid fewshot method: ", fewshot_method)
    exit()
# ----------------------------------------------------------------------------------- #

# For training -------------------------------------------------------------------- #
n_shot_tr = 2
if use_multi:
    n_query_tr = 2
else:
    n_query_tr = 30
n_tasks_per_epoch = 250
train_set = utilities.val_set(train_list, train_y, time_size, norm=norm_data, norm_type=norm_type)
train_sampler = TaskSampler(
    train_set, n_way=n_way, n_shot=n_shot_tr, n_query=n_query_tr, n_tasks=n_tasks_per_epoch
)
train_loader = DataLoader(
    train_set,
    batch_sampler=train_sampler,
    num_workers=1,
    pin_memory=True,
    collate_fn=train_sampler.episodic_collate_fn,
)
# --------------------------------------------------------------------------------- #

train_optimizer = SGD(few_shot_classifier.parameters(), lr=1e-2, momentum=0.9, weight_decay=5e-4)
train_scheduler = MultiStepLR(train_optimizer, milestones=[120, 160], gamma=0.1)
if use_triplets == 1:
    criterion = tripletloss(margin=margin).to(device)
elif use_triplets == 2:
    # mask for similar/negative classes for each class
    classes_mask = torch.tensor([[0, 1, 0, 0, 0, 1, 1], [1, 0, 1, 1, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 1, 0]]).bool()
    criterion = quadrupleloss3(class_mask=classes_mask, margin1=margin, margin2=margin2).to(device)
else:
    if fewshot_method == "matchingnetworks":
        criterion = torch.nn.NLLLoss().to(device)
    elif fewshot_method == "simpleshot" or fewshot_method == "bdcspn" or fewshot_method == "laplacianshot":
        criterion = torch.nn.BCELoss().to(device)
    elif fewshot_method == "relation":
        criterion = torch.nn.MSELoss().to(device)
    else:
        criterion = torch.nn.CrossEntropyLoss().to(device)

def training_epoch(
    model: FewShotClassifier, data_loader: DataLoader, optimizer: Optimizer, method : str = "prototypical"
):
    all_loss = []
    model.train()
    with tqdm(
        enumerate(data_loader), total=len(data_loader), desc="Training"
    ) as tqdm_train:
        for episode_index, (
            support_images,
            support_labels,
            query_images,
            query_labels,
            _,
        ) in tqdm_train:
            optimizer.zero_grad()
            model.process_support_set(
                support_images.to(device), support_labels.to(device)
            )
            classification_scores = model(query_images.to(device))
            # Added to deal with different losses for different fewshot methods ------------------------------------- #
            if method == "simpleshot" or method == "bdcspn":
                classification_scores = (torch.clamp(classification_scores, min=-0.1) + 0.1) / 1.1
            if method == "simpleshot" or method == "bdcspn" or method == "relation" or method == "laplacianshot":
                query_labels = torch.nn.functional.one_hot(query_labels, num_classes=num_classes).float()
            # ------------------------------------------------------------------------------------------------------- #
            loss = criterion(classification_scores, query_labels.to(device))
            loss.backward()
            optimizer.step()

            all_loss.append(loss.item())

            tqdm_train.set_postfix(loss=mean(all_loss))

    return mean(all_loss)


for e in range(epochs):
    print("Epoch: %d/%d" % (e, epochs))
    average_loss = training_epoch(few_shot_classifier, train_loader, train_optimizer, fewshot_method)
    log_loss.write("%f\n" % average_loss)
    log_loss.flush()
    if (e + 1) % int(timestamps) == 0:
        few_shot_classifier.eval()
        validation_accuracy = evaluate(
            few_shot_classifier, val_loader, device=device, tqdm_prefix="Validation"
        )
        print('Valid Acc: %.5f' % validation_accuracy)
        log.write("Valid Acc: %.5f\n" % validation_accuracy)
        log.flush()
        if fewshot_method != "FEAT":
            torch.save(model.state_dict(), outputWeightspath + str(e) + '.h5')
        if fewshot_method == "relation" or fewshot_method == "bdcspn" or fewshot_method == "FEAT" or fewshot_method == "laplacianshot" or fewshot_method == "matchingnetworks":
            torch.save(few_shot_classifier.state_dict(), outputWeightspath + str(e) + '_fs.h5')
        few_shot_classifier.train()
log.close()
log_loss.close()
print("Done")