Upload folder using huggingface_hub

convs/augmentation.py

@@ -0,0 +1,104 @@
+from PIL import Image
+import os
+import numpy as np
+import torch
+from torchvision.utils import save_image
+import torchvision.transforms as tvts
+import random
+from os import listdir
+from os.path import isfile, join
+import shutil
+
+# Define a list of augmentation transformations to be applied to images
+transforms = [
+    tvts.ColorJitter(brightness=.5, hue=.3),         # Adjust brightness and hue
+    tvts.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5.)),  # Apply Gaussian blur with random parameters
+    tvts.RandomAdjustSharpness(sharpness_factor=2),  # Adjust image sharpness
+    tvts.RandomRotation(degrees=(0, 180)),           # Rotate images randomly between 0 and 180 degrees
+    tvts.RandomHorizontalFlip(p=0.5),                # Randomly flip images horizontally
+    tvts.RandomVerticalFlip(p=0.5)                   # Randomly flip images vertically
+]
+
+# Select a specified number of random images from a list
+def select_random_imgs(img_list, count):
+    return random.sample(img_list, count)
+
+# Create a new folder name by adding "augment" to the original name
+def create_foldername(fname):
+    names = fname.split("_")
+    names.insert(2, "augment")
+    return "_".join(names)
+
+# Save original images to a new destination folder without applying transformations
+def save_original_imgs(source_fname, dest_fname, img_files):
+    for img in img_files:
+        img_name = img.split(".")[0]
+        img = open_PILimg(path=os.path.join(source_fname, img))
+        save_image(tvts.ToTensor()(img), os.path.join(dest_fname, "{}.jpg".format(img_name)))
+
+# Select a specified number of random files and copy them to the destination folder
+def select_random_files(count, source_fname, dest_fname):
+    files = os.listdir(source_fname)
+    files = select_random_imgs(files, count=count)
+
+    # Iterate through the files and copy them to the destination folder
+    for file in files:
+        source_path = os.path.join(source_fname, file)
+        destination_path = os.path.join(dest_fname, file)
+        shutil.copy(source_path, destination_path)
+        print(f"Copied {file} to {dest_fname}")
+
+# Open an image file using PIL and convert it to RGB format
+def open_PILimg(path):
+    return Image.open(path).convert("RGB")
+
+# Save a PIL image to the specified path
+def save_PILimg(path, img):
+    save_image(tvts.ToTensor()(img), "{}.jpg".format(path))
+
+# Function to augment images in a specific folder
+def augment_folder(root_fname, fname, augment_count=25):
+    # Get the list of all images in the folder
+    onlyfiles = os.listdir(os.path.join(root_fname, fname))
+    print("Before augmentation, number of images in {} is {}".format(root_fname, len(onlyfiles)))
+
+    # Randomly select images to be augmented
+    random_imgs = select_random_imgs(onlyfiles, len(onlyfiles))
+    augment_fname = create_foldername(root_fname)
+
+    # Create folder for augmented images if it does not exist
+    if not os.path.exists(augment_fname):
+        os.mkdir(augment_fname)
+
+    # Create a sub-folder for the specific set of images
+    save_fname = os.path.join(augment_fname, fname)
+    if not os.path.exists(save_fname):
+        os.mkdir(save_fname)
+
+    # Save the original images in the new folder
+    save_original_imgs(source_fname=os.path.join(root_fname, fname),
+                       dest_fname=os.path.join(augment_fname, fname),
+                       img_files=onlyfiles)
+
+    # Apply transformations and save augmented images
+    for img in random_imgs:
+        img_name = img.split(".")[0]
+        img = open_PILimg(path=os.path.join(root_fname, fname, img))
+        
+        for transform in transforms:
+            transname = transform.__class__.__name__
+            transformed_imgs = [transform(img) for _ in range(augment_count)]
+            for i, trans_img in enumerate(transformed_imgs):
+                save_image(tvts.ToTensor()(trans_img), os.path.join(save_fname, "trans_img_{}_{}_{}.jpg".format(img_name, transname, i)))
+                
+    print("After augmentation, number of images in {} is {}".format(save_fname, len(os.listdir(save_fname))))
+
+# Main block to iterate over root folders ("Train" and "Test") and apply augmentations
+if __name__ == "__main__":
+    root_folder = [["Train"], ["Test"]]
+    for root in root_folder:
+        # List all subfolders within the root directory
+        folders = [f for f in os.listdir(root) if os.path.isdir(os.path.join(root, f))]
+        # Apply augmentation to each subfolder
+        for folder in folders:
+            augment_folder(root, folder)

convs/cifar_resnet.py

@@ -0,0 +1,207 @@
+'''
+Reference:
+https://github.com/khurramjaved96/incremental-learning/blob/autoencoders/model/resnet32.py
+'''
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class DownsampleA(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleA, self).__init__()
+        assert stride == 2
+        self.avg = nn.AvgPool2d(kernel_size=1, stride=stride)
+
+    def forward(self, x):
+        x = self.avg(x)
+        return torch.cat((x, x.mul(0)), 1)
+
+
+class DownsampleB(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleB, self).__init__()
+        self.conv = nn.Conv2d(nIn, nOut, kernel_size=1, stride=stride, padding=0, bias=False)
+        self.bn = nn.BatchNorm2d(nOut)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return x
+
+
+class DownsampleC(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleC, self).__init__()
+        assert stride != 1 or nIn != nOut
+        self.conv = nn.Conv2d(nIn, nOut, kernel_size=1, stride=stride, padding=0, bias=False)
+
+    def forward(self, x):
+        x = self.conv(x)
+        return x
+
+
+class DownsampleD(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleD, self).__init__()
+        assert stride == 2
+        self.conv = nn.Conv2d(nIn, nOut, kernel_size=2, stride=stride, padding=0, bias=False)
+        self.bn = nn.BatchNorm2d(nOut)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return x
+
+
+class ResNetBasicblock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(ResNetBasicblock, self).__init__()
+
+        self.conv_a = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn_a = nn.BatchNorm2d(planes)
+
+        self.conv_b = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn_b = nn.BatchNorm2d(planes)
+
+        self.downsample = downsample
+
+    def forward(self, x):
+        residual = x
+
+        basicblock = self.conv_a(x)
+        basicblock = self.bn_a(basicblock)
+        basicblock = F.relu(basicblock, inplace=True)
+
+        basicblock = self.conv_b(basicblock)
+        basicblock = self.bn_b(basicblock)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        return F.relu(residual + basicblock, inplace=True)
+
+
+class CifarResNet(nn.Module):
+    """
+    ResNet optimized for the Cifar Dataset, as specified in
+    https://arxiv.org/abs/1512.03385.pdf
+    """
+
+    def __init__(self, block, depth, channels=3):
+        super(CifarResNet, self).__init__()
+
+        # Model type specifies number of layers for CIFAR-10 and CIFAR-100 model
+        assert (depth - 2) % 6 == 0, 'depth should be one of 20, 32, 44, 56, 110'
+        layer_blocks = (depth - 2) // 6
+
+        self.conv_1_3x3 = nn.Conv2d(channels, 16, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn_1 = nn.BatchNorm2d(16)
+
+        self.inplanes = 16
+        self.stage_1 = self._make_layer(block, 16, layer_blocks, 1)
+        self.stage_2 = self._make_layer(block, 32, layer_blocks, 2)
+        self.stage_3 = self._make_layer(block, 64, layer_blocks, 2)
+        self.avgpool = nn.AvgPool2d(8)
+        self.out_dim = 64 * block.expansion
+        #self.fc = nn.Linear(64*block.expansion, 10)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                # m.bias.data.zero_()
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+            elif isinstance(m, nn.Linear):
+                nn.init.kaiming_normal_(m.weight)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = DownsampleA(self.inplanes, planes * block.expansion, stride)
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv_1_3x3(x)  # [bs, 16, 32, 32]
+        x = F.relu(self.bn_1(x), inplace=True)
+
+        x_1 = self.stage_1(x)  # [bs, 16, 32, 32]
+        x_2 = self.stage_2(x_1)  # [bs, 32, 16, 16]
+        x_3 = self.stage_3(x_2)  # [bs, 64, 8, 8]
+
+        pooled = self.avgpool(x_3)  # [bs, 64, 1, 1]
+        features = pooled.view(pooled.size(0), -1)  # [bs, 64]
+
+        return {
+            'fmaps': [x_1, x_2, x_3],
+            'features': features
+        }
+
+    @property
+    def last_conv(self):
+        return self.stage_3[-1].conv_b
+
+
+def resnet20mnist():
+    """Constructs a ResNet-20 model for MNIST."""
+    model = CifarResNet(ResNetBasicblock, 20, 1)
+    return model
+
+
+def resnet32mnist():
+    """Constructs a ResNet-32 model for MNIST."""
+    model = CifarResNet(ResNetBasicblock, 32, 1)
+    return model
+
+
+def resnet20():
+    """Constructs a ResNet-20 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 20)
+    return model
+
+
+def resnet32():
+    """Constructs a ResNet-32 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 32)
+    return model
+
+
+def resnet44():
+    """Constructs a ResNet-44 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 44)
+    return model
+
+
+def resnet56():
+    """Constructs a ResNet-56 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 56)
+    return model
+
+
+def resnet110():
+    """Constructs a ResNet-110 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 110)
+    return model
+
+# for auc
+def resnet14():
+    model = CifarResNet(ResNetBasicblock, 14)
+    return model
+
+def resnet26():
+    model = CifarResNet(ResNetBasicblock, 26)
+    return model

convs/conv_cifar.py

@@ -0,0 +1,77 @@
+'''
+For MEMO implementations of CIFAR-ConvNet
+Reference:
+https://github.com/wangkiw/ICLR23-MEMO/blob/main/convs/conv_cifar.py
+'''
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# for cifar
+def conv_block(in_channels, out_channels):
+    return nn.Sequential(
+        nn.Conv2d(in_channels, out_channels, 3, padding=1),
+        nn.BatchNorm2d(out_channels),
+        nn.ReLU(),
+        nn.MaxPool2d(2)
+    )
+
+class ConvNet2(nn.Module):
+    def __init__(self, x_dim=3, hid_dim=64, z_dim=64):
+        super().__init__()
+        self.out_dim = 64
+        self.avgpool = nn.AvgPool2d(8)
+        self.encoder = nn.Sequential(
+            conv_block(x_dim, hid_dim),
+            conv_block(hid_dim, z_dim),
+        )
+
+    def forward(self, x):
+        x = self.encoder(x)
+        x = self.avgpool(x)
+        features = x.view(x.shape[0], -1)
+        return {
+            "features":features
+        }
+        
+class GeneralizedConvNet2(nn.Module):
+    def __init__(self, x_dim=3, hid_dim=64, z_dim=64):
+        super().__init__()
+        self.encoder = nn.Sequential(
+            conv_block(x_dim, hid_dim),
+        )
+
+    def forward(self, x):
+        base_features = self.encoder(x)
+        return base_features
+    
+class SpecializedConvNet2(nn.Module):
+    def __init__(self,hid_dim=64,z_dim=64):
+        super().__init__()
+        self.feature_dim = 64
+        self.avgpool = nn.AvgPool2d(8)
+        self.AdaptiveBlock = conv_block(hid_dim,z_dim)
+    
+    def forward(self,x):
+        base_features = self.AdaptiveBlock(x)
+        pooled = self.avgpool(base_features)
+        features = pooled.view(pooled.size(0),-1)
+        return features
+
+def conv2():
+    return ConvNet2()
+
+def get_conv_a2fc():
+    basenet = GeneralizedConvNet2()
+    adaptivenet = SpecializedConvNet2()
+    return basenet,adaptivenet
+
+if __name__ == '__main__':
+    a, b = get_conv_a2fc()
+    _base = sum(p.numel() for p in a.parameters())
+    _adap = sum(p.numel() for p in b.parameters())
+    print(f"conv :{_base+_adap}")
+    
+    conv2 = conv2()
+    conv2_sum = sum(p.numel() for p in conv2.parameters())
+    print(f"conv2 :{conv2_sum}")

convs/conv_imagenet.py

@@ -0,0 +1,82 @@
+'''
+For MEMO implementations of ImageNet-ConvNet
+Reference:
+https://github.com/wangkiw/ICLR23-MEMO/blob/main/convs/conv_imagenet.py
+'''
+import torch.nn as nn
+import torch
+
+# for imagenet
+def first_block(in_channels, out_channels):
+    return nn.Sequential(
+        nn.Conv2d(in_channels, out_channels, kernel_size=7, stride=2, padding=3),
+        nn.BatchNorm2d(out_channels),
+        nn.ReLU(),
+        nn.MaxPool2d(2)
+    )
+    
+def conv_block(in_channels, out_channels):
+    return nn.Sequential(
+        nn.Conv2d(in_channels, out_channels, 3, padding=1),
+        nn.BatchNorm2d(out_channels),
+        nn.ReLU(),
+        nn.MaxPool2d(2)
+    )
+
+class ConvNet(nn.Module):
+    def __init__(self, x_dim=3, hid_dim=128, z_dim=512):
+        super().__init__()
+        self.block1 = first_block(x_dim, hid_dim)
+        self.block2 = conv_block(hid_dim, hid_dim)
+        self.block3 = conv_block(hid_dim, hid_dim)
+        self.block4 = conv_block(hid_dim, z_dim)
+        self.avgpool = nn.AvgPool2d(7)
+        self.out_dim = 512
+
+    def forward(self, x):
+        x = self.block1(x)
+        x = self.block2(x)
+        x = self.block3(x)
+        x = self.block4(x)
+
+        x = self.avgpool(x)
+        features = x.view(x.shape[0], -1)
+        
+        return {
+            "features": features
+        }
+
+class GeneralizedConvNet(nn.Module):
+    def __init__(self, x_dim=3, hid_dim=128, z_dim=512):
+        super().__init__()
+        self.block1 = first_block(x_dim, hid_dim)
+        self.block2 = conv_block(hid_dim, hid_dim)
+        self.block3 = conv_block(hid_dim, hid_dim)
+
+    def forward(self, x):
+        x = self.block1(x)
+        x = self.block2(x)
+        x = self.block3(x)
+        return x
+
+class SpecializedConvNet(nn.Module):
+    def __init__(self, hid_dim=128,z_dim=512):
+        super().__init__()
+        self.block4 = conv_block(hid_dim, z_dim)
+        self.avgpool = nn.AvgPool2d(7)
+        self.feature_dim = 512
+        
+    def forward(self, x):
+        x = self.block4(x)
+        x = self.avgpool(x)
+        features = x.view(x.shape[0], -1)
+        return features
+    
+def conv4():
+    model = ConvNet()
+    return model
+
+def conv_a2fc_imagenet():
+    _base = GeneralizedConvNet()
+    _adaptive_net = SpecializedConvNet()
+    return _base, _adaptive_net

convs/linears.py

@@ -0,0 +1,168 @@
+'''
+Reference:
+https://github.com/hshustc/CVPR19_Incremental_Learning/blob/master/cifar100-class-incremental/modified_linear.py
+'''
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+class SimpleLinear(nn.Module):
+    '''
+    Reference:
+    https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/linear.py
+    '''
+    def __init__(self, in_features, out_features, bias=True):
+        super(SimpleLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = nn.Parameter(torch.Tensor(out_features, in_features))
+        if bias:
+            self.bias = nn.Parameter(torch.Tensor(out_features))
+        else:
+            self.register_parameter('bias', None)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.kaiming_uniform_(self.weight, nonlinearity='linear')
+        nn.init.constant_(self.bias, 0)
+
+    def forward(self, input):
+        #print('input shape is -------->',input.shape)
+        return {'logits': F.linear(input, self.weight, self.bias)}
+
+
+class CosineLinear(nn.Module):
+    def __init__(self, in_features, out_features, nb_proxy=1, to_reduce=False, sigma=True):
+        super(CosineLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features * nb_proxy
+        self.nb_proxy = nb_proxy
+        self.to_reduce = to_reduce
+        self.weight = nn.Parameter(torch.Tensor(self.out_features, in_features))
+        if sigma:
+            self.sigma = nn.Parameter(torch.Tensor(1))
+        else:
+            self.register_parameter('sigma', None)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        stdv = 1. / math.sqrt(self.weight.size(1))
+        self.weight.data.uniform_(-stdv, stdv)
+        if self.sigma is not None:
+            self.sigma.data.fill_(1)
+
+    def forward(self, input):
+        out = F.linear(F.normalize(input, p=2, dim=1), F.normalize(self.weight, p=2, dim=1))
+
+        if self.to_reduce:
+            # Reduce_proxy
+            out = reduce_proxies(out, self.nb_proxy)
+
+        if self.sigma is not None:
+            out = self.sigma * out
+
+        return {'logits': out}
+
+
+class SplitCosineLinear(nn.Module):
+    def __init__(self, in_features, out_features1, out_features2, nb_proxy=1, sigma=True):
+        super(SplitCosineLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = (out_features1 + out_features2) * nb_proxy
+        self.nb_proxy = nb_proxy
+        self.fc1 = CosineLinear(in_features, out_features1, nb_proxy, False, False)
+        self.fc2 = CosineLinear(in_features, out_features2, nb_proxy, False, False)
+        if sigma:
+            self.sigma = nn.Parameter(torch.Tensor(1))
+            self.sigma.data.fill_(1)
+        else:
+            self.register_parameter('sigma', None)
+
+    def forward(self, x):
+        out1 = self.fc1(x)
+        out2 = self.fc2(x)
+
+        out = torch.cat((out1['logits'], out2['logits']), dim=1)  # concatenate along the channel
+
+        # Reduce_proxy
+        out = reduce_proxies(out, self.nb_proxy)
+
+        if self.sigma is not None:
+            out = self.sigma * out
+
+        return {
+            'old_scores': reduce_proxies(out1['logits'], self.nb_proxy),
+            'new_scores': reduce_proxies(out2['logits'], self.nb_proxy),
+            'logits': out
+        }
+
+
+def reduce_proxies(out, nb_proxy):
+    if nb_proxy == 1:
+        return out
+    bs = out.shape[0]
+    nb_classes = out.shape[1] / nb_proxy
+    assert nb_classes.is_integer(), 'Shape error'
+    nb_classes = int(nb_classes)
+
+    simi_per_class = out.view(bs, nb_classes, nb_proxy)
+    attentions = F.softmax(simi_per_class, dim=-1)
+
+    return (attentions * simi_per_class).sum(-1)
+
+
+'''
+class CosineLinear(nn.Module):
+    def __init__(self, in_features, out_features, sigma=True):
+        super(CosineLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = nn.Parameter(torch.Tensor(out_features, in_features))
+        if sigma:
+            self.sigma = nn.Parameter(torch.Tensor(1))
+        else:
+            self.register_parameter('sigma', None)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        stdv = 1. / math.sqrt(self.weight.size(1))
+        self.weight.data.uniform_(-stdv, stdv)
+        if self.sigma is not None:
+            self.sigma.data.fill_(1)
+
+    def forward(self, input):
+        out = F.linear(F.normalize(input, p=2, dim=1), F.normalize(self.weight, p=2, dim=1))
+        if self.sigma is not None:
+            out = self.sigma * out
+        return {'logits': out}
+
+
+class SplitCosineLinear(nn.Module):
+    def __init__(self, in_features, out_features1, out_features2, sigma=True):
+        super(SplitCosineLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features1 + out_features2
+        self.fc1 = CosineLinear(in_features, out_features1, False)
+        self.fc2 = CosineLinear(in_features, out_features2, False)
+        if sigma:
+            self.sigma = nn.Parameter(torch.Tensor(1))
+            self.sigma.data.fill_(1)
+        else:
+            self.register_parameter('sigma', None)
+
+    def forward(self, x):
+        out1 = self.fc1(x)
+        out2 = self.fc2(x)
+
+        out = torch.cat((out1['logits'], out2['logits']), dim=1)  # concatenate along the channel
+        if self.sigma is not None:
+            out = self.sigma * out
+
+        return {
+            'old_scores': out1['logits'],
+            'new_scores': out2['logits'],
+            'logits': out
+        }
+'''

convs/memo_cifar_resnet.py

@@ -0,0 +1,213 @@
+'''
+For MEMO implementations of CIFAR-ResNet
+Reference:
+https://github.com/khurramjaved96/incremental-learning/blob/autoencoders/model/resnet32.py
+'''
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import logging
+
+class DownsampleA(nn.Module):
+    """
+    A downsampling block that uses average pooling.
+    """
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleA, self).__init__()
+        assert stride == 2
+        self.avg = nn.AvgPool2d(kernel_size=1, stride=stride)
+
+    def forward(self, x):
+        x = self.avg(x)
+        return torch.cat((x, x.mul(0)), 1)
+
+class ResNetBasicblock(nn.Module):
+    """
+    Basic block for ResNet Memo.
+    """
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, nconv=2, downsample=None):
+        super(ResNetBasicblock, self).__init__()
+        self.nconv = nconv
+        self.conv_a = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn_a = nn.BatchNorm2d(planes)
+        if self.nconv == 2:
+            self.conv_b = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+            self.bn_b = nn.BatchNorm2d(planes)
+
+        self.downsample = downsample
+
+    def forward(self, x):
+        residual = x
+
+        basicblock = self.conv_a(x)
+        basicblock = self.bn_a(basicblock)
+        basicblock = F.relu(basicblock, inplace=True)
+        logging.debug('basicblock ---> {}'.format(basicblock.shape))
+        if self.nconv == 2:
+            basicblock = self.conv_b(basicblock)
+            basicblock = self.bn_b(basicblock)
+            logging.debug('basicblock in if block ---> {}'.format(basicblock.shape))
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+            logging.debug('basicblock in downsample ---> {}'.format(basicblock.shape))
+        
+        logging.debug('Final residual ---> {}'.format(residual.shape))
+        logging.debug('Final basicblock ---> {}'.format(basicblock.shape))
+        return F.relu(residual + basicblock, inplace=True)
+
+
+
+class GeneralizedResNet_cifar(nn.Module):
+    """
+    Generalized ResNet for Memo.
+    """
+    def __init__(self, block, depth, channels=3):
+        super(GeneralizedResNet_cifar, self).__init__()
+        assert (depth - 2) % 6 == 0, 'depth should be one of 20, 32, 44, 56, 110'
+        layer_blocks = (depth - 2) // 6
+        self.conv_1_3x3 = nn.Conv2d(channels, 16, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn_1 = nn.BatchNorm2d(16)
+
+        self.inplanes = 16 
+        self.stage_1 = self._make_layer(block, 16, layer_blocks, 1)
+        self.stage_2 = self._make_layer(block, 32, layer_blocks, 2)
+
+        self.out_dim = 64 * block.expansion
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                # m.bias.data.zero_()
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+            elif isinstance(m, nn.Linear):
+                nn.init.kaiming_normal_(m.weight)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = DownsampleA(self.inplanes, planes * block.expansion, stride)
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride=stride, downsample=downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv_1_3x3(x)  # [bs, 16, 32, 32]
+        logging.debug("GB:conv_1_3x3 --> {}".format(x.shape))
+        x = F.relu(self.bn_1(x), inplace=True)
+
+        x_1 = self.stage_1(x)  # [bs, 16, 32, 32]
+        logging.debug("GB:stage_1 --> {}".format(x_1.shape))
+        x_2 = self.stage_2(x_1)  # [bs, 32, 16, 16]
+        logging.debug("GB:stage_2 --> {}".format(x_2.shape))
+        return x_2
+    
+class SpecializedResNet_cifar(nn.Module):
+    """
+    Specialized ResNet for Memo.
+    """
+    def __init__(self, block, depth, nconv=[2,2], inplanes=32, feature_dim=64):
+        super(SpecializedResNet_cifar, self).__init__()
+        self.inplanes = inplanes
+        self.feature_dim = feature_dim
+        layer_blocks = (depth - 2) // 6
+        self.final_stage = self._make_layer(block, 64, layer_blocks, nconv, 2)
+        self.avgpool = nn.AvgPool2d(8)
+        
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                # m.bias.data.zero_()
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+            elif isinstance(m, nn.Linear):
+                nn.init.kaiming_normal_(m.weight)
+                m.bias.data.zero_()
+    
+    def _make_layer(self, block, planes, blocks, nconv, stride=2):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = DownsampleA(self.inplanes, planes * block.expansion, stride)
+        layers = []
+        layers.append(block(self.inplanes, planes, stride=stride, downsample=downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks - 2):
+            layers.append(block(self.inplanes, planes))
+        layers.append(block(self.inplanes, planes, nconv=nconv[0]))
+        if len(nconv)>1:
+            layers.append(block(self.inplanes, planes, nconv=nconv[1]))
+        return nn.Sequential(*layers)
+    
+    def forward(self, base_feature_map):
+        final_feature_map = self.final_stage(base_feature_map)
+        logging.debug("SB:final_stage --> {}".format(final_feature_map.shape))
+        pooled = self.avgpool(final_feature_map)
+        logging.debug("SB:pooled --> {}".format(pooled.shape))
+        features = pooled.view(pooled.size(0), -1) #bs x 64
+        logging.debug("SB:features --> {}".format(features.shape))
+        return features
+
+#For cifar & MEMO
+def get_resnet8_a2fc():
+    basenet = GeneralizedResNet_cifar(ResNetBasicblock,8)
+    adaptivenet = SpecializedResNet_cifar(ResNetBasicblock,8)
+    return basenet,adaptivenet
+
+def get_resnet14_a2fc():
+    basenet = GeneralizedResNet_cifar(ResNetBasicblock,14)
+    adaptivenet = SpecializedResNet_cifar(ResNetBasicblock,14)
+    return basenet,adaptivenet
+
+def get_resnet20_a2fc():
+    basenet = GeneralizedResNet_cifar(ResNetBasicblock,20)
+    adaptivenet = SpecializedResNet_cifar(ResNetBasicblock,20)
+    return basenet,adaptivenet
+
+def get_resnet26_a2fc():
+    basenet = GeneralizedResNet_cifar(ResNetBasicblock,26)
+    adaptivenet = SpecializedResNet_cifar(ResNetBasicblock,26)
+    return basenet,adaptivenet
+
+def get_resnet32_a2fc(args):
+    """
+    Returns a pair of base and adaptive networks for ResNet-32 architecture.
+    Args:
+        args (dict): A dictionary containing parameters such as 'curr' task index and 'layers'.
+    """
+    logging.debug('Curr Task : {}'.format(args['curr']))
+    nconv = args['layers'][args['curr']] if args['curr'] > -1 else [2, 2]
+    logging.debug('Curr Task {}: nconv {}'.format(args['curr'], nconv))
+    basenet = GeneralizedResNet_cifar(ResNetBasicblock,32)
+    adaptivenet = SpecializedResNet_cifar(ResNetBasicblock,32,nconv=nconv)
+    return basenet,adaptivenet
+
+def get_resnet56_a2fc(args):
+    """
+    Returns a pair of base and adaptive networks for ResNet-56 architecture.
+    Args:
+        args (dict): A dictionary containing parameters such as 'curr' task index and 'layers'.
+    """
+    logging.debug('Curr Task : {}'.format(args['curr']))
+    nconv = args['layers'][args['curr']] if args['curr'] > -1 else [2, 2]
+    logging.debug('Curr Task {}: nconv {}'.format(args['curr'], nconv))
+    basenet = GeneralizedResNet_cifar(ResNetBasicblock,32)
+    adaptivenet = SpecializedResNet_cifar(ResNetBasicblock,56,nconv=nconv)
+    return basenet,adaptivenet
+
+

convs/memo_resnet.py

@@ -0,0 +1,385 @@
+'''
+For MEMO implementations of ImageNet-ResNet
+Reference:
+https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
+'''
+import logging
+import torch
+import torch.nn as nn
+try:
+    from torchvision.models.utils import load_state_dict_from_url
+except:
+    from torch.hub import load_state_dict_from_url
+
+__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+           'resnet152', 'resnext50_32x4d', 'resnext101_32x8d',
+           'wide_resnet50_2', 'wide_resnet101_2']
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
+    'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, groups=groups, bias=False, dilation=dilation)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None, nconv=2):
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.nconv = nconv
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        if self.nconv == 2:
+            self.conv2 = conv3x3(planes, planes)
+            self.bn2 = norm_layer(planes)
+        
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        if self.nconv == 2:
+            out = self.conv2(out)
+            out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out = out + identity
+        out = self.relu(out)
+
+        return out
+
+class BasicBlock1Conv(nn.Module):
+    expansion = 1
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(BasicBlock1Conv, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+        out = self.conv1(x)
+        out = self.bn1(out)
+        if self.downsample is not None:
+            identity = self.downsample(x)
+        out += identity
+        out = self.relu(out)
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class GeneralizedResNet_imagenet(nn.Module):
+    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
+                 groups=1, width_per_group=64, replace_stride_with_dilation=None,
+                 norm_layer=None):
+        super(GeneralizedResNet_imagenet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,  # stride=2 -> stride=1 for cifar
+                               bias=False)
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)  # Removed in _forward_impl for cifar
+        logging.debug("Making layer 1")
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        logging.debug("Making layer 2")
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        
+        logging.debug("Making layer 3")
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
+                                        dilate=replace_stride_with_dilation[1])
+        self.out_dim = 512 * block.expansion
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+        layers = []
+        logging.debug("(inplanes: {}, planes: {}) for first layer".format(self.inplanes, planes))
+        
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer))
+        self.inplanes = planes * block.expansion
+        logging.debug("self.inplanes changed to {}".format(self.inplanes))
+        for _ in range(1, blocks):
+            logging.debug("(inplanes: {}, planes: {}) for next layer -->".format(self.inplanes, planes))
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer))
+        return nn.Sequential(*layers)
+    def _forward_impl(self, x):
+        x = self.conv1(x)  
+        logging.debug("GB:conv1 --> {}".format(x.shape))
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+        logging.debug("GB:maxpool --> {}".format(x.shape))
+        x_1 = self.layer1(x)  
+        logging.debug("GB:x_1 --> {}".format(x_1.shape))
+        x_2 = self.layer2(x_1)  
+        logging.debug("GB:x_2 --> {}".format(x_2.shape))
+       
+        x_3 = self.layer3(x_2)  
+        logging.debug("GB:x_3 --> {}".format(x_3.shape))
+        return x_3
+        
+
+    def forward(self, x):
+        return self._forward_impl(x)
+
+class SpecializedResNet_imagenet(nn.Module):
+    def __init__(self, block, layers, nconv, num_classes=1000, zero_init_residual=False,
+                    groups=1, width_per_group=64, replace_stride_with_dilation=None,
+        norm_layer=None):
+        super(SpecializedResNet_imagenet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+        
+        self.feature_dim = 512 * block.expansion
+        self.inplanes = 256 * block.expansion
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                                "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        
+        logging.debug("Making layer 4")
+        self.layer4 = self._make_layer(block, 512, layers[3], nconv=nconv, stride=2,
+                                        dilate=replace_stride_with_dilation[2])
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.out_dim = 512 * block.expansion
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, nconv, stride=1, dilate=False):
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+        layers = []
+        logging.debug("(inplanes: {}, planes: {}) for first layer".format(self.inplanes, planes))
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer, nconv[0]))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            logging.debug("(inplanes: {}, planes: {}) for next layer".format(self.inplanes, planes))
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer, nconv=nconv[1]))
+
+        return nn.Sequential(*layers)
+    
+    def forward(self, x):
+        logging.debug("SB:x --> {}".format(x.shape))        
+        x_4 = self.layer4(x)  # [bs, 512, 4, 4]
+        logging.debug("SB:x_4 --> {}".format(x_4.shape))
+        pooled = self.avgpool(x_4)  # [bs, 512, 1, 1]
+        logging.debug("SB:pooled --> {}".format(pooled.shape))
+        features = torch.flatten(pooled, 1)  # [bs, 512]
+        logging.debug("SB:features --> {}".format(features.shape))
+        return features
+
+def get_resnet10_imagenet():
+    basenet = GeneralizedResNet_imagenet(BasicBlock,[1, 1, 1, 1])
+    adaptivenet = SpecializedResNet_imagenet(BasicBlock, [1, 1, 1, 1])
+    return basenet,adaptivenet
+
+
+def get_resnet18_imagenet(args):    
+    logging.debug('Curr Task : {}'.format(args['curr']))
+
+    nconv = args['layers'][args['curr']] if args['curr'] > -1 else [2, 2]
+    logging.debug('Curr Task {}: nconv {}'.format(args['curr'], nconv))
+    basenet = GeneralizedResNet_imagenet(BasicBlock,[2, 2, 2, 2])
+    adaptivenet = SpecializedResNet_imagenet(BasicBlock, layers=[2,2,2,len(nconv)], nconv=nconv)
+    return basenet,adaptivenet
+
+def get_resnet26_imagenet():
+    basenet = GeneralizedResNet_imagenet(Bottleneck,[2, 2, 2, 2])
+    adaptivenet = SpecializedResNet_imagenet(Bottleneck, [2, 2, 2, 2])
+    return basenet,adaptivenet
+
+def get_resnet34_imagenet():
+    basenet = GeneralizedResNet_imagenet(BasicBlock,[3, 4, 6, 3])
+    adaptivenet = SpecializedResNet_imagenet(BasicBlock, [3, 4, 6, 3])
+    return basenet,adaptivenet
+    
+def get_resnet50_imagenet():
+    basenet = GeneralizedResNet_imagenet(Bottleneck,[3, 4, 6, 3])
+    adaptivenet = SpecializedResNet_imagenet(Bottleneck, [3, 4, 6, 3])
+    return basenet,adaptivenet
+
+
+if __name__ == '__main__':
+    model2imagenet = 3*224*224
+
+    a, b = get_resnet10_imagenet()
+    _base = sum(p.numel() for p in a.parameters())
+    _adap = sum(p.numel() for p in b.parameters())
+    print(f"resnet10 #params:{_base+_adap}")
+
+    a, b = get_resnet18_imagenet()
+    _base = sum(p.numel() for p in a.parameters())
+    _adap = sum(p.numel() for p in b.parameters())
+    print(f"resnet18 #params:{_base+_adap}")
+    
+    a, b = get_resnet26_imagenet()
+    _base = sum(p.numel() for p in a.parameters())
+    _adap = sum(p.numel() for p in b.parameters())
+    print(f"resnet26 #params:{_base+_adap}")
+
+    a, b = get_resnet34_imagenet()
+    _base = sum(p.numel() for p in a.parameters())
+    _adap = sum(p.numel() for p in b.parameters())
+    print(f"resnet34 #params:{_base+_adap}")
+
+    a, b = get_resnet50_imagenet()
+    _base = sum(p.numel() for p in a.parameters())
+    _adap = sum(p.numel() for p in b.parameters())
+    print(f"resnet50 #params:{_base+_adap}")

convs/modified_represnet.py

@@ -0,0 +1,177 @@
+import torch
+import torch.nn as nn
+import math
+import torch.utils.model_zoo as model_zoo
+import torch.nn.functional as F
+
+__all__ = ['ResNet', 'resnet18_rep', 'resnet34_rep' ]
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    "3x3 convolution with padding"
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=True)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=True)
+
+class conv_block(nn.Module):
+
+    def __init__(self, in_planes, planes, mode, stride=1):
+        super(conv_block, self).__init__()
+        self.conv = conv3x3(in_planes, planes, stride)
+        self.mode = mode
+        if mode == 'parallel_adapters':
+            self.adapter = conv1x1(in_planes, planes, stride)
+
+    
+    def re_init_conv(self):
+        nn.init.kaiming_normal_(self.adapter.weight, mode='fan_out', nonlinearity='relu')
+        return 
+    def forward(self, x):
+        y = self.conv(x)
+        if self.mode == 'parallel_adapters':
+            y = y + self.adapter(x)
+
+        return y
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, mode, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv_block(inplanes, planes, mode, stride)
+        self.norm1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv_block(planes, planes, mode)
+        self.norm2 = nn.BatchNorm2d(planes)
+        self.mode = mode
+
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+        out = self.conv1(x)
+        out = self.norm1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+        out = self.norm2(out)
+        if self.downsample is not None:
+            residual = self.downsample(x)
+        out += residual
+        out = self.relu(out)
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=100, args = None):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        assert args is not None
+        self.mode = args["mode"]
+        
+        if 'cifar' in args["dataset"]:
+            self.conv1 = nn.Sequential(nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+                                       nn.BatchNorm2d(self.inplanes), nn.ReLU(inplace=True))
+            print("use cifar")
+        elif 'imagenet' in args["dataset"]:
+            if args["init_cls"] == args["increment"]:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+            else:
+                # Following PODNET implmentation
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+
+
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.feature = nn.AvgPool2d(4, stride=1)
+        self.out_dim = 512
+
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=True),
+            )
+        layers = []
+        layers.append(block(self.inplanes, planes, self.mode, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes, self.mode))
+
+        return nn.Sequential(*layers)
+
+    def switch(self, mode='normal'):
+        for name, module in self.named_modules():
+            if hasattr(module, 'mode'):
+                module.mode = mode
+    def re_init_params(self):
+        for name, module in self.named_modules():
+            if hasattr(module, 're_init_conv'):
+                module.re_init_conv()
+    def forward(self, x):
+        x = self.conv1(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        dim = x.size()[-1]
+        pool = nn.AvgPool2d(dim, stride=1)
+        x = pool(x)
+        x = x.view(x.size(0), -1)
+        return {"features": x}
+
+
+def resnet18_rep(pretrained=False, **kwargs):
+    """Constructs a ResNet-18 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    if pretrained:
+        pretrained_state_dict = model_zoo.load_url(model_urls['resnet18'])
+        now_state_dict        = model.state_dict()
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(now_state_dict)
+    return model
+
+
+def resnet34_rep(pretrained=False, **kwargs):
+    """Constructs a ResNet-34 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        pretrained_state_dict = model_zoo.load_url(model_urls['resnet34'])
+        now_state_dict        = model.state_dict()
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(now_state_dict)
+    return model

convs/resnet.py

@@ -0,0 +1,414 @@
+'''
+Reference:
+https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
+'''
+import logging
+import torch
+import torch.nn as nn
+try:
+    from torchvision.models.utils import load_state_dict_from_url
+except:
+    from torch.hub import load_state_dict_from_url
+
+__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+           'resnet152', 'resnext50_32x4d', 'resnext101_32x8d',
+           'wide_resnet50_2', 'wide_resnet101_2']
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
+    'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, groups=groups, bias=False, dilation=dilation)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+
+
+
+class  ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
+                 groups=1, width_per_group=64, replace_stride_with_dilation=None,
+                 norm_layer=None,args=None):
+        super(ResNet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        
+        assert args is not None, "you should pass args to resnet"
+        if 'cifar' in args["dataset"]:
+            if args["model_name"] == "memo":
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+            else:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),                       
+                    nn.BatchNorm2d(self.inplanes), 
+                    nn.ReLU(inplace=True))
+        elif 'imagenet' in args["dataset"]:
+            if args["init_cls"] == args["increment"]:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+            else:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+                
+        
+
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
+                                       dilate=replace_stride_with_dilation[1])
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
+                                       dilate=replace_stride_with_dilation[2])
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.out_dim = 512 * block.expansion
+        #self.fc = nn.Linear(512 * block.expansion, num_classes)  # Removed in _forward_impl
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer))
+
+        return nn.Sequential(*layers)
+
+    def _forward_impl(self, x):
+        # See note [TorchScript super()]
+        #print("Input data shape------->", x.shape)
+        x = self.conv1(x)  # [bs, 64, 32, 32]
+        #print('x-->', x.shape)
+        x_1 = self.layer1(x)  # [bs, 128, 32, 32]
+        #print('x_1-->', x_1.shape)
+        x_2 = self.layer2(x_1)  # [bs, 256, 16, 16]
+        #print('x_2-->', x_2.shape)
+        x_3 = self.layer3(x_2)  # [bs, 512, 8, 8]
+        #print('x_3-->', x_3.shape)
+        x_4 = self.layer4(x_3)  # [bs, 512, 4, 4]
+
+        #print('x_4-->', x_4.shape)
+
+        pooled = self.avgpool(x_4)  # [bs, 512, 1, 1]
+        features = torch.flatten(pooled, 1)  # [bs, 512]
+        #x = self.fc(features)
+        #print("final x ------>", x.shape)
+
+        return {
+            'fmaps': [x_1, x_2, x_3, x_4],
+            'features': features
+        }
+
+    def forward(self, x):
+        return self._forward_impl(x)
+
+    @property
+    def last_conv(self):
+        if hasattr(self.layer4[-1], 'conv3'):
+            return self.layer4[-1].conv3
+        else:
+            return self.layer4[-1].conv2
+
+
+def _resnet(arch, block, layers, pretrained, progress, **kwargs):
+    model = ResNet(block, layers, **kwargs)
+    #print(model)
+    logging.info("************loading the trained network*************")
+    if pretrained:
+        state_dict = load_state_dict_from_url(model_urls[arch],
+                                              progress=progress)
+        #print(state_dict.keys())
+        #print(state_dict.keys())
+        del state_dict['fc.weight']
+        del state_dict['fc.bias']
+        #model.load_state_dict(state_dict)
+        #print(model)
+        
+        #newmodel = torch.nn.Sequential(*(list(model.children())[:-1]))
+        #print(newmodel)
+    return model
+
+def resnet10(pretrained=False, progress=True, **kwargs):
+    """
+    For MEMO implementations of ResNet-10
+    """
+    return _resnet('resnet10', BasicBlock, [1, 1, 1, 1], pretrained, progress,
+                   **kwargs)
+        
+def resnet26(pretrained=False, progress=True, **kwargs):
+    """
+    For MEMO implementations of ResNet-26
+    """
+    return _resnet('resnet26', Bottleneck, [2, 2, 2, 2], pretrained, progress,
+                   **kwargs)
+
+def resnet18(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-18 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,
+                   **kwargs)
+
+
+def resnet34(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-34 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet50(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-50 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet101(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-101 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet152(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-152 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnext50_32x4d(pretrained=False, progress=True, **kwargs):
+    r"""ResNeXt-50 32x4d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 4
+    return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3],
+                   pretrained, progress, **kwargs)
+
+
+def resnext101_32x8d(pretrained=False, progress=True, **kwargs):
+    r"""ResNeXt-101 32x8d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 8
+    return _resnet('resnext101_32x8d', Bottleneck, [3, 4, 23, 3],
+                   pretrained, progress, **kwargs)
+
+
+def wide_resnet50_2(pretrained=False, progress=True, **kwargs):
+    r"""Wide ResNet-50-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet50_2', Bottleneck, [3, 4, 6, 3],
+                   pretrained, progress, **kwargs)
+
+
+def wide_resnet101_2(pretrained=False, progress=True, **kwargs):
+    r"""Wide ResNet-101-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet101_2', Bottleneck, [3, 4, 23, 3],
+                   pretrained, progress, **kwargs)

convs/resnet_cbam.py

@@ -0,0 +1,267 @@
+import torch
+import torch.nn as nn
+import math
+import torch.utils.model_zoo as model_zoo
+import torch.nn.functional as F
+
+__all__ = ['ResNet', 'resnet18_cbam', 'resnet34_cbam', 'resnet50_cbam', 'resnet101_cbam',
+           'resnet152_cbam']
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    "3x3 convolution with padding"
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=False)
+
+
+class ChannelAttention(nn.Module):
+    def __init__(self, in_planes, ratio=16):
+        super(ChannelAttention, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.max_pool = nn.AdaptiveMaxPool2d(1)
+
+        self.fc1   = nn.Conv2d(in_planes, in_planes // 16, 1, bias=False)
+        self.relu1 = nn.ReLU()
+        self.fc2   = nn.Conv2d(in_planes // 16, in_planes, 1, bias=False)
+
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
+        max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
+        out = avg_out + max_out
+        return self.sigmoid(out)
+
+
+class SpatialAttention(nn.Module):
+    def __init__(self, kernel_size=7):
+        super(SpatialAttention, self).__init__()
+
+        assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
+        padding = 3 if kernel_size == 7 else 1
+
+        self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        avg_out = torch.mean(x, dim=1, keepdim=True)
+        max_out, _ = torch.max(x, dim=1, keepdim=True)
+        x = torch.cat([avg_out, max_out], dim=1)
+        x = self.conv1(x)
+        return self.sigmoid(x)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.ca = ChannelAttention(planes)
+        self.sa = SpatialAttention()
+
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+        out = self.bn2(out)
+        if self.downsample is not None:
+            residual = self.downsample(x)
+        out += residual
+        out = self.relu(out)
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * 4)
+        self.relu = nn.ReLU(inplace=True)
+        self.ca = ChannelAttention(planes * 4)
+        self.sa = SpatialAttention()
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+        out = self.conv3(out)
+        out = self.bn3(out)
+        out = self.ca(out) * out
+        out = self.sa(out) * out
+        if self.downsample is not None:
+            residual = self.downsample(x)
+        out += residual
+        out = self.relu(out)
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=100, args=None):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        assert args is not None, "you should pass args to resnet"
+        if 'cifar' in args["dataset"]:
+            self.conv1 = nn.Sequential(nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+                                       nn.BatchNorm2d(self.inplanes), nn.ReLU(inplace=True))
+        elif 'imagenet' in args["dataset"]:
+            if args["init_cls"] == args["increment"]:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+            else:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.feature = nn.AvgPool2d(4, stride=1)
+        # self.fc = nn.Linear(512 * block.expansion, num_classes)
+        self.out_dim = 512 * block.expansion
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(planes * block.expansion),
+            )
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        dim = x.size()[-1]
+        pool = nn.AvgPool2d(dim, stride=1)
+        x = pool(x)
+        x = x.view(x.size(0), -1)
+        return {"features": x}
+
+def resnet18_cbam(pretrained=False, **kwargs):
+    """Constructs a ResNet-18 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    if pretrained:
+        pretrained_state_dict = model_zoo.load_url(model_urls['resnet18'])
+        now_state_dict        = model.state_dict()
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(now_state_dict)
+    return model
+
+
+def resnet34_cbam(pretrained=False, **kwargs):
+    """Constructs a ResNet-34 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        pretrained_state_dict = model_zoo.load_url(model_urls['resnet34'])
+        now_state_dict        = model.state_dict()
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(now_state_dict)
+    return model
+
+
+def resnet50_cbam(pretrained=False, **kwargs):
+    """Constructs a ResNet-50 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        pretrained_state_dict = model_zoo.load_url(model_urls['resnet50'])
+        now_state_dict        = model.state_dict()
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(now_state_dict)
+    return model
+
+
+def resnet101_cbam(pretrained=False, **kwargs):
+    """Constructs a ResNet-101 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
+    if pretrained:
+        pretrained_state_dict = model_zoo.load_url(model_urls['resnet101'])
+        now_state_dict        = model.state_dict()
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(now_state_dict)
+    return model
+
+
+def resnet152_cbam(pretrained=False, **kwargs):
+    """Constructs a ResNet-152 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
+    if pretrained:
+        pretrained_state_dict = model_zoo.load_url(model_urls['resnet152'])
+        now_state_dict        = model.state_dict()
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(now_state_dict)
+    return model

convs/ucir_cifar_resnet.py

@@ -0,0 +1,204 @@
+'''
+Reference:
+https://github.com/khurramjaved96/incremental-learning/blob/autoencoders/model/resnet32.py
+https://github.com/hshustc/CVPR19_Incremental_Learning/blob/master/cifar100-class-incremental/modified_resnet_cifar.py
+'''
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+# from convs.modified_linear import CosineLinear
+
+
+class DownsampleA(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleA, self).__init__()
+        assert stride == 2
+        self.avg = nn.AvgPool2d(kernel_size=1, stride=stride)
+
+    def forward(self, x):
+        x = self.avg(x)
+        return torch.cat((x, x.mul(0)), 1)
+
+
+class DownsampleB(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleB, self).__init__()
+        self.conv = nn.Conv2d(nIn, nOut, kernel_size=1, stride=stride, padding=0, bias=False)
+        self.bn = nn.BatchNorm2d(nOut)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return x
+
+
+class DownsampleC(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleC, self).__init__()
+        assert stride != 1 or nIn != nOut
+        self.conv = nn.Conv2d(nIn, nOut, kernel_size=1, stride=stride, padding=0, bias=False)
+
+    def forward(self, x):
+        x = self.conv(x)
+        return x
+
+
+class DownsampleD(nn.Module):
+    def __init__(self, nIn, nOut, stride):
+        super(DownsampleD, self).__init__()
+        assert stride == 2
+        self.conv = nn.Conv2d(nIn, nOut, kernel_size=2, stride=stride, padding=0, bias=False)
+        self.bn = nn.BatchNorm2d(nOut)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return x
+
+
+class ResNetBasicblock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, last=False):
+        super(ResNetBasicblock, self).__init__()
+
+        self.conv_a = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn_a = nn.BatchNorm2d(planes)
+
+        self.conv_b = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn_b = nn.BatchNorm2d(planes)
+
+        self.downsample = downsample
+        self.last = last
+
+    def forward(self, x):
+        residual = x
+
+        basicblock = self.conv_a(x)
+        basicblock = self.bn_a(basicblock)
+        basicblock = F.relu(basicblock, inplace=True)
+
+        basicblock = self.conv_b(basicblock)
+        basicblock = self.bn_b(basicblock)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out = residual + basicblock
+        if not self.last:
+            out = F.relu(out, inplace=True)
+
+        return out
+
+
+class CifarResNet(nn.Module):
+    """
+    ResNet optimized for the Cifar Dataset, as specified in
+    https://arxiv.org/abs/1512.03385.pdf
+    """
+
+    def __init__(self, block, depth, channels=3):
+        super(CifarResNet, self).__init__()
+
+        # Model type specifies number of layers for CIFAR-10 and CIFAR-100 model
+        assert (depth - 2) % 6 == 0, 'depth should be one of 20, 32, 44, 56, 110'
+        layer_blocks = (depth - 2) // 6
+
+        self.conv_1_3x3 = nn.Conv2d(channels, 16, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn_1 = nn.BatchNorm2d(16)
+
+        self.inplanes = 16
+        self.stage_1 = self._make_layer(block, 16, layer_blocks, 1)
+        self.stage_2 = self._make_layer(block, 32, layer_blocks, 2)
+        self.stage_3 = self._make_layer(block, 64, layer_blocks, 2, last_phase=True)
+        self.avgpool = nn.AvgPool2d(8)
+        self.out_dim = 64 * block.expansion
+        # self.fc = CosineLinear(64*block.expansion, 10)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, last_phase=False):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = DownsampleB(self.inplanes, planes * block.expansion, stride)  # DownsampleA => DownsampleB
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        if last_phase:
+            for i in range(1, blocks-1):
+                layers.append(block(self.inplanes, planes))
+            layers.append(block(self.inplanes, planes, last=True))
+        else:
+            for i in range(1, blocks):
+                layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv_1_3x3(x)  # [bs, 16, 32, 32]
+        x = F.relu(self.bn_1(x), inplace=True)
+
+        x_1 = self.stage_1(x)  # [bs, 16, 32, 32]
+        x_2 = self.stage_2(x_1)  # [bs, 32, 16, 16]
+        x_3 = self.stage_3(x_2)  # [bs, 64, 8, 8]
+
+        pooled = self.avgpool(x_3)  # [bs, 64, 1, 1]
+        features = pooled.view(pooled.size(0), -1)  # [bs, 64]
+        # out = self.fc(vector)
+
+        return {
+            'fmaps': [x_1, x_2, x_3],
+            'features': features
+        }
+
+    @property
+    def last_conv(self):
+        return self.stage_3[-1].conv_b
+
+
+def resnet20mnist():
+    """Constructs a ResNet-20 model for MNIST."""
+    model = CifarResNet(ResNetBasicblock, 20, 1)
+    return model
+
+
+def resnet32mnist():
+    """Constructs a ResNet-32 model for MNIST."""
+    model = CifarResNet(ResNetBasicblock, 32, 1)
+    return model
+
+
+def resnet20():
+    """Constructs a ResNet-20 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 20)
+    return model
+
+
+def resnet32():
+    """Constructs a ResNet-32 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 32)
+    return model
+
+
+def resnet44():
+    """Constructs a ResNet-44 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 44)
+    return model
+
+
+def resnet56():
+    """Constructs a ResNet-56 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 56)
+    return model
+
+
+def resnet110():
+    """Constructs a ResNet-110 model for CIFAR-10."""
+    model = CifarResNet(ResNetBasicblock, 110)
+    return model

convs/ucir_resnet.py

@@ -0,0 +1,299 @@
+'''
+Reference:
+https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
+'''
+import torch
+import torch.nn as nn
+try:
+    from torchvision.models.utils import load_state_dict_from_url
+except:
+    from torch.hub import load_state_dict_from_url
+
+__all__ = ['resnet50']
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
+    'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, groups=groups, bias=False, dilation=dilation)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None, last=False):
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+        self.last = last
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        if not self.last:
+            out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None, last=False):
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        self.last = last
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        if not self.last:
+            out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
+                 groups=1, width_per_group=64, replace_stride_with_dilation=None,
+                 norm_layer=None, args=None):
+        super(ResNet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        
+        assert args is not None, "you should pass args to resnet"
+        if 'cifar' in args["dataset"]:
+            self.conv1 = nn.Sequential(nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+                                       nn.BatchNorm2d(self.inplanes), nn.ReLU(inplace=True))
+        elif 'imagenet' in args["dataset"]:
+            if args["init_cls"] == args["increment"]:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+            else:
+                self.conv1 = nn.Sequential(
+                    nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+                    nn.BatchNorm2d(self.inplanes),
+                    nn.ReLU(inplace=True),
+                    nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+                )
+
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
+                                       dilate=replace_stride_with_dilation[1])
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
+                                       dilate=replace_stride_with_dilation[2], last_phase=True)
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.out_dim = 512 * block.expansion
+        self.fc = nn.Linear(512 * block.expansion, num_classes)  # Removed in _forward_impl
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilate=False, last_phase=False):
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer))
+        self.inplanes = planes * block.expansion
+        if last_phase:
+            for _ in range(1, blocks-1):
+                layers.append(block(self.inplanes, planes, groups=self.groups,
+                                    base_width=self.base_width, dilation=self.dilation,
+                                    norm_layer=norm_layer))
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer, last=True))
+        else:
+            for _ in range(1, blocks):
+                layers.append(block(self.inplanes, planes, groups=self.groups,
+                                    base_width=self.base_width, dilation=self.dilation,
+                                    norm_layer=norm_layer))
+
+        return nn.Sequential(*layers)
+
+    def _forward_impl(self, x):
+        # See note [TorchScript super()]
+        x = self.conv1(x)  # [bs, 64, 32, 32]
+
+        x_1 = self.layer1(x)  # [bs, 128, 32, 32]
+        x_2 = self.layer2(x_1)  # [bs, 256, 16, 16]
+        x_3 = self.layer3(x_2)  # [bs, 512, 8, 8]
+        x_4 = self.layer4(x_3)  # [bs, 512, 4, 4]
+
+        pooled = self.avgpool(x_4)  # [bs, 512, 1, 1]
+        features = torch.flatten(pooled, 1)  # [bs, 512]
+        # x = self.fc(x)
+
+        return {
+            'fmaps': [x_1, x_2, x_3, x_4],
+            'features': features
+        }
+
+    def forward(self, x):
+        return self._forward_impl(x)
+
+    @property
+    def last_conv(self):
+        if hasattr(self.layer4[-1], 'conv3'):
+            return self.layer4[-1].conv3
+        else:
+            return self.layer4[-1].conv2
+
+
+def _resnet(arch, block, layers, pretrained, progress, **kwargs):
+    model = ResNet(block, layers, **kwargs)
+    if pretrained:
+        state_dict = load_state_dict_from_url(model_urls[arch],
+                                              progress=progress)
+        model.load_state_dict(state_dict)
+    return model
+
+
+def resnet18(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-18 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,
+                   **kwargs)
+
+
+def resnet34(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-34 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet50(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-50 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)

exps/blcl.json

@@ -0,0 +1,30 @@
+{
+    "prefix": "benchmark",
+    "memory_size": 2000,
+    "memory_per_class":20,
+    "fixed_memory": false,
+    "shuffle": true,
+    "init_cls": 4,
+    "increment": 2,
+    "model_name": "blcl",
+    "train_base": true,
+    "train_adaptive": false,
+    "debug": false,
+    "skip": false,
+    "device": ["0"],
+    "seed":[1993],
+    "scheduler": "steplr",
+    "init_epoch": 300,
+    "t_max": null,
+    "init_lr" : 0.1,
+    "init_weight_decay" : 5e-4,
+    "init_lr_decay" : 0.1,
+    "init_milestones" : [60,120,170],
+    "milestones" : [80,120,150],
+    "epochs":300,
+    "lrate" : 0.1,
+    "batch_size" : 64,
+    "weight_decay" : 2e-4,
+    "lrate_decay" : 0.1,
+    "alpha_aux" : 1.0
+}

exps/ewc.json

@@ -0,0 +1,14 @@
+{
+    "prefix": "reproduce",
+    "memory_size": 2000,
+    "memory_per_class": 20,
+    "fixed_memory": false,
+    "shuffle": true,
+    "init_cls": 4,
+    "increment": 2,
+    "model_name": "ewc",
+    "convnet_type": "resnet32",
+    "device": ["0"],
+    "seed": [1993]
+}
+

exps/finetune.json

@@ -0,0 +1,13 @@
+{
+    "prefix": "reproduce",
+    "memory_size": 2000,
+    "memory_per_class": 20,
+    "fixed_memory": false,
+    "shuffle": true,
+    "init_cls": 4,
+    "increment": 2,
+    "model_name": "finetune",
+    "convnet_type": "resnet32",
+    "device": ["0"],
+    "seed": [1993]
+}

exps/icarl.json

@@ -0,0 +1,14 @@
+{
+    "prefix": "reproduce",
+    "memory_size": 2000,
+    "memory_per_class": 20,
+    "fixed_memory": false,
+    "shuffle": true,
+    "init_cls": 4,
+    "increment": 2,
+    "model_name": "icarl",
+    "convnet_type": "resnet32",
+    "device": ["0"],
+    "seed": [1993]
+}
+

exps/lwf.json

@@ -0,0 +1,13 @@
+{
+    "prefix": "reproduce",
+    "memory_size": 2000,
+    "memory_per_class": 20,
+    "fixed_memory": false,
+    "shuffle": true,
+    "init_cls": 4,
+    "increment": 2,
+    "model_name": "lwf",
+    "convnet_type": "resnet32",
+    "device": ["0"],
+    "seed": [1993]
+}

exps/memo.json

@@ -0,0 +1,30 @@
+{
+    "prefix": "benchmark",
+    "memory_size": 2000,
+    "memory_per_class":20,
+    "fixed_memory": false,
+    "shuffle": true,
+    "init_cls": 4,
+    "increment": 2,
+    "model_name": "memo",
+    "train_base": true,
+    "train_adaptive": false,
+    "debug": false,
+    "skip": false,
+    "device": ["0"],
+    "seed":[1993],
+    "scheduler": "steplr",
+    "init_epoch": 300,
+    "t_max": null,
+    "init_lr" : 0.1,
+    "init_weight_decay" : 5e-4,
+    "init_lr_decay" : 0.1,
+    "init_milestones" : [60,120,170],
+    "milestones" : [80,120,150],
+    "epochs":300,
+    "lrate" : 0.1,
+    "batch_size" : 64,
+    "weight_decay" : 2e-4,
+    "lrate_decay" : 0.1,
+    "alpha_aux" : 1.0
+}

exps/replay.json

@@ -0,0 +1,13 @@
+{
+    "prefix": "reproduce",
+    "memory_size": 2000,
+    "memory_per_class": 20,
+    "fixed_memory": false,
+    "shuffle": true,
+    "init_cls": 4,
+    "increment": 2,
+    "model_name": "replay",
+    "convnet_type": "resnet32",
+    "device": ["0"],
+    "seed": [1993]
+}

main.py

@@ -0,0 +1,55 @@
+import json
+import argparse
+from trainer import train
+import json
+
+def string_to_list(args):
+    """
+    Convert a JSON string to a Python list.
+    
+    Args:
+        args (str): JSON string representing a list.
+    
+    Returns:
+        list: Parsed list from the JSON string.
+    """
+    return json.loads(args)
+
+def main():
+    """
+    Function to set up the training process. 
+    Parses command line arguments, loads configuration from a JSON file, and starts the training.
+    """
+    # Parse command-line arguments
+    args = setup_parser().parse_args()
+    param = load_json(args.config)
+    args = vars(args) 
+    args.update(param) 
+    train(args)
+
+def load_json(settings_path):
+    """
+    Load parameters from a JSON file.
+    
+    Args:
+        settings_path (str): Path to the JSON configuration file.
+    
+    Returns:
+        dict: Configuration parameters loaded from the JSON file.
+    """
+    with open(settings_path) as data_file:
+        param = json.load(data_file)
+    return param
+
+def setup_parser():
+    parser = argparse.ArgumentParser(description='Reproduce of multiple continual learning algorthms.')
+    parser.add_argument('--config', type=str, default='./exps/finetune.json', help='Json file of settings.')
+    parser.add_argument('--dataset', default="gnss", help="Kind of dataset",  type=str)
+    parser.add_argument('--summary_file', type=str, default='run_new',help='path for the tensorboard experiment')
+    parser.add_argument('--layers', help='delimited list input',  type=string_to_list)
+    parser.add_argument('--type', default="normal", help='Type of memo models (normal or avg)',  type=str)
+    parser.add_argument('--convnet_type', default="memo_resnet32", help="Kind of resnet",  type=str)
+    return parser
+
+if __name__ == '__main__':
+    main()

models/base.py

@@ -0,0 +1,511 @@
+import copy
+import logging
+import numpy as np
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from utils.toolkit import tensor2numpy, accuracy
+from scipy.spatial.distance import cdist
+import os
+from sklearn.metrics import confusion_matrix
+import seaborn as sn
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+import shutil
+from sklearn.metrics import f1_score, recall_score, precision_score
+import matplotlib
+import matplotlib.pyplot as plt
+plt.rcParams["font.family"] = "serif"
+
+EPSILON = 1e-8
+batch_size = 64
+
+
+class BaseLearner(object):
+    def __init__(self, args):
+        self.args = args
+        self.curr_acc = None
+        self._cur_task = -1
+        self._known_classes = 0
+        self._total_classes = 0
+        self._network = None
+        self._old_network = None
+        self._data_memory, self._targets_memory = np.array([]), np.array([])
+        self.topk = 3
+        self._memory_size = args["memory_size"]
+        self._memory_per_class = args.get("memory_per_class", None)
+        self._fixed_memory = args.get("fixed_memory", False)
+        self._device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        #self._device = args["device"][0]
+        self._multiple_gpus = args["device"]
+        self._predictions_folder = os.path.join('predictions', args["summary_file"])
+        
+        if os.path.exists(self._predictions_folder):
+
+            shutil.rmtree(self._predictions_folder)
+        
+        os.mkdir(self._predictions_folder)
+        
+        
+
+    @property
+    def exemplar_size(self):
+        assert len(self._data_memory) == len(
+            self._targets_memory
+        ), "Exemplar size error."
+        return len(self._targets_memory)
+
+    @property
+    def samples_per_class(self):
+        if self._fixed_memory:
+            return self._memory_per_class
+        else:
+            assert self._total_classes != 0, "Total classes is 0"
+            return self._memory_size // self._total_classes
+
+    @property
+    def feature_dim(self):
+        if isinstance(self._network, nn.DataParallel):
+            return self._network.module.feature_dim
+        else:
+            return self._network.feature_dim
+
+    def build_rehearsal_memory(self, data_manager, per_class):
+        if self._fixed_memory:
+            self._construct_exemplar_unified(data_manager, per_class)
+        else:
+            self._reduce_exemplar(data_manager, per_class)
+            self._construct_exemplar(data_manager, per_class)
+
+    def save_checkpoint(self):
+        
+        torch.save(self._network.state_dict(), os.path.join(self._predictions_folder, "state_dict_task_{}.pth".format(self._cur_task)))
+
+    def save_model(self):
+        self._network.cpu()
+        model_scripted = torch.jit.script(self._network)
+        model_scripted.save(os.path.join(self._predictions_folder, 'model_task_{}.pt'.format(self._cur_task)))
+        
+    def after_task(self):
+        pass
+
+    def _evaluate(self, y_pred, y_true):
+        ret = {}
+        grouped = accuracy(y_pred.T[0], y_true, self._known_classes)
+        ret["grouped"] = grouped
+        ret["top1"] = grouped["total"]
+        ret["top{}".format(self.topk)] = np.around(
+            (y_pred.T == np.tile(y_true, (self.topk, 1))).sum() * 100 / len(y_true),
+            decimals=2,
+        )
+
+        return ret
+
+    def eval_task(self, save_conf=False):
+        y_pred, y_true = self._eval_cnn(self.test_loader)
+        cnn_accy = self._evaluate(y_pred, y_true)
+
+        if hasattr(self, "_class_means"):
+            y_pred, y_true = self._eval_nme(self.test_loader, self._class_means)
+            nme_accy = self._evaluate(y_pred, y_true)
+        else:
+            nme_accy = None
+
+        if save_conf:
+            _pred = y_pred.T[0]
+            _pred_path = os.path.join(self.args['logfilename'], "pred.npy")
+            _target_path = os.path.join(self.args['logfilename'], "target.npy")
+            np.save(_pred_path, _pred)
+            np.save(_target_path, y_true)
+
+            _save_dir = os.path.join(f"./results/conf_matrix/{self.args['prefix']}")
+            os.makedirs(_save_dir, exist_ok=True)
+            _save_path = os.path.join(_save_dir, f"{self.args['csv_name']}.csv")
+            with open(_save_path, "a+") as f:
+                f.write(f"{self.args['time_str']},{self.args['model_name']},{_pred_path},{_target_path} \n")
+
+        return cnn_accy, nme_accy
+
+    def incremental_train(self):
+        pass
+
+    def _train(self):
+        pass
+
+    def _get_memory(self):
+        if len(self._data_memory) == 0:
+            return None
+        else:
+            return (self._data_memory, self._targets_memory)
+
+    def _compute_accuracy(self, model, loader):
+        model.eval()
+        y_pred = [] # save predction
+        y_true = [] # save ground truth
+
+        correct, total = 0, 0
+        for i, (_, inputs, targets) in enumerate(loader):
+            inputs = inputs.to(self._device)
+            with torch.no_grad():
+                outputs = model(inputs)["logits"]
+            predicts = torch.max(outputs, dim=1)[1]
+            
+            correct += (predicts.cpu() == targets).sum()
+            total += len(targets)
+
+            y_pred.extend(predicts.data.cpu().numpy())  # save prediction
+            y_true.extend(targets.data.cpu().numpy())  # save ground truth
+
+        true_targets = np.array(y_true)
+        pred_targets = np.array(y_pred)
+
+        uq_true, count_true = np.unique(true_targets, return_counts=True)
+        uq_pred, count_pred = np.unique(pred_targets, return_counts=True)
+        logging.debug('Task: {}\tUnique True samples after each epoch: {}\tCounts: {}'.format(self._cur_task, uq_true, count_true))
+        logging.debug('Task: {}\tUnique Predicted samples after each epoch: {}\tCounts: {}'.format(self._cur_task, uq_pred, count_pred))
+
+        correct_new = (true_targets == pred_targets).sum()
+        
+        logging.info('#### Task: {} Test ACC after each epoch: {} ####'.format(self._cur_task, 
+                                                               np.around(correct_new * 100 / len(y_pred), decimals=2)))
+        return np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+
+    def _createConfusionMatrix(self, model, loader):
+        """
+        Creates and visualizes the confusion matrix for evaluating the model's performance.
+
+        Parameters:
+            model (torch.nn.Module): The trained model for which the confusion matrix is being generated.
+            loader (torch.utils.data.DataLoader): The data loader for the dataset to be evaluated.
+
+        Returns:
+            matplotlib.figure.Figure: A figure containing the confusion matrix visualization.
+
+        Computes various evaluation metrics including accuracy, F1-score, precision, and recall. 
+        Additionally, it saves the predictions and embeddings for further analysis.
+        """
+        model.eval()
+        y_pred = [] # save predction
+        y_true = [] # save ground truth
+        embeddings = []
+        correct, total = 0, 0
+        # iterate over data
+        for i, (_, inputs, targets) in enumerate(loader):
+            inputs = inputs.to(self._device)
+            with torch.no_grad():
+                outputs = model(inputs)["logits"]
+                embedding = model(inputs)["features"]
+            predicts = torch.max(outputs, dim=1)[1]
+            correct += (predicts.cpu() == targets).sum()
+            total += len(targets)
+
+            y_pred.extend(predicts.data.cpu().numpy())  # save prediction
+            y_true.extend(targets.data.cpu().numpy())  # save ground truth
+            embeddings.extend(embedding.data.cpu().numpy()) # save the embeddings
+        np.save(os.path.join(self._predictions_folder,
+                              'predictions_task_{}_tr_pr.npy'.format(self._cur_task)), np.array(list(zip(y_true, y_pred))))
+        assert np.stack(embeddings).shape[0] == len(embeddings), "embeddings are not of the desired shape"
+        np.save(os.path.join(self._predictions_folder,
+                              'embeddings_task_{}.npy'.format(self._cur_task)), np.stack(embeddings))
+        self.save_checkpoint()
+        self.curr_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+        
+        logging.info('Task: {}\tTest ACC on Inference data ----> {}'.format(self._cur_task, self.curr_acc))
+        
+        # constant for classes
+        classes = tuple(map(str, np.unique(y_true)))
+        f1_scores = f1_score(y_true, y_pred, average=None)
+        recall_scores = recall_score(y_true, y_pred, average=None)
+        precision_scores = precision_score(y_true, y_pred, average=None)
+        mat_size = len(classes)
+        f1_matrix = np.zeros((mat_size, mat_size), float) 
+        precision_matrix = np.zeros((mat_size, mat_size), float) 
+        recall_matrix = np.zeros((mat_size, mat_size), float) 
+        
+        np.fill_diagonal(f1_matrix, f1_scores)
+        np.fill_diagonal(precision_matrix, precision_scores) 
+        np.fill_diagonal(recall_matrix, recall_scores)
+
+        # print the count of each testing label 
+        uq_lbls, lbls_counts = np.unique(y_true, return_counts=True)
+        logging.info('Testing on the classes {}\tCount of each class {}'.format(uq_lbls, lbls_counts))
+
+        # Build confusion matrix
+        cf_matrix = confusion_matrix(y_true, y_pred)
+        
+        group_counts = ['{0:0.0f}'.format(value) for value in cf_matrix.flatten()]
+        group_f1 = ['{0:0.4f}'.format(value) for value in f1_matrix.flatten()]
+        group_precision = ['{0:0.4f}'.format(value) for value in precision_matrix.flatten()]
+        group_recall = ['{0:0.4f}'.format(value) for value in recall_matrix.flatten()]
+
+        percentages = cf_matrix / np.sum(cf_matrix, axis=1)[:, None]
+        group_percentages = ['{0:.2%}'.format(value) for value in percentages.flatten()]
+        
+        labels = ['{}\n{}\n{} {}'.format(v2, v3, v4, v5) for v2, v3, v4, v5 in zip(group_counts, group_f1, group_precision, group_recall)]        
+        labels = np.asarray(labels).reshape(len(classes), len(classes))
+        
+        df_cm = pd.DataFrame(cf_matrix , index=[i for i in classes],
+                            columns=[i for i in classes])
+        
+        plt.figure(figsize=(15, 15))    
+        return sn.heatmap(df_cm, annot=labels, fmt='', 
+                            cmap="rainbow", 
+                            norm=matplotlib.colors.LogNorm(), 
+                            linewidths=0.3,
+                            linecolor='black', 
+                            annot_kws={"color":"black"}
+                            ).get_figure()
+
+
+    def _eval_cnn(self, loader):
+        self._network.eval()
+        y_pred, y_true = [], []
+        for _, (_, inputs, targets) in enumerate(loader):
+            inputs = inputs.to(self._device)
+            with torch.no_grad():
+                outputs = self._network(inputs)["logits"]
+            predicts = torch.topk(
+                outputs, k=self.topk, dim=1, largest=True, sorted=True
+            )[
+                1
+            ]  # [bs, topk]
+            y_pred.append(predicts.cpu().numpy())
+            y_true.append(targets.cpu().numpy())
+
+        return np.concatenate(y_pred), np.concatenate(y_true)  # [N, topk]
+    
+    def _eval_nme(self, loader, class_means):
+        self._network.eval()
+        vectors, y_true = self._extract_vectors(loader)
+        vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+
+        dists = cdist(class_means, vectors, "sqeuclidean")  # [nb_classes, N]
+        scores = dists.T  # [N, nb_classes], choose the one with the smallest distance
+
+        return np.argsort(scores, axis=1)[:, : self.topk], y_true  # [N, topk]
+
+    def _extract_vectors(self, loader):
+        self._network.eval()
+        vectors, targets = [], []
+        for _, _inputs, _targets in loader:
+            _targets = _targets.numpy()
+            if isinstance(self._network, nn.DataParallel):
+                _vectors = tensor2numpy(
+                    self._network.module.extract_vector(_inputs.to(self._device))
+                )
+            else:
+                _vectors = tensor2numpy(
+                    self._network.extract_vector(_inputs.to(self._device))
+                )
+
+            vectors.append(_vectors)
+            targets.append(_targets)
+
+        return np.concatenate(vectors), np.concatenate(targets)
+
+    def _reduce_exemplar(self, data_manager, m):
+        logging.info("Reducing exemplars...({} per classes)".format(m))
+        dummy_data, dummy_targets = copy.deepcopy(self._data_memory), copy.deepcopy(
+            self._targets_memory
+        )
+        self._class_means = np.zeros((self._total_classes, self.feature_dim))
+        self._data_memory, self._targets_memory = np.array([]), np.array([])
+
+        for class_idx in range(self._known_classes):
+            mask = np.where(dummy_targets == class_idx)[0]
+            dd, dt = dummy_data[mask][:m], dummy_targets[mask][:m]
+            self._data_memory = (
+                np.concatenate((self._data_memory, dd))
+                if len(self._data_memory) != 0
+                else dd
+            )
+            self._targets_memory = (
+                np.concatenate((self._targets_memory, dt))
+                if len(self._targets_memory) != 0
+                else dt
+            )
+
+            # Exemplar mean
+            idx_dataset = data_manager.get_dataset(
+                [], source="train", mode="test", appendent=(dd, dt)
+            )
+            idx_loader = DataLoader(
+                idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(idx_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            mean = np.mean(vectors, axis=0)
+            mean = mean / np.linalg.norm(mean)
+
+            self._class_means[class_idx, :] = mean
+
+    def _construct_exemplar(self, data_manager, m):
+        logging.info("Constructing exemplars...({} per classes)".format(m))
+        for class_idx in range(self._known_classes, self._total_classes):
+            data, targets, idx_dataset = data_manager.get_dataset(
+                np.arange(class_idx, class_idx + 1),
+                source="train",
+                mode="test",
+                ret_data=True,
+            )
+            idx_loader = DataLoader(
+                idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(idx_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            class_mean = np.mean(vectors, axis=0)
+
+            # Select
+            selected_exemplars = []
+            exemplar_vectors = []  # [n, feature_dim]
+            for k in range(1, m + 1):
+                S = np.sum(
+                    exemplar_vectors, axis=0
+                )  # [feature_dim] sum of selected exemplars vectors
+                mu_p = (vectors + S) / k  # [n, feature_dim] sum to all vectors
+                i = np.argmin(np.sqrt(np.sum((class_mean - mu_p) ** 2, axis=1)))
+                selected_exemplars.append(
+                    np.array(data[i])
+                )  # New object to avoid passing by inference
+                exemplar_vectors.append(
+                    np.array(vectors[i])
+                )  # New object to avoid passing by inference
+
+                vectors = np.delete(
+                    vectors, i, axis=0
+                )  # Remove it to avoid duplicative selection
+                data = np.delete(
+                    data, i, axis=0
+                )  # Remove it to avoid duplicative selection
+
+            # uniques = np.unique(selected_exemplars, axis=0)
+            # print('Unique elements: {}'.format(len(uniques)))
+            selected_exemplars = np.array(selected_exemplars)
+            exemplar_targets = np.full(m, class_idx)
+            self._data_memory = (
+                np.concatenate((self._data_memory, selected_exemplars))
+                if len(self._data_memory) != 0
+                else selected_exemplars
+            )
+            self._targets_memory = (
+                np.concatenate((self._targets_memory, exemplar_targets))
+                if len(self._targets_memory) != 0
+                else exemplar_targets
+            )
+
+            # Exemplar mean
+            idx_dataset = data_manager.get_dataset(
+                [],
+                source="train",
+                mode="test",
+                appendent=(selected_exemplars, exemplar_targets),
+            )
+            idx_loader = DataLoader(
+                idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(idx_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            mean = np.mean(vectors, axis=0)
+            mean = mean / np.linalg.norm(mean)
+
+            self._class_means[class_idx, :] = mean
+
+    def _construct_exemplar_unified(self, data_manager, m):
+        logging.info(
+            "Constructing exemplars for new classes...({} per classes)".format(m)
+        )
+        _class_means = np.zeros((self._total_classes, self.feature_dim))
+
+        # Calculate the means of old classes with newly trained network
+        for class_idx in range(self._known_classes):
+            mask = np.where(self._targets_memory == class_idx)[0]
+            class_data, class_targets = (
+                self._data_memory[mask],
+                self._targets_memory[mask],
+            )
+
+            class_dset = data_manager.get_dataset(
+                [], source="train", mode="test", appendent=(class_data, class_targets)
+            )
+            class_loader = DataLoader(
+                class_dset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(class_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            mean = np.mean(vectors, axis=0)
+            mean = mean / np.linalg.norm(mean)
+
+            _class_means[class_idx, :] = mean
+
+        # Construct exemplars for new classes and calculate the means
+        for class_idx in range(self._known_classes, self._total_classes):
+            data, targets, class_dset = data_manager.get_dataset(
+                np.arange(class_idx, class_idx + 1),
+                source="train",
+                mode="test",
+                ret_data=True,
+            )
+            class_loader = DataLoader(
+                class_dset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+
+            vectors, _ = self._extract_vectors(class_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            class_mean = np.mean(vectors, axis=0)
+
+            # Select
+            selected_exemplars = []
+            exemplar_vectors = []
+            for k in range(1, m + 1):
+                S = np.sum(
+                    exemplar_vectors, axis=0
+                )  # [feature_dim] sum of selected exemplars vectors
+                mu_p = (vectors + S) / k  # [n, feature_dim] sum to all vectors
+                i = np.argmin(np.sqrt(np.sum((class_mean - mu_p) ** 2, axis=1)))
+
+                selected_exemplars.append(
+                    np.array(data[i])
+                )  # New object to avoid passing by inference
+                exemplar_vectors.append(
+                    np.array(vectors[i])
+                )  # New object to avoid passing by inference
+
+                vectors = np.delete(
+                    vectors, i, axis=0
+                )  # Remove it to avoid duplicative selection
+                data = np.delete(
+                    data, i, axis=0
+                )  # Remove it to avoid duplicative selection
+
+            selected_exemplars = np.array(selected_exemplars)
+            exemplar_targets = np.full(m, class_idx)
+            self._data_memory = (
+                np.concatenate((self._data_memory, selected_exemplars))
+                if len(self._data_memory) != 0
+                else selected_exemplars
+            )
+            self._targets_memory = (
+                np.concatenate((self._targets_memory, exemplar_targets))
+                if len(self._targets_memory) != 0
+                else exemplar_targets
+            )
+
+            # Exemplar mean
+            exemplar_dset = data_manager.get_dataset(
+                [],
+                source="train",
+                mode="test",
+                appendent=(selected_exemplars, exemplar_targets),
+            )
+            exemplar_loader = DataLoader(
+                exemplar_dset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(exemplar_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            mean = np.mean(vectors, axis=0)
+            mean = mean / np.linalg.norm(mean)
+
+            _class_means[class_idx, :] = mean
+
+        self._class_means = _class_means

models/blcl.py

@@ -0,0 +1,455 @@
+import logging
+import numpy as np
+from tqdm import tqdm
+import torch
+from torch import nn
+import copy
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from models.base import BaseLearner
+from utils.inc_net import AdaptiveNet
+from utils.toolkit import count_parameters, target2onehot, tensor2numpy
+from utils.contrastive_loss import DMLLossCosine, DMLLossCosine
+from utils.bayesian_weighting import AutomaticWeightedLoss
+from torch.utils.tensorboard import SummaryWriter
+
+num_workers=2
+EPSILON = 1e-8
+batch_size = 64
+
+class BLCL(BaseLearner):
+    """
+    BLCL: Continual Learning class implementing incremental learning with contrastive and cross-entropy lossusing uncertaintiy-based weighting of the losses.
+    It handles sequential training on new tasks, while preserving knowledge from previously learned classes.
+    """
+    def __init__(self, args):
+        super().__init__(args)
+        self.args = args
+        self._old_base = None
+        self.args.update({'curr': self._cur_task})
+        self._network = AdaptiveNet(args, True)
+        logging.info(f'>>> train generalized blocks:{self.args["train_base"]} train_adaptive:{self.args["train_adaptive"]}')
+        self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file']))
+
+
+    def after_task(self):
+        """
+        Update known classes after finishing a task.
+        Handle freezing or training of generalized blocks based on the task configuration.
+        """
+        self._known_classes = self._total_classes
+        if self._cur_task == 0:
+            if self.args['train_base']:
+                logging.info("Train Generalized Blocks...")
+                self._network.TaskAgnosticExtractor.train()
+                for param in self._network.TaskAgnosticExtractor.parameters():
+                    param.requires_grad = True
+            else:
+                logging.info("Fix Generalized Blocks...")
+                self._network.TaskAgnosticExtractor.eval()
+                for param in self._network.TaskAgnosticExtractor.parameters():
+                    param.requires_grad = False
+        
+        logging.info('Exemplar size: {}'.format(self.exemplar_size))
+
+    def incremental_train(self, data_manager):
+        """
+        Perform incremental training for the current task. This method updates the model to learn new classes
+
+        Args:
+            data_manager (DataManager): Manages datasets and provides task-specific data.
+        """
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(self._cur_task)
+
+        # Update arguments with the current task number.
+        self.args.update({'curr': self._cur_task})
+
+        # Update the model's fully connected layer to accommodate new classes.
+        self._network.update_fc(self._total_classes)
+        logging.info("****MODEL ARCHITECTURE after fc update*****")
+        logging.info(self._network)
+        logging.info('Learning on {}-{}'.format(self._known_classes, self._total_classes))
+        logging.info(
+            "Known_classes: {}\tTotal_classes: {}\tcurrent_task: {}".format(self._known_classes, self._total_classes, self._cur_task)
+        )
+
+        if self._cur_task>0: # Freeze the network of the previous trained adaptive network (requires grad = False)
+            logging.info("self._curr_task {} and no of adaptiveExtractors {}".format(self._cur_task, len(self._network.AdaptiveExtractors)))
+            for i in range(self._cur_task):
+                for p in self._network.AdaptiveExtractors[i].parameters():
+                    if self.args['train_adaptive']:
+                        p.requires_grad = True
+                    else:
+                        p.requires_grad = False
+                    
+                if self.args["type"] == "avg":
+                    break
+
+        logging.debug('All params: {}'.format(count_parameters(self._network)))
+        logging.debug('Trainable params: {}'.format(count_parameters(self._network, True)))
+
+        # Get the training dataset, including any rehearsal memory (previously stored samples).
+        _, tr_targets, train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source='train',
+            mode='train', 
+            appendent=self._get_memory(),
+            ret_data=True
+        )
+        
+        self.train_loader = DataLoader(
+            train_dataset, 
+            num_workers=num_workers,
+            batch_size=self.args["batch_size"],
+            shuffle=True
+        )
+        
+
+        _, te_targets, test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), 
+            source='test', 
+            mode='test',
+            ret_data=True
+        )
+        
+        self.test_loader = DataLoader(
+            test_dataset,
+            batch_size=self.args["batch_size"],
+            shuffle=False, 
+            num_workers=num_workers
+        )
+
+        # Setup losses: Automatic weighting of cross-entropy loss and contrastive loss
+        self.contrastive_loss = DMLLossCosine() 
+        self.awl = AutomaticWeightedLoss(2)
+
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+        self.build_rehearsal_memory(data_manager, self.samples_per_class)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+    
+    def set_network(self):
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+        self._network.train()                   #All status from eval to train
+        if self.args['train_base']:
+            self._network.TaskAgnosticExtractor.train()
+        else:
+            self._network.TaskAgnosticExtractor.eval()
+        
+        # set adaptive extractor's status
+        self._network.AdaptiveExtractors[-1].train()
+        if self._cur_task >= 1:
+            for i in range(self._cur_task):
+                if self.args['train_adaptive']:
+                    self._network.AdaptiveExtractors[i].train()
+                else:
+                    self._network.AdaptiveExtractors[i].eval()
+                if self.args["type"] == "avg":
+                    break
+            
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+            
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if self._cur_task==0:
+            logging.debug('## Initial Training ##')
+            optimizer = optim.SGD([{"params": filter(lambda p: p.requires_grad, self._network.parameters()),
+                                   "momentum": 0.9,
+                                   "lr": self.args["init_lr"],
+                                   "weight_decay": self.args["init_weight_decay"]},
+                                  {"params": self.awl.parameters(),
+                                   "weight_decay": 0,
+                                   "lr": self.args["init_lr"]}])
+            if self.args['scheduler'] == 'steplr':
+                scheduler = optim.lr_scheduler.MultiStepLR(
+                    optimizer=optimizer, 
+                    milestones=self.args['init_milestones'], 
+                    gamma=self.args['init_lr_decay']
+                )
+            elif self.args['scheduler'] == 'cosine':
+                scheduler = optim.lr_scheduler.CosineAnnealingLR(
+                    optimizer=optimizer,
+                    T_max=self.args['init_epoch']
+                ) 
+            else:
+                raise NotImplementedError
+            
+            if not self.args['skip']:
+                self._init_train(train_loader, test_loader, optimizer, scheduler)
+            else:
+                if isinstance(self._network, nn.DataParallel):
+                    self._network = self._network.module
+                load_acc = self._network.load_checkpoint(self.args)
+                self._network.to(self._device)
+
+                if len(self._multiple_gpus) > 1:
+                    self._network = nn.DataParallel(self._network, self._multiple_gpus)
+                
+                cur_test_acc = self._compute_accuracy(self._network, self.test_loader)
+                logging.info(f"Loaded_Test_Acc:{load_acc} Cur_Test_Acc:{cur_test_acc}")
+        else:
+            optimizer = optim.SGD([{"params": filter(lambda p: p.requires_grad, self._network.parameters()),
+                                   "momentum": 0.9,
+                                   "lr": self.args["lrate"],
+                                   "weight_decay": self.args["weight_decay"]},
+                                  {"params": self.awl.parameters(),
+                                   "weight_decay": 0,
+                                   "lr": self.args["lrate"]}])
+            if self.args['scheduler'] == 'steplr':
+                scheduler = optim.lr_scheduler.MultiStepLR(
+                    optimizer=optimizer,
+                    milestones=self.args['milestones'], 
+                    gamma=self.args['lrate_decay']
+                )
+            elif self.args['scheduler'] == 'cosine':
+                assert self.args['t_max'] is not None
+                scheduler = optim.lr_scheduler.CosineAnnealingLR(
+                    optimizer=optimizer,
+                    T_max=self.args['t_max']
+                )
+            else:
+                raise NotImplementedError
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+            if len(self._multiple_gpus) > 1:
+                self._network.module.weight_align(self._total_classes-self._known_classes)
+            else:
+                self._network.weight_align(self._total_classes-self._known_classes)
+            
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.test_loader),
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+
+
+    def _test_model(self, test_loader, epoch):
+        self._network.eval()
+        self.awl.eval()
+        losses = 0.
+        losses_clf = 0.
+        
+        for i, (_, inputs, targets) in enumerate(test_loader):
+            inputs, targets = inputs.to(self._device), targets.to(self._device)
+            outputs = self._network(inputs)
+            logits =outputs["logits"]
+
+            loss_clf = F.cross_entropy(logits, targets)
+            loss = loss_clf
+            losses += loss.item()
+            losses_clf += loss_clf.item()
+            
+        self.writer.add_scalar('Task: {} on {}-{} -- test/classification_loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses_clf / len(test_loader), epoch)
+        
+
+    def _init_train(self,train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(self.args["init_epoch"]))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.
+            losses_clf = 0.
+            losses_contrast = 0.
+            correct, total = 0, 0
+            
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                
+                outputs = self._network(inputs)
+                logits, embeddings =outputs["logits"], outputs["features"]
+
+                loss_clf = F.cross_entropy(logits,targets)
+                c_loss = self.contrastive_loss(embeddings, targets)
+                loss = self.awl(loss_clf, c_loss)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+                losses_clf+=loss_clf.item()
+                losses_contrast+=c_loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            params = list(next(self.awl.parameters()))
+            self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses_contrast / len(train_loader), epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/classification_loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses_clf / len(train_loader), epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/Total_loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses / len(train_loader), epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/clf_weight'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        params[0], epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_weight'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        params[1], epoch)
+            
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct)*100 / total, decimals=2)
+            if epoch%5==0:
+                self._test_model(test_loader=self.test_loader, epoch=epoch)
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}'.format(
+                self._cur_task, epoch+1, self.args['init_epoch'], losses/len(train_loader), train_acc, test_acc)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        test_acc,  epoch)
+            else:
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}'.format(
+                self._cur_task,
+                epoch + 1,
+                self.args['init_epoch'],
+                losses/len(train_loader),
+                train_acc)
+            prog_bar.set_description(info)
+        logging.info(info)
+       
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(self.args["epochs"]))
+        for _, epoch in enumerate(prog_bar):
+            self.set_network()
+            losses = 0.
+            losses_clf=0.
+            losses_contrast=0.
+            losses_aux=0.
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                
+                outputs = self._network(inputs)
+                
+                
+                logits, aux_logits, embeddings=outputs["logits"],outputs["aux_logits"],outputs["features"]
+
+                loss_clf=F.cross_entropy(logits,targets)
+                c_loss = self.contrastive_loss(embeddings,targets)
+                aux_targets = targets.clone()
+                aux_targets=torch.where(aux_targets-self._known_classes+1>0,  aux_targets-self._known_classes+1,0)
+                loss_aux=F.cross_entropy(aux_logits,aux_targets)
+                loss= self.awl(loss_clf, c_loss) + self.args['alpha_aux']*loss_aux 
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+                losses_aux+=loss_aux.item()
+                losses_clf+=loss_clf.item()
+                losses_contrast+=c_loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            params = list(next(self.awl.parameters()))
+            self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses_contrast / len(train_loader), epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/classification_loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses_clf / len(train_loader), epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/Total_loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses / len(train_loader), epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/clf_weight'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        params[0], epoch)
+            self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_weight'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        params[1], epoch)
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct)*100 / total, decimals=2)
+            if epoch % 5 == 0:
+                self._test_model(test_loader=self.test_loader, epoch=epoch)
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux  {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}'.format(
+                self._cur_task, epoch+1, self.args["epochs"], losses/len(train_loader),losses_clf/len(train_loader),losses_aux/len(train_loader),train_acc, test_acc)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes), 
+                                       test_acc,  epoch)
+            else:
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux {:.3f}, Train_accy {:.2f}'.format(
+                self._cur_task, 
+                epoch + 1, 
+                self.args["epochs"], 
+                losses/len(train_loader), 
+                losses_clf/len(train_loader),
+                losses_aux/len(train_loader),
+                train_acc)
+                
+            prog_bar.set_description(info)
+        logging.info(info)
+    
+    
+    def _construct_exemplar(self, data_manager, m):
+        logging.info("Constructing exemplars...({} per classes)".format(m))
+        for class_idx in range(self._known_classes, self._total_classes):
+            data, targets, idx_dataset = data_manager.get_dataset(
+                np.arange(class_idx, class_idx + 1),
+                source="train",
+                mode="test",
+                ret_data=True,
+            )
+            idx_loader = DataLoader(
+                idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(idx_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            class_mean = np.mean(vectors, axis=0)
+
+            # Select
+            selected_exemplars = []
+            exemplar_vectors = []  # [n, feature_dim]
+            for k in range(1, m + 1):
+                S = np.sum(
+                    exemplar_vectors, axis=0
+                )  # [feature_dim] sum of selected exemplars vectors
+                mu_p = (vectors + S) / k  # [n, feature_dim] sum to all vectors
+                i = np.argmin(np.sqrt(np.sum((class_mean - mu_p) ** 2, axis=1)))
+                selected_exemplars.append(
+                    np.array(data[i])
+                )  # New object to avoid passing by inference
+                exemplar_vectors.append(
+                    np.array(vectors[i])
+                )  # New object to avoid passing by inference
+
+                vectors = np.delete(
+                    vectors, i, axis=0
+                )  # Remove it to avoid duplicative selection
+                data = np.delete(
+                    data, i, axis=0
+                )  # Remove it to avoid duplicative selection
+                
+                if len(vectors) == 0:
+                    break
+            # uniques = np.unique(selected_exemplars, axis=0)
+            # print('Unique elements: {}'.format(len(uniques)))
+            selected_exemplars = np.array(selected_exemplars)
+            # exemplar_targets = np.full(m, class_idx)
+            exemplar_targets = np.full(selected_exemplars.shape[0], class_idx)
+            self._data_memory = (
+                np.concatenate((self._data_memory, selected_exemplars))
+                if len(self._data_memory) != 0
+                else selected_exemplars
+            )
+            self._targets_memory = (
+                np.concatenate((self._targets_memory, exemplar_targets))
+                if len(self._targets_memory) != 0
+                else exemplar_targets
+            )
+
+            # Exemplar mean
+            idx_dataset = data_manager.get_dataset(
+                [],
+                source="train",
+                mode="test",
+                appendent=(selected_exemplars, exemplar_targets),
+            )
+            idx_loader = DataLoader(
+                idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(idx_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            mean = np.mean(vectors, axis=0)
+            mean = mean / np.linalg.norm(mean)
+
+            self._class_means[class_idx, :] = mean

models/der.py

@@ -0,0 +1,230 @@
+# Please note that the current implementation of DER only contains the dynamic expansion process, since masking and pruning are not implemented by the source repo.
+import logging
+import numpy as np
+from tqdm import tqdm
+import torch
+from torch import nn
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from models.base import BaseLearner
+from utils.inc_net import DERNet, IncrementalNet
+from utils.toolkit import count_parameters, target2onehot, tensor2numpy
+
+EPSILON = 1e-8
+
+init_epoch = 200
+init_lr = 0.1
+init_milestones = [60, 120, 170]
+init_lr_decay = 0.1
+init_weight_decay = 0.0005
+
+
+epochs = 170
+lrate = 0.1
+milestones = [80, 120, 150]
+lrate_decay = 0.1
+batch_size = 128
+weight_decay = 2e-4
+num_workers = 8
+T = 2
+
+
+class DER(BaseLearner):
+    def __init__(self, args):
+        super().__init__(args)
+        self._network = DERNet(args, False)
+
+    def after_task(self):
+        self._known_classes = self._total_classes
+        logging.info("Exemplar size: {}".format(self.exemplar_size))
+
+    def incremental_train(self, data_manager):
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(
+            self._cur_task
+        )
+        self._network.update_fc(self._total_classes)
+        logging.info(
+            "Learning on {}-{}".format(self._known_classes, self._total_classes)
+        )
+
+        if self._cur_task > 0:
+            for i in range(self._cur_task):
+                for p in self._network.convnets[i].parameters():
+                    p.requires_grad = False
+
+        logging.info("All params: {}".format(count_parameters(self._network)))
+        logging.info(
+            "Trainable params: {}".format(count_parameters(self._network, True))
+        )
+
+        train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source="train",
+            mode="train",
+            appendent=self._get_memory(),
+        )
+        self.train_loader = DataLoader(
+            train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers
+        )
+        test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), source="test", mode="test"
+        )
+        self.test_loader = DataLoader(
+            test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+        self.build_rehearsal_memory(data_manager, self.samples_per_class)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+
+    def train(self):
+        self._network.train()
+        if len(self._multiple_gpus) > 1 :
+            self._network_module_ptr = self._network.module
+        else:
+            self._network_module_ptr = self._network
+        self._network_module_ptr.convnets[-1].train()
+        if self._cur_task >= 1:
+            for i in range(self._cur_task):
+                self._network_module_ptr.convnets[i].eval()
+
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if self._cur_task == 0:
+            optimizer = optim.SGD(
+                filter(lambda p: p.requires_grad, self._network.parameters()),
+                momentum=0.9,
+                lr=init_lr,
+                weight_decay=init_weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=init_milestones, gamma=init_lr_decay
+            )
+            self._init_train(train_loader, test_loader, optimizer, scheduler)
+        else:
+            optimizer = optim.SGD(
+                filter(lambda p: p.requires_grad, self._network.parameters()),
+                lr=lrate,
+                momentum=0.9,
+                weight_decay=weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=milestones, gamma=lrate_decay
+            )
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+            if len(self._multiple_gpus) > 1:
+                self._network.module.weight_align(
+                    self._total_classes - self._known_classes
+                )
+            else:
+                self._network.weight_align(self._total_classes - self._known_classes)
+
+    def _init_train(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(init_epoch))
+        for _, epoch in enumerate(prog_bar):
+            self.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                loss = F.cross_entropy(logits, targets)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+
+        logging.info(info)
+
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(epochs))
+        for _, epoch in enumerate(prog_bar):
+            self.train()
+            losses = 0.0
+            losses_clf = 0.0
+            losses_aux = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                outputs = self._network(inputs)
+                logits, aux_logits = outputs["logits"], outputs["aux_logits"]
+                loss_clf = F.cross_entropy(logits, targets)
+                aux_targets = targets.clone()
+                aux_targets = torch.where(
+                    aux_targets - self._known_classes + 1 > 0,
+                    aux_targets - self._known_classes + 1,
+                    0,
+                )
+                loss_aux = F.cross_entropy(aux_logits, aux_targets)
+                loss = loss_clf + loss_aux
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+                losses_aux += loss_aux.item()
+                losses_clf += loss_clf.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    losses_clf / len(train_loader),
+                    losses_aux / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    losses_clf / len(train_loader),
+                    losses_aux / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+        logging.info(info)

models/ewc.py

@@ -0,0 +1,275 @@
+import logging
+import numpy as np
+from tqdm import tqdm
+import torch
+from torch import nn
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from models.base import BaseLearner
+from models.podnet import pod_spatial_loss
+from utils.inc_net import IncrementalNet
+from utils.toolkit import target2onehot, tensor2numpy
+from torch.utils.tensorboard import SummaryWriter
+
+
+
+EPSILON = 1e-8
+
+init_epoch = 200
+init_lr = 0.1
+init_milestones = [60, 120, 170]
+init_lr_decay = 0.1
+init_weight_decay = 0.0005
+
+
+epochs = 200
+lrate = 0.1
+milestones = [70, 120, 150]
+lrate_decay = 0.1
+batch_size = 32
+weight_decay = 2e-4
+num_workers = 2
+T = 2
+lamda = 1000
+fishermax = 0.0001
+
+
+
+
+class EWC(BaseLearner):
+    def __init__(self, args):
+        super().__init__(args)
+        self.fisher = None
+        self._network = IncrementalNet(args, True)
+        self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file']))
+        
+
+    def after_task(self):
+        self._known_classes = self._total_classes
+
+    def incremental_train(self, data_manager):
+        self.curr_acc = 0
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(
+            self._cur_task
+        )
+        self._network.update_fc(self._total_classes)
+        logging.info(
+            "Learning on {}-{}".format(self._known_classes, self._total_classes)
+        )
+
+        train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source="train",
+            mode="train",
+        )
+        self.train_loader = DataLoader(
+            train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers
+        )
+        test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), source="test", mode="test"
+        )
+        self.test_loader = DataLoader(
+            test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+
+        if self.fisher is None:
+            self.fisher = self.getFisherDiagonal(self.train_loader)
+        else:
+            alpha = self._known_classes / self._total_classes
+            new_finsher = self.getFisherDiagonal(self.train_loader)
+            for n, p in new_finsher.items():
+                new_finsher[n][: len(self.fisher[n])] = (
+                    alpha * self.fisher[n]
+                    + (1 - alpha) * new_finsher[n][: len(self.fisher[n])]
+                )
+            self.fisher = new_finsher
+        self.mean = {
+            n: p.clone().detach()
+            for n, p in self._network.named_parameters()
+            if p.requires_grad
+        }
+        if self._total_classes == data_manager.get_total_classnum():
+            self.writer.close()
+
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if self._cur_task == 0:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                momentum=0.9,
+                lr=init_lr,
+                weight_decay=init_weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=init_milestones, gamma=init_lr_decay
+            )
+            self._init_train(train_loader, test_loader, optimizer, scheduler)
+        else:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                lr=lrate,
+                momentum=0.9,
+                weight_decay=weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=milestones, gamma=lrate_decay
+            )
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+        
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.test_loader),
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+        
+
+    def _init_train(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(init_epoch))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+                loss = F.cross_entropy(logits, targets)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+
+            prog_bar.set_description(info)
+
+        logging.info(info)
+
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(epochs))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                loss_clf = F.cross_entropy(
+                    logits[:, self._known_classes :], targets - self._known_classes
+                )
+                loss_ewc = self.compute_ewc()
+                loss = loss_clf + lamda * loss_ewc
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+        logging.info(info)
+
+    def compute_ewc(self):
+        loss = 0
+        if len(self._multiple_gpus) > 1:
+            for n, p in self._network.module.named_parameters():
+                if n in self.fisher.keys():
+                    loss += (
+                        torch.sum(
+                            (self.fisher[n])
+                            * (p[: len(self.mean[n])] - self.mean[n]).pow(2)
+                        )
+                        / 2
+                    )
+        else:
+            for n, p in self._network.named_parameters():
+                if n in self.fisher.keys():
+                    loss += (
+                        torch.sum(
+                            (self.fisher[n])
+                            * (p[: len(self.mean[n])] - self.mean[n]).pow(2)
+                        )
+                        / 2
+                    )
+        return loss
+
+    def getFisherDiagonal(self, train_loader):
+        fisher = {
+            n: torch.zeros(p.shape).to(self._device)
+            for n, p in self._network.named_parameters()
+            if p.requires_grad
+        }
+        self._network.train()
+        optimizer = optim.SGD(self._network.parameters(), lr=lrate)
+        for i, (_, inputs, targets) in enumerate(train_loader):
+            inputs, targets = inputs.to(self._device), targets.to(self._device)
+            logits = self._network(inputs)["logits"]
+            loss = torch.nn.functional.cross_entropy(logits, targets)
+            optimizer.zero_grad()
+            loss.backward()
+            for n, p in self._network.named_parameters():
+                if p.grad is not None:
+                    fisher[n] += p.grad.pow(2).clone()
+        for n, p in fisher.items():
+            fisher[n] = p / len(train_loader)
+            fisher[n] = torch.min(fisher[n], torch.tensor(fishermax))
+        return fisher

models/finetune.py

@@ -0,0 +1,231 @@
+import logging
+import numpy as np
+import torch
+from torch import nn
+from torch.serialization import load
+from tqdm import tqdm
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from utils.inc_net import IncrementalNet
+from models.base import BaseLearner
+from utils.toolkit import target2onehot, tensor2numpy, count_parameters, count_parameters
+from torch.utils.tensorboard import SummaryWriter
+
+
+
+init_epoch = 200
+init_lr = 0.1
+init_milestones = [60, 120, 170]
+init_lr_decay = 0.1
+init_weight_decay = 0.0005
+
+
+epochs = 200
+lrate = 0.1
+milestones = [40, 70]
+lrate_decay = 0.1
+batch_size = 32
+
+weight_decay = 2e-4
+num_workers = 2
+
+
+class Finetune(BaseLearner):
+    def __init__(self, args):
+        super().__init__(args)
+        self._network = IncrementalNet(args, True)
+        self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file']))
+        #self.train_mode = args['train']
+
+    def after_task(self):
+        self._known_classes = self._total_classes
+
+    def incremental_train(self, data_manager):
+        self.curr_acc = 0
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(
+            self._cur_task
+        )
+        
+        
+        self._network.update_fc(self._total_classes)
+        logging.info(
+            "Learning on {}-{}".format(self._known_classes, self._total_classes)
+        )
+        logging.info("All params: {}".format(count_parameters(self._network)))
+        logging.info(
+            "Trainable params: {}".format(count_parameters(self._network, True))
+        )
+        logging.debug("****MODEL ARCHITECTURE****")
+        logging.debug(self._network)
+
+
+        train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source="train",
+            mode="train",
+        )
+        
+
+
+        self.train_loader = DataLoader(
+            train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers
+        )
+        test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), source="test", mode="test"
+        )
+        self.test_loader = DataLoader(
+            test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+        
+        if len(self._multiple_gpus) > 1:
+            print('***********RUNNING on multiple devices****************')
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+       
+        self._train(self.train_loader, self.test_loader)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+        if self._total_classes == data_manager.get_total_classnum():
+            self.writer.close()
+
+    def _train(self, train_loader, test_loader):
+
+        self._network.to(self._device)
+        
+        if self._cur_task == 0:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                momentum=0.9,
+                lr=init_lr,
+                weight_decay=init_weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=init_milestones, gamma=init_lr_decay
+            )
+            self._init_train(train_loader, test_loader, optimizer, scheduler)
+        else:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                lr=lrate,
+                momentum=0.9,
+                weight_decay=weight_decay,
+            )  # 1e-5
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=milestones, gamma=lrate_decay
+            )
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.test_loader),
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+        
+
+    def _init_train(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(init_epoch))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                
+                loss = F.cross_entropy(logits, targets)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+                
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                # "Learning on {}-{}".format(self._known_classes, self._total_classes)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+
+            prog_bar.set_description(info)
+
+        logging.info(info)
+
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+
+        prog_bar = tqdm(range(epochs))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                fake_targets = targets - self._known_classes
+                loss_clf = F.cross_entropy(
+                    logits[:, self._known_classes :], fake_targets
+                )
+
+                loss = loss_clf
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+        logging.info(info)

models/foster.py

@@ -0,0 +1,445 @@
+import logging
+import numpy as np
+from tqdm import tqdm
+import torch
+from torch import nn
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from models.base import BaseLearner
+from utils.inc_net import FOSTERNet
+from utils.toolkit import count_parameters, target2onehot, tensor2numpy, count_parameters
+from torch.utils.tensorboard import SummaryWriter
+# Please refer to https://github.com/G-U-N/ECCV22-FOSTER for the full source code to reproduce foster.
+
+EPSILON = 1e-8
+
+
+class FOSTER(BaseLearner):
+    def __init__(self, args):
+        super().__init__(args)
+        self.args = args
+        self._network = FOSTERNet(args, False)
+        self._snet = None
+        self.beta1 = args["beta1"]
+        self.beta2 = args["beta2"]
+        self.per_cls_weights = None
+        self.is_teacher_wa = args["is_teacher_wa"]
+        self.is_student_wa = args["is_student_wa"]
+        self.lambda_okd = args["lambda_okd"]
+        self.wa_value = args["wa_value"]
+        self.oofc = args["oofc"].lower()
+        self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file']))
+
+    def after_task(self):
+        self._known_classes = self._total_classes
+        logging.info("Exemplar size: {}".format(self.exemplar_size))
+
+    def incremental_train(self, data_manager):
+        self.curr_acc = 0
+        self.data_manager = data_manager
+        self._cur_task += 1
+        if self._cur_task > 1:
+            self._network = self._snet
+        self._total_classes = self._known_classes + data_manager.get_task_size(
+            self._cur_task
+        )
+        self._network.update_fc(self._total_classes)
+        self._network_module_ptr = self._network
+        self._network.update_fc(self._total_classes)
+        logging.info(
+            "Learning on {}-{}".format(self._known_classes, self._total_classes)
+        )
+       
+        logging.debug("****MODEL ARCHITECTURE****")
+        logging.debug(self._network)
+
+        if self._cur_task > 0:
+            for p in self._network.convnets[0].parameters():
+                p.requires_grad = False
+            for p in self._network.oldfc.parameters():
+                p.requires_grad = False
+
+        logging.info("All params: {}".format(count_parameters(self._network)))
+        logging.info(
+            "Trainable params: {}".format(count_parameters(self._network, True))
+        )
+
+        train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source="train",
+            mode="train",
+            appendent=self._get_memory(),
+        )
+        self.train_loader = DataLoader(
+            train_dataset,
+            batch_size=self.args["batch_size"],
+            shuffle=True,
+            num_workers=self.args["num_workers"],
+            pin_memory=True,
+        )
+        test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), source="test", mode="test"
+        )
+        self.test_loader = DataLoader(
+            test_dataset,
+            batch_size=self.args["batch_size"],
+            shuffle=False,
+            num_workers=self.args["num_workers"],
+        )
+
+        inference_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), source="inference", mode="test"
+        )
+        self.inference_loader = DataLoader(
+            inference_dataset, batch_size=self.args["batch_size"], shuffle=False,
+            num_workers=self.args["num_workers"]
+        )
+
+
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+        self.build_rehearsal_memory(data_manager, self.samples_per_class)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+        if self._total_classes == data_manager.get_total_classnum():
+            self.writer.close()
+
+    def train(self):
+        self._network_module_ptr.train()
+        self._network_module_ptr.convnets[-1].train()
+        if self._cur_task >= 1:
+            self._network_module_ptr.convnets[0].eval()
+
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if hasattr(self._network, "module"):
+            self._network_module_ptr = self._network.module
+        if self._cur_task == 0:
+            optimizer = optim.SGD(
+                filter(lambda p: p.requires_grad, self._network.parameters()),
+                momentum=0.9,
+                lr=self.args["init_lr"],
+                weight_decay=self.args["init_weight_decay"],
+            )
+            scheduler = optim.lr_scheduler.CosineAnnealingLR(
+                optimizer=optimizer, T_max=self.args["init_epochs"]
+            )
+            self._init_train(train_loader, test_loader, optimizer, scheduler)
+        else:
+
+            cls_num_list = [self.samples_old_class] * self._known_classes + [
+                self.samples_new_class(i)
+                for i in range(self._known_classes, self._total_classes)
+            ]
+
+            effective_num = 1.0 - np.power(self.beta1, cls_num_list)
+            per_cls_weights = (1.0 - self.beta1) / np.array(effective_num)
+            per_cls_weights = (
+                per_cls_weights / np.sum(per_cls_weights) * len(cls_num_list)
+            )
+
+            logging.info("per cls weights : {}".format(per_cls_weights))
+            self.per_cls_weights = torch.FloatTensor(per_cls_weights).to(self._device)
+
+            optimizer = optim.SGD(
+                filter(lambda p: p.requires_grad, self._network.parameters()),
+                lr=self.args["lr"],
+                momentum=0.9,
+                weight_decay=self.args["weight_decay"],
+            )
+            scheduler = optim.lr_scheduler.CosineAnnealingLR(
+                optimizer=optimizer, T_max=self.args["boosting_epochs"]
+            )
+            if self.oofc == "az":
+                for i, p in enumerate(self._network_module_ptr.fc.parameters()):
+                    if i == 0:
+                        p.data[
+                            self._known_classes :, : self._network_module_ptr.out_dim
+                        ] = torch.tensor(0.0)
+            elif self.oofc != "ft":
+                assert 0, "not implemented"
+            self._feature_boosting(train_loader, test_loader, optimizer, scheduler)
+            if self.is_teacher_wa:
+                self._network_module_ptr.weight_align(
+                    self._known_classes,
+                    self._total_classes - self._known_classes,
+                    self.wa_value,
+                )
+            else:
+                logging.info("do not weight align teacher!")
+
+            cls_num_list = [self.samples_old_class] * self._known_classes + [
+                self.samples_new_class(i)
+                for i in range(self._known_classes, self._total_classes)
+            ]
+            effective_num = 1.0 - np.power(self.beta2, cls_num_list)
+            per_cls_weights = (1.0 - self.beta2) / np.array(effective_num)
+            per_cls_weights = (
+                per_cls_weights / np.sum(per_cls_weights) * len(cls_num_list)
+            )
+            logging.info("per cls weights : {}".format(per_cls_weights))
+            self.per_cls_weights = torch.FloatTensor(per_cls_weights).to(self._device)
+            self._feature_compression(train_loader, test_loader)
+        
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.inference_loader), 
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+        
+    def _init_train(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(self.args["init_epochs"]))
+        for _, epoch in enumerate(prog_bar):
+            self.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(
+                    self._device, non_blocking=True
+                ), targets.to(self._device, non_blocking=True)
+                logits = self._network(inputs)["logits"]
+                loss = F.cross_entropy(logits, targets)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    self.args["init_epochs"],
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Loss/train'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    self.args["init_epochs"],
+                    losses / len(train_loader),
+                    train_acc,
+                )
+
+            prog_bar.set_description(info)
+            logging.info(info)
+
+    def _feature_boosting(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(self.args["boosting_epochs"]))
+        for _, epoch in enumerate(prog_bar):
+            self.train()
+            losses = 0.0
+            losses_clf = 0.0
+            losses_fe = 0.0
+            losses_kd = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(
+                    self._device, non_blocking=True
+                ), targets.to(self._device, non_blocking=True)
+                outputs = self._network(inputs)
+                logits, fe_logits, old_logits = (
+                    outputs["logits"],
+                    outputs["fe_logits"],
+                    outputs["old_logits"].detach(),
+                )
+                loss_clf = F.cross_entropy(logits / self.per_cls_weights, targets)
+                loss_fe = F.cross_entropy(fe_logits, targets)
+                loss_kd = self.lambda_okd * _KD_loss(
+                    logits[:, : self._known_classes], old_logits, self.args["T"]
+                )
+                loss = loss_clf + loss_fe + loss_kd
+                optimizer.zero_grad()
+                loss.backward()
+                if self.oofc == "az":
+                    for i, p in enumerate(self._network_module_ptr.fc.parameters()):
+                        if i == 0:
+                            p.grad.data[
+                                self._known_classes :,
+                                : self._network_module_ptr.out_dim,
+                            ] = torch.tensor(0.0)
+                elif self.oofc != "ft":
+                    assert 0, "not implemented"
+                optimizer.step()
+                losses += loss.item()
+                losses_fe += loss_fe.item()
+                losses_clf += loss_clf.item()
+                losses_kd += (
+                    self._known_classes / self._total_classes
+                ) * loss_kd.item()
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_fe {:.3f}, Loss_kd {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    self.args["boosting_epochs"],
+                    losses / len(train_loader),
+                    losses_clf / len(train_loader),
+                    losses_fe / len(train_loader),
+                    losses_kd / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Loss/train'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_fe {:.3f}, Loss_kd {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    self.args["boosting_epochs"],
+                    losses / len(train_loader),
+                    losses_clf / len(train_loader),
+                    losses_fe / len(train_loader),
+                    losses_kd / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+            logging.info(info)
+
+    def _feature_compression(self, train_loader, test_loader):
+        self._snet = FOSTERNet(self.args, False)
+        self._snet.update_fc(self._total_classes)
+        if len(self._multiple_gpus) > 1:
+            self._snet = nn.DataParallel(self._snet, self._multiple_gpus)
+        if hasattr(self._snet, "module"):
+            self._snet_module_ptr = self._snet.module
+        else:
+            self._snet_module_ptr = self._snet
+        self._snet.to(self._device)
+        self._snet_module_ptr.convnets[0].load_state_dict(
+            self._network_module_ptr.convnets[0].state_dict()
+        )
+        self._snet_module_ptr.copy_fc(self._network_module_ptr.oldfc)
+        optimizer = optim.SGD(
+            filter(lambda p: p.requires_grad, self._snet.parameters()),
+            lr=self.args["lr"],
+            momentum=0.9,
+        )
+        scheduler = optim.lr_scheduler.CosineAnnealingLR(
+            optimizer=optimizer, T_max=self.args["compression_epochs"]
+        )
+        self._network.eval()
+        prog_bar = tqdm(range(self.args["compression_epochs"]))
+        for _, epoch in enumerate(prog_bar):
+            self._snet.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(
+                    self._device, non_blocking=True
+                ), targets.to(self._device, non_blocking=True)
+                dark_logits = self._snet(inputs)["logits"]
+                with torch.no_grad():
+                    outputs = self._network(inputs)
+                    logits, old_logits, fe_logits = (
+                        outputs["logits"],
+                        outputs["old_logits"],
+                        outputs["fe_logits"],
+                    )
+                loss_dark = self.BKD(dark_logits, logits, self.args["T"])
+                loss = loss_dark
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+                _, preds = torch.max(dark_logits[: targets.shape[0]], dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._snet, test_loader)
+                info = "SNet: Task {}, Epoch {}/{} => Loss {:.3f},  Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    self.args["compression_epochs"],
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Loss/train'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "SNet: Task {}, Epoch {}/{} => Loss {:.3f},  Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    self.args["compression_epochs"],
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+            logging.info(info)
+        if len(self._multiple_gpus) > 1:
+            self._snet = self._snet.module
+        if self.is_student_wa:
+            self._snet.weight_align(
+                self._known_classes,
+                self._total_classes - self._known_classes,
+                self.wa_value,
+            )
+        else:
+            logging.info("do not weight align student!")
+
+        self._snet.eval()
+        y_pred, y_true = [], []
+        for _, (_, inputs, targets) in enumerate(test_loader):
+            inputs = inputs.to(self._device, non_blocking=True)
+            with torch.no_grad():
+                outputs = self._snet(inputs)["logits"]
+            predicts = torch.topk(
+                outputs, k=self.topk, dim=1, largest=True, sorted=True
+            )[1]
+            y_pred.append(predicts.cpu().numpy())
+            y_true.append(targets.cpu().numpy())
+        y_pred = np.concatenate(y_pred)
+        y_true = np.concatenate(y_true)
+        cnn_accy = self._evaluate(y_pred, y_true)
+        logging.info("darknet eval: ")
+        logging.info("CNN top1 curve: {}".format(cnn_accy["top1"]))
+        logging.info("CNN top5 curve: {}".format(cnn_accy["top5"]))
+
+    @property
+    def samples_old_class(self):
+        if self._fixed_memory:
+            return self._memory_per_class
+        else:
+            assert self._total_classes != 0, "Total classes is 0"
+            return self._memory_size // self._known_classes
+
+    def samples_new_class(self, index):
+        if self.args["dataset"] == "cifar100":
+            return 500
+        else:
+            return self.data_manager.getlen(index)
+
+    def BKD(self, pred, soft, T):
+        pred = torch.log_softmax(pred / T, dim=1)
+        soft = torch.softmax(soft / T, dim=1)
+        soft = soft * self.per_cls_weights
+        soft = soft / soft.sum(1)[:, None]
+        return -1 * torch.mul(soft, pred).sum() / pred.shape[0]
+
+
+def _KD_loss(pred, soft, T):
+    pred = torch.log_softmax(pred / T, dim=1)
+    soft = torch.softmax(soft / T, dim=1)
+    return -1 * torch.mul(soft, pred).sum() / pred.shape[0]

models/icarl.py

@@ -0,0 +1,237 @@
+import logging
+import numpy as np
+from tqdm import tqdm
+import torch
+from torch import nn
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from models.base import BaseLearner
+from utils.inc_net import IncrementalNet
+from utils.inc_net import CosineIncrementalNet
+from utils.toolkit import target2onehot, tensor2numpy
+from torch.utils.tensorboard import SummaryWriter
+
+EPSILON = 1e-8
+
+init_epoch = 200
+init_lr = 0.1
+init_milestones = [60, 120, 170]
+init_lr_decay = 0.1
+init_weight_decay = 0.0005
+
+
+epochs = 200
+lrate = 0.1
+milestones = [80, 120]
+lrate_decay = 0.1
+batch_size = 128
+weight_decay = 2e-4
+num_workers = 2
+T = 2
+
+
+class iCaRL(BaseLearner):
+    def __init__(self, args):
+        super().__init__(args)
+        self._network = IncrementalNet(args, True)
+        self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file']))
+
+    def after_task(self):
+        self._old_network = self._network.copy().freeze()
+        self._known_classes = self._total_classes
+        logging.info("Exemplar size: {}".format(self.exemplar_size))
+
+    def incremental_train(self, data_manager):
+        self.curr_acc = 0
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(
+            self._cur_task
+        )
+        self._network.update_fc(self._total_classes)
+        logging.info(
+            "Learning on {}-{}".format(self._known_classes, self._total_classes)
+        )
+        logging.info(
+            "Known_classes: {}\tTotal_classes: {}\tcurrent_task: {}".format(self._known_classes, self._total_classes, self._cur_task)
+        )
+
+        _, tr_targets, train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source="train",
+            mode="train",
+            appendent=self._get_memory(),
+            ret_data=True
+        )
+        
+
+        self.train_loader = DataLoader(
+            train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers
+        )
+
+        _, te_targets, test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), 
+            source="test", 
+            mode="test",
+            ret_data=True
+        )
+        self.test_loader = DataLoader(
+            test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+
+        uq_te, count_te = np.unique(te_targets, return_counts=True)
+        uq_tr, count_tr = np.unique(tr_targets, return_counts=True)
+
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+        self.build_rehearsal_memory(data_manager, self.samples_per_class)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if self._old_network is not None:
+            self._old_network.to(self._device)
+
+        if self._cur_task == 0:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                momentum=0.9,
+                lr=init_lr,
+                weight_decay=init_weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=init_milestones, gamma=init_lr_decay
+            )
+            logging.info('## Initial Training ##')
+            self._init_train(train_loader, test_loader, optimizer, scheduler)
+
+        else:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                lr=lrate,
+                momentum=0.9,
+                weight_decay=weight_decay,
+            )  # 1e-5
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=milestones, gamma=lrate_decay
+            )
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.test_loader),
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+        
+
+    def _init_train(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(init_epoch))
+        for _, epoch in enumerate(prog_bar):
+            
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                loss = F.cross_entropy(logits, targets)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+
+            prog_bar.set_description(info)
+
+        logging.info(info)
+
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(epochs))
+        for _, epoch in enumerate(prog_bar):
+            
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                loss_clf = F.cross_entropy(logits, targets)
+                loss_kd = _KD_loss(
+                    logits[:, : self._known_classes],
+                    self._old_network(inputs)["logits"],
+                    T,
+                )
+
+                loss = loss_clf + loss_kd
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+        logging.info(info)
+
+
+def _KD_loss(pred, soft, T):
+    pred = torch.log_softmax(pred / T, dim=1)
+    soft = torch.softmax(soft / T, dim=1)
+    return -1 * torch.mul(soft, pred).sum() / pred.shape[0]

models/lwf.py

@@ -0,0 +1,222 @@
+import logging
+import numpy as np
+import torch
+from torch import nn
+from torch.serialization import load
+from tqdm import tqdm
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from utils.inc_net import IncrementalNet
+from models.base import BaseLearner
+from utils.toolkit import target2onehot, tensor2numpy
+from torch.utils.tensorboard import SummaryWriter
+
+init_epoch = 200
+init_lr = 0.1
+init_milestones = [60, 120, 160]
+init_lr_decay = 0.1
+init_weight_decay = 0.0005
+
+
+epochs = 200
+lrate = 0.1
+milestones = [60, 120, 180, 220]
+lrate_decay = 0.1
+batch_size = 32
+weight_decay = 2e-4
+num_workers = 2
+T = 2
+lamda = 3
+
+
+class LwF(BaseLearner):
+    def __init__(self, args):
+        super().__init__(args)
+        self._network = IncrementalNet(args, True)
+        self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file']))
+
+    def after_task(self):
+        self._old_network = self._network.copy().freeze()
+        self._known_classes = self._total_classes
+
+    def incremental_train(self, data_manager):
+        self.curr_acc = 0
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(
+            self._cur_task
+        )
+        self._network.update_fc(self._total_classes)
+        logging.info(
+            "Learning on {}-{}".format(self._known_classes, self._total_classes)
+        )
+        
+        train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source="train",
+            mode="train",
+        )
+        self.train_loader = DataLoader(
+            train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers
+        )
+        test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), source="test", mode="test"
+        )
+        self.test_loader = DataLoader(
+            test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+        if self._total_classes == data_manager.get_total_classnum():
+            self.writer.close()
+
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if self._old_network is not None:
+            self._old_network.to(self._device)
+
+        if self._cur_task == 0:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                momentum=0.9,
+                lr=init_lr,
+                weight_decay=init_weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=init_milestones, gamma=init_lr_decay
+            )
+            self._init_train(train_loader, test_loader, optimizer, scheduler)
+        else:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                lr=lrate,
+                momentum=0.9,
+                weight_decay=weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=milestones, gamma=lrate_decay
+            )
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.test_loader),
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+        
+
+    def _init_train(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(init_epoch))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                loss = F.cross_entropy(logits, targets)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+
+        logging.info(info)
+
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+
+        prog_bar = tqdm(range(epochs))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                fake_targets = targets - self._known_classes
+                loss_clf = F.cross_entropy(
+                    logits[:, self._known_classes :], fake_targets
+                )
+                loss_kd = _KD_loss(
+                    logits[:, : self._known_classes],
+                    self._old_network(inputs)["logits"],
+                    T,
+                )
+
+                loss = lamda * loss_kd + loss_clf
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                with torch.no_grad():
+                    _, preds = torch.max(logits, dim=1)
+                    correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                    total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+        logging.info(info)
+
+
+def _KD_loss(pred, soft, T):
+    pred = torch.log_softmax(pred / T, dim=1)
+    soft = torch.softmax(soft / T, dim=1)
+    return -1 * torch.mul(soft, pred).sum() / pred.shape[0]

models/memo.py

@@ -0,0 +1,386 @@
+import logging
+import numpy as np
+from tqdm import tqdm
+import torch
+from torch import nn
+import copy
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from models.base import BaseLearner
+from utils.inc_net import AdaptiveNet
+from utils.toolkit import count_parameters, target2onehot, tensor2numpy
+from torch.utils.tensorboard import SummaryWriter
+
+num_workers=2
+EPSILON = 1e-8
+batch_size = 64
+
+class MEMO(BaseLearner):
+
+    def __init__(self, args):
+        super().__init__(args)
+        self.args = args
+        self._old_base = None
+        self.args.update({'curr': self._cur_task})
+        self._network = AdaptiveNet(args, True)
+        logging.info(f'>>> train generalized blocks:{self.args["train_base"]} train_adaptive:{self.args["train_adaptive"]}')
+        self.writer = SummaryWriter(log_dir='DARCY-runs/{}'.format(args['summary_file']))
+
+
+    def after_task(self):
+        self._known_classes = self._total_classes
+        if self._cur_task == 0:
+            if self.args['train_base']:
+                logging.info("Train Generalized Blocks...")
+                self._network.TaskAgnosticExtractor.train()
+                for param in self._network.TaskAgnosticExtractor.parameters():
+                    param.requires_grad = True
+            else:
+                logging.info("Fix Generalized Blocks...")
+                self._network.TaskAgnosticExtractor.eval()
+                for param in self._network.TaskAgnosticExtractor.parameters():
+                    param.requires_grad = False
+        
+        logging.info('Exemplar size: {}'.format(self.exemplar_size))
+
+    def incremental_train(self, data_manager):
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(self._cur_task)
+        self.args.update({'curr': self._cur_task})
+        self._network.update_fc(self._total_classes)
+        logging.info("****MODEL ARCHITECTURE after fc update*****")
+        logging.info(self._network)
+        logging.info('Learning on {}-{}'.format(self._known_classes, self._total_classes))
+        logging.info(
+            "Known_classes: {}\tTotal_classes: {}\tcurrent_task: {}".format(self._known_classes, self._total_classes, self._cur_task)
+        )
+        if self._cur_task>0: # Freeze the network of the previous trained adaptive network (requires grad = False)
+            logging.info("self._curr_task {} and no of adaptiveExtractors {}".format(self._cur_task, len(self._network.AdaptiveExtractors)))
+            for i in range(self._cur_task):
+                for p in self._network.AdaptiveExtractors[i].parameters():
+                    if self.args['train_adaptive']:
+                        p.requires_grad = True
+                    else:
+                        p.requires_grad = False
+                    
+                if self.args["type"] == "avg":
+                    break
+
+        logging.debug('All params: {}'.format(count_parameters(self._network)))
+        logging.debug('Trainable params: {}'.format(count_parameters(self._network, True)))
+        _, tr_targets, train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source='train',
+            mode='train', 
+            appendent=self._get_memory(),
+            ret_data=True
+        )
+        self.train_loader = DataLoader(
+            train_dataset, 
+            batch_size=self.args["batch_size"], 
+            shuffle=True, 
+            num_workers=num_workers
+        )
+        
+        _, te_targets, test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), 
+            source='test', 
+            mode='test',
+            ret_data=True
+        )
+
+        self.test_loader = DataLoader(
+            test_dataset, 
+            batch_size=self.args["batch_size"],
+            shuffle=False, 
+            num_workers=num_workers
+        )
+
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+        self.build_rehearsal_memory(data_manager, self.samples_per_class)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+    
+    def set_network(self):
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+        self._network.train()                   #All status from eval to train
+        if self.args['train_base']:
+            self._network.TaskAgnosticExtractor.train()
+        else:
+            self._network.TaskAgnosticExtractor.eval()
+        
+        # set adaptive extractor's status
+        self._network.AdaptiveExtractors[-1].train()
+        if self._cur_task >= 1:
+            for i in range(self._cur_task):
+                if self.args['train_adaptive']:
+                    self._network.AdaptiveExtractors[i].train()
+                else:
+                    self._network.AdaptiveExtractors[i].eval()
+                if self.args["type"] == "avg":
+                    break
+            
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+            
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if self._cur_task==0:
+            logging.debug('## Initial Training ##')
+            optimizer = optim.SGD(
+                filter(lambda p: p.requires_grad, self._network.parameters()),
+                momentum=0.9,
+                lr=self.args["init_lr"],
+                weight_decay=self.args["init_weight_decay"]
+            )
+            if self.args['scheduler'] == 'steplr':
+                scheduler = optim.lr_scheduler.MultiStepLR(
+                    optimizer=optimizer, 
+                    milestones=self.args['init_milestones'], 
+                    gamma=self.args['init_lr_decay']
+                )
+            elif self.args['scheduler'] == 'cosine':
+                scheduler = optim.lr_scheduler.CosineAnnealingLR(
+                    optimizer=optimizer,
+                    T_max=self.args['init_epoch']
+                ) 
+            else:
+                raise NotImplementedError
+            
+            if not self.args['skip']:
+                self._init_train(train_loader, test_loader, optimizer, scheduler)
+            else:
+                if isinstance(self._network, nn.DataParallel):
+                    self._network = self._network.module
+                load_acc = self._network.load_checkpoint(self.args)
+                self._network.to(self._device)
+
+                if len(self._multiple_gpus) > 1:
+                    self._network = nn.DataParallel(self._network, self._multiple_gpus)
+                
+                cur_test_acc = self._compute_accuracy(self._network, self.test_loader)
+                logging.info(f"Loaded_Test_Acc:{load_acc} Cur_Test_Acc:{cur_test_acc}")
+        else:
+            optimizer = optim.SGD(
+                filter(lambda p: p.requires_grad, self._network.parameters()), 
+                lr=self.args['lrate'], 
+                momentum=0.9, 
+                weight_decay=self.args['weight_decay']
+            )
+            if self.args['scheduler'] == 'steplr':
+                scheduler = optim.lr_scheduler.MultiStepLR(
+                    optimizer=optimizer,
+                    milestones=self.args['milestones'], 
+                    gamma=self.args['lrate_decay']
+                )
+            elif self.args['scheduler'] == 'cosine':
+                assert self.args['t_max'] is not None
+                scheduler = optim.lr_scheduler.CosineAnnealingLR(
+                    optimizer=optimizer,
+                    T_max=self.args['t_max']
+                )
+            else:
+                raise NotImplementedError
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+            if len(self._multiple_gpus) > 1:
+                self._network.module.weight_align(self._total_classes-self._known_classes)
+            else:
+                self._network.weight_align(self._total_classes-self._known_classes)
+            
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.test_loader),
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+        
+    
+    def _test_model(self, test_loader, epoch):
+        self._network.eval()
+        losses = 0.
+        
+        for i, (_, inputs, targets) in enumerate(test_loader):
+            inputs, targets = inputs.to(self._device), targets.to(self._device)
+            outputs = self._network(inputs)
+            logits = outputs["logits"]
+            loss_clf = F.cross_entropy(logits, targets)
+            loss= loss_clf 
+            losses += loss.item()
+        self.writer.add_scalar('Task: {} on {}-{} -- test/Loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses / len(test_loader), epoch)
+        
+    def _init_train(self,train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(self.args["init_epoch"]))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)['logits']
+
+                loss=F.cross_entropy(logits,targets) 
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct)*100 / total, decimals=2)
+            if epoch%5==0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                self._test_model(test_loader=test_loader, epoch=epoch)
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}'.format(
+                self._cur_task, epoch+1, self.args['init_epoch'], losses/len(train_loader), train_acc, test_acc)
+                self.writer.add_scalar('Task: {} on {}-{} -- train/Loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        test_acc,  epoch)
+            else:
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}'.format(
+                self._cur_task,
+                epoch + 1,
+                self.args['init_epoch'],
+                losses/len(train_loader),
+                train_acc)
+            prog_bar.set_description(info)
+        logging.info(info)
+       
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(self.args["epochs"]))
+        for _, epoch in enumerate(prog_bar):
+            self.set_network()
+            losses = 0.
+            losses_clf=0.
+            losses_aux=0.
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+
+                outputs= self._network(inputs)
+                logits,aux_logits=outputs["logits"],outputs["aux_logits"]
+                loss_clf=F.cross_entropy(logits,targets)
+                aux_targets = targets.clone()
+                aux_targets=torch.where(aux_targets-self._known_classes+1>0,  aux_targets-self._known_classes+1,0)
+                loss_aux=F.cross_entropy(aux_logits,aux_targets)
+                loss=loss_clf+self.args['alpha_aux']*loss_aux
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+                losses_aux+=loss_aux.item()
+                losses_clf+=loss_clf.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct)*100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                self._test_model(test_loader=test_loader, epoch=epoch)
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux  {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}'.format(
+                self._cur_task, epoch+1, self.args["epochs"], losses/len(train_loader),losses_clf/len(train_loader),losses_aux/len(train_loader),train_acc, test_acc)
+                
+                self.writer.add_scalar('Task: {} on {}-{} -- train/Loss'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes),
+                                        train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes), 
+                                       test_acc,  epoch)
+            else:
+                info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux {:.3f}, Train_accy {:.2f}'.format(
+                self._cur_task, 
+                epoch + 1, 
+                self.args["epochs"], 
+                losses/len(train_loader), 
+                losses_clf/len(train_loader),
+                losses_aux/len(train_loader),
+                train_acc)
+                
+            prog_bar.set_description(info)
+        logging.info(info)
+      
+    def _construct_exemplar(self, data_manager, m):
+        logging.info("Constructing exemplars...({} per classes)".format(m))
+        for class_idx in range(self._known_classes, self._total_classes):
+            data, targets, idx_dataset = data_manager.get_dataset(
+                np.arange(class_idx, class_idx + 1),
+                source="train",
+                mode="test",
+                ret_data=True,
+            )
+            idx_loader = DataLoader(
+                idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(idx_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            class_mean = np.mean(vectors, axis=0)
+
+            # Select
+            selected_exemplars = []
+            exemplar_vectors = []  # [n, feature_dim]
+            for k in range(1, m + 1):
+                S = np.sum(
+                    exemplar_vectors, axis=0
+                )  # [feature_dim] sum of selected exemplars vectors
+                mu_p = (vectors + S) / k  # [n, feature_dim] sum to all vectors
+                i = np.argmin(np.sqrt(np.sum((class_mean - mu_p) ** 2, axis=1)))
+                selected_exemplars.append(
+                    np.array(data[i])
+                )  # New object to avoid passing by inference
+                exemplar_vectors.append(
+                    np.array(vectors[i])
+                )  # New object to avoid passing by inference
+
+                vectors = np.delete(
+                    vectors, i, axis=0
+                )  # Remove it to avoid duplicative selection
+                data = np.delete(
+                    data, i, axis=0
+                )  # Remove it to avoid duplicative selection
+                
+                if len(vectors) == 0:
+                    break
+            # uniques = np.unique(selected_exemplars, axis=0)
+            # print('Unique elements: {}'.format(len(uniques)))
+            selected_exemplars = np.array(selected_exemplars)
+            # exemplar_targets = np.full(m, class_idx)
+            exemplar_targets = np.full(selected_exemplars.shape[0], class_idx)
+            self._data_memory = (
+                np.concatenate((self._data_memory, selected_exemplars))
+                if len(self._data_memory) != 0
+                else selected_exemplars
+            )
+            self._targets_memory = (
+                np.concatenate((self._targets_memory, exemplar_targets))
+                if len(self._targets_memory) != 0
+                else exemplar_targets
+            )
+
+            # Exemplar mean
+            idx_dataset = data_manager.get_dataset(
+                [],
+                source="train",
+                mode="test",
+                appendent=(selected_exemplars, exemplar_targets),
+            )
+            idx_loader = DataLoader(
+                idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4
+            )
+            vectors, _ = self._extract_vectors(idx_loader)
+            vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T
+            mean = np.mean(vectors, axis=0)
+            mean = mean / np.linalg.norm(mean)
+
+            self._class_means[class_idx, :] = mean

models/replay.py

@@ -0,0 +1,213 @@
+import logging
+import numpy as np
+from tqdm import tqdm
+import torch
+from torch import nn
+from torch import optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from models.base import BaseLearner
+from utils.inc_net import IncrementalNet
+from utils.toolkit import target2onehot, tensor2numpy
+from torch.utils.tensorboard import SummaryWriter
+
+EPSILON = 1e-8
+
+
+init_epoch = 200
+init_lr = 0.1
+init_milestones = [60, 120, 170]
+init_lr_decay = 0.1
+init_weight_decay = 0.0005
+
+
+epochs = 200
+lrate = 0.1
+milestones = [30, 50]
+lrate_decay = 0.1
+batch_size = 128
+weight_decay = 2e-4
+num_workers = 2
+T = 2
+
+
+class Replay(BaseLearner):
+    def __init__(self, args):
+        super().__init__(args)
+        self._network = IncrementalNet(args, True)
+        self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file']))
+
+    def after_task(self):
+        self._known_classes = self._total_classes
+        logging.info("Exemplar size: {}".format(self.exemplar_size))
+
+    def incremental_train(self, data_manager):
+        self.curr_acc = 0
+        self._cur_task += 1
+        self._total_classes = self._known_classes + data_manager.get_task_size(
+            self._cur_task
+        )
+        
+        self._network.update_fc(self._total_classes)
+        logging.info(
+            "Learning on {}-{}".format(self._known_classes, self._total_classes)
+        )
+        logging.info(
+            "Known_classes: {}\tTotal_classes: {}\tcurrent_task: {}".format(self._known_classes, self._total_classes, self._cur_task)
+        )
+
+        # Loader
+        _, tr_targets, train_dataset = data_manager.get_dataset(
+            np.arange(self._known_classes, self._total_classes),
+            source="train",
+            mode="train",
+            appendent=self._get_memory(),
+            ret_data=True
+        )
+        self.train_loader = DataLoader(
+            train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers
+        )
+        _, te_targets, test_dataset = data_manager.get_dataset(
+            np.arange(0, self._total_classes), source="test", mode="test", ret_data=True
+        )
+        self.test_loader = DataLoader(
+            test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+
+        # Procedure
+        if len(self._multiple_gpus) > 1:
+            self._network = nn.DataParallel(self._network, self._multiple_gpus)
+        self._train(self.train_loader, self.test_loader)
+
+        self.build_rehearsal_memory(data_manager, self.samples_per_class)
+        if len(self._multiple_gpus) > 1:
+            self._network = self._network.module
+
+    def _train(self, train_loader, test_loader):
+        self._network.to(self._device)
+        if self._cur_task == 0:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                momentum=0.9,
+                lr=init_lr,
+                weight_decay=init_weight_decay,
+            )
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=init_milestones, gamma=init_lr_decay
+            )
+            logging.info('## Initial Training ##')
+            self._init_train(train_loader, test_loader, optimizer, scheduler)
+        else:
+            optimizer = optim.SGD(
+                self._network.parameters(),
+                lr=lrate,
+                momentum=0.9,
+                weight_decay=weight_decay,
+            )  # 1e-5
+            scheduler = optim.lr_scheduler.MultiStepLR(
+                optimizer=optimizer, milestones=milestones, gamma=lrate_decay
+            )
+            self._update_representation(train_loader, test_loader, optimizer, scheduler)
+        
+        self.writer.add_figure("Confusion matrix", 
+                               self._createConfusionMatrix(self._network, self.test_loader),
+                               self._cur_task)
+        self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task)
+
+    def _init_train(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(init_epoch))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                loss = F.cross_entropy(logits, targets)
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    init_epoch,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+
+            prog_bar.set_description(info)
+
+        logging.info(info)
+
+    def _update_representation(self, train_loader, test_loader, optimizer, scheduler):
+        prog_bar = tqdm(range(epochs))
+        for _, epoch in enumerate(prog_bar):
+            self._network.train()
+            losses = 0.0
+            correct, total = 0, 0
+            for i, (_, inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(self._device), targets.to(self._device)
+                logits = self._network(inputs)["logits"]
+
+                loss_clf = F.cross_entropy(logits, targets)
+                loss = loss_clf
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                losses += loss.item()
+
+                # acc
+                _, preds = torch.max(logits, dim=1)
+                correct += preds.eq(targets.expand_as(preds)).cpu().sum()
+                total += len(targets)
+
+            scheduler.step()
+            train_acc = np.around(tensor2numpy(correct) * 100 / total, decimals=2)
+            if epoch % 5 == 0:
+                test_acc = self._compute_accuracy(self._network, test_loader)
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                    test_acc,
+                )
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Train/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), train_acc,  epoch)
+                self.writer.add_scalar('Task: {} on {}-{} -- Test/Accuracy'.format(self._cur_task, self._known_classes, self._total_classes), test_acc,  epoch)
+            else:
+                info = "Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}".format(
+                    self._cur_task,
+                    epoch + 1,
+                    epochs,
+                    losses / len(train_loader),
+                    train_acc,
+                )
+            prog_bar.set_description(info)
+        logging.info(info)

trainer.py

@@ -0,0 +1,149 @@
+import sys
+import logging
+import copy
+import torch
+from utils import factory
+from utils.data_manager import DataManager
+from utils.toolkit import count_parameters
+import os
+
+
+def train(args):
+    """
+    Entry point for training the model.
+    
+    Args:
+        args (dict): Configuration arguments including model settings, dataset info, device, seed list, etc.
+    """
+    seed_list = copy.deepcopy(args["seed"])
+    device = copy.deepcopy(args["device"])
+
+    for seed in seed_list:
+        args["seed"] = seed
+        args["device"] = device
+        _train(args)
+
+
+def _train(args):
+    
+    """
+    Main training function to handle incremental learning across tasks.
+
+    Args:
+        args (dict): Configuration arguments including model settings, dataset info, etc.
+    """
+    # Initialize class counter
+    init_cls = 0 if args ["init_cls"] == args["increment"] else args["init_cls"]
+    logs_name = "logs/{}/{}".format(args["model_name"],args["dataset"])
+    
+    if not os.path.exists(logs_name):
+        os.makedirs(logs_name)
+
+    if not os.path.exists("predictions"):
+        os.makedirs("predictions")
+
+    logfilename = "logs/{}/{}/{}_{}_{}".format(
+        args["model_name"],
+        args["dataset"],
+        args["convnet_type"],
+        args["seed"],
+        args["summary_file"]
+    )
+    logging.basicConfig(
+        level=logging.INFO,
+        format="[%(asctime)s: %(filename)s: %(lineno)d: %(funcName)s]=> %(message)s",
+        handlers=[
+            logging.FileHandler(filename=logfilename + ".log", mode="w"),
+            logging.StreamHandler(sys.stdout),
+        ],
+    )
+
+    _set_random()
+    _set_device(args)
+
+    # Initialize data manager for handling datasets
+    data_manager = DataManager(
+        args["dataset"],
+        args["shuffle"],
+        args["seed"],
+        args["init_cls"],
+        args["increment"],
+    )
+    model = factory.get_model(args["model_name"], args)
+
+    # Initialize accuracy tracking variables
+    cnn_curve, nme_curve = {"top1": [], "top3": []}, {"top1": [], "top3": []}
+
+    logging.info("nb_tasks: {}".format(data_manager.nb_tasks))
+    for task in range(data_manager.nb_tasks):
+        
+        model.incremental_train(data_manager)
+        cnn_accy, nme_accy = model.eval_task()
+        model.after_task()
+
+        if nme_accy is not None:
+            logging.info("CNN: {}".format(cnn_accy["grouped"]))
+            logging.info("NME: {}".format(nme_accy["grouped"]))
+
+            cnn_curve["top1"].append(cnn_accy["top1"])
+            cnn_curve["top3"].append(cnn_accy["top3"])
+
+            nme_curve["top1"].append(nme_accy["top1"])
+            nme_curve["top3"].append(nme_accy["top3"])
+
+            logging.info("CNN top1 curve: {}".format(cnn_curve["top1"]))
+            logging.info("CNN top3 curve: {}".format(cnn_curve["top3"]))
+            logging.info("NME top1 curve: {}".format(nme_curve["top1"]))
+            logging.info("NME top3 curve: {}\n".format(nme_curve["top3"]))
+
+            print('Average Accuracy (CNN):', sum(cnn_curve["top1"])/len(cnn_curve["top1"]))
+            print('Average Accuracy (NME):', sum(nme_curve["top1"])/len(nme_curve["top1"]))
+
+            logging.info("Average Accuracy (CNN): {}".format(sum(cnn_curve["top1"])/len(cnn_curve["top1"])))
+            logging.info("Average Accuracy (NME): {}".format(sum(nme_curve["top1"])/len(nme_curve["top1"])))
+        else:
+            logging.info("No NME accuracy.")
+            logging.info("CNN: {}".format(cnn_accy["grouped"]))
+
+            cnn_curve["top1"].append(cnn_accy["top1"])
+            cnn_curve["top3"].append(cnn_accy["top3"])
+
+            logging.info("CNN top1 curve: {}".format(cnn_curve["top1"]))
+            logging.info("CNN top3 curve: {}\n".format(cnn_curve["top3"]))
+
+            print('Average Accuracy (CNN):', sum(cnn_curve["top1"])/len(cnn_curve["top1"]))
+            logging.info("Average Accuracy (CNN): {}".format(sum(cnn_curve["top1"])/len(cnn_curve["top1"])))
+
+    
+def _set_device(args):
+    """
+    Configure device settings for the model (CPU or GPU).
+
+    Args:
+        args (dict): Configuration arguments including device settings.
+    """
+    device_type = args["device"]
+    gpus = []
+
+    for device in device_type:
+        if device_type == -1:
+            device = torch.device("cpu")
+        else:
+            device = torch.device("cuda:{}".format(device))
+
+        gpus.append(device)
+
+    args["device"] = gpus
+
+
+def _set_random():
+    torch.manual_seed(1)
+    torch.cuda.manual_seed(1)
+    torch.cuda.manual_seed_all(1)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def print_args(args):
+    for key, value in args.items():
+        logging.info("{}: {}".format(key, value))

utils/augmentation.py

@@ -0,0 +1,122 @@
+"""
+image_augmentation.py
+
+This script performs data augmentation on images using various transformations such as color jitter,
+Gaussian blur, sharpness adjustment, horizontal flip, and vertical flip. 
+It generates augmented images from an existing dataset and saves them to new folders.
+
+"""
+
+from PIL import Image
+import os
+from torchvision.utils import save_image
+import torchvision.transforms as tvts
+import random
+
+# List of transformations for data augmentation
+transforms=[tvts.ColorJitter(brightness=.5, hue=.3),
+            tvts.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5.)),
+            tvts.RandomAdjustSharpness(sharpness_factor=2),
+            tvts.RandomHorizontalFlip(p=0.5),
+            tvts.RandomVerticalFlip(p=0.5)]
+
+def select_random_imgs(img_list, count):
+    """
+    Selects a random subset of images from a list.
+
+    Parameters:
+        img_list (list): List of image filenames.
+        count (int): Number of images to select.
+
+    Returns:
+        list: Randomly selected image filenames.
+    """
+    return random.sample(img_list, count)
+
+def create_foldername(fname):
+    """
+    Creates a new folder name for augmented images.
+
+    Parameters:
+        fname (str): Original folder name.
+
+    Returns:
+        str: Augmented folder name.
+    """
+    names = fname.split("_")
+    names.insert(2, "augment")
+    return "_".join(names)
+
+def save_original_imgs(source_fname, dest_fname, img_files):
+    """
+    Saves original images to the destination folder.
+
+    Parameters:
+        source_fname (str): Source folder name.
+        dest_fname (str): Destination folder name.
+        img_files (list): List of image filenames.
+    """
+    for img in img_files:
+        img_name = img.split(".")[0]
+        img = open_PILimg(path=os.path.join(source_fname, img))
+        save_image(tvts.ToTensor()(img), os.path.join(dest_fname, "{}.jpg".format(img_name)))
+
+def open_PILimg(path):
+    """
+    Opens an image file using PIL.
+
+    Parameters:
+        path (str): File path to the image.
+
+    Returns:
+        PIL.Image.Image: PIL image object.
+    """
+    return Image.open(path).convert("RGB")
+    
+def augment_folder(root_fname, fname, augment_count=25):
+    """
+    Augments images in a folder and saves the augmented images to a new folder.
+
+    Parameters:
+        root_fname (str): Root folder containing the source images.
+        fname (str): Name of the folder containing the source images.
+        augment_count (int): Number of augmented images to generate for each original image.
+    """
+    onlyfiles = os.listdir(os.path.join(root_fname, fname))
+    print(f'Befor augmentation, number of images: {len(onlyfiles)}')
+    random_imgs = select_random_imgs(onlyfiles, len(onlyfiles))
+    augment_fname = create_foldername(root_fname)
+    if not os.path.exists(augment_fname):
+        os.mkdir(augment_fname)
+    
+    save_fname = os.path.join(augment_fname, fname)
+
+    if not os.path.exists(save_fname):
+        os.mkdir(save_fname)
+
+    save_original_imgs(source_fname=os.path.join(root_fname, fname), 
+                       dest_fname=os.path.join(augment_fname, fname), 
+                       img_files=onlyfiles)
+
+    for img in random_imgs:
+        img_name = img.split(".")[0]
+        img = open_PILimg(path=os.path.join(root_fname, fname, img))
+        
+        for transform in transforms:
+            transname = transform.__class__.__name__
+            transformed_imgs = [transform(img) for _ in range(augment_count)]
+            for i, trans_img in enumerate(transformed_imgs):
+                save_image(tvts.ToTensor()(trans_img), os.path.join(save_fname, "trans_img_{}_{}_{}.jpg".format(img_name, transname, i)))
+
+    print(f"After augmentation, number of images: {len(os.listdir(save_fname))}")
+    
+
+if __name__ == "__main__":
+    # Example usage
+    root_folder = [["GNSS/Train"]]
+    for root in root_folder:
+        folders = [f for f in os.listdir(root) if os.path.isdir(os.path.join(root, f))]
+        for folder in folders:
+            augment_folder(root, folder)
+
+

utils/bayesian_weighting.py

@@ -0,0 +1,34 @@
+import torch
+import torch.nn as nn
+
+class AutomaticWeightedLoss(nn.Module):
+    """
+    Automatically weighted multi-task loss module.
+
+    This module automatically weights multiple loss functions based on their individual magnitudes.
+
+    Params:
+        num (int): The number of loss functions.
+    
+    """
+    def __init__(self, num=2):
+        super(AutomaticWeightedLoss, self).__init__()
+        params = torch.ones(num, requires_grad=True)
+        self.params = torch.nn.Parameter(params)
+
+    def forward(self, *x):
+        """
+        Forward pass through the AutomaticWeightedLoss module.
+
+        Parameters:
+            *x (Tensor): Variable number of loss functions.
+
+        Returns:
+            Tensor: Weighted sum of the loss functions.
+        """
+        loss_sum = 0
+        for i, loss in enumerate(x):
+            loss_sum += 0.5 / (self.params[i] ** 2) * loss + torch.log(1 + self.params[i] ** 2)
+        return loss_sum
+
+

utils/cluster_analysis.py

@@ -0,0 +1,27 @@
+from sklearn.metrics import davies_bouldin_score as dbs
+from sklearn.metrics import calinski_harabasz_score as chs
+
+def cluster_analysis(embeddings, predicted_labels, task_no):
+    """
+    Calculate clustering quality metrics for the provided embeddings and labels.
+
+    Args:
+        embeddings (np.ndarray): The embeddings (n_samples, n_features) to be clustered.
+        predicted_labels (np.ndarray): The predicted cluster labels (n_samples,) for the embeddings.
+
+    Returns:
+        tuple: A tuple containing:
+            - Davies-Bouldin Score
+            - Calinski-Harabasz Score
+            - Silhouette Score (if more than 1 cluster exists)
+    """
+
+    if len(embeddings) != len(predicted_labels):
+        raise ValueError("Embeddings and predicted labels must have the same length.")
+    
+    # Calculating cluster analysis scores
+    dbs_score = dbs(X=embeddings, labels=predicted_labels)
+    chs_score = chs(X=embeddings, labels=predicted_labels)
+    return dbs_score, chs_score
+
+

utils/contrastive_loss.py

@@ -0,0 +1,98 @@
+"""
+DMLLossCosine.py
+
+This module implements a custom PyTorch loss function called DMLLossCosine.
+
+Usage:
+- Create an instance of DMLLossCosine.
+- Call the instance with embeddings and target tensors to compute the loss.
+
+"""
+
+import torch
+import numpy as np
+import pandas as pd
+from torch import nn, optim
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+import matplotlib.pyplot as plt
+import torchvision
+from tqdm.notebook import tqdm
+import logging
+import random
+
+class DMLLossCosine(nn.Module):
+    """
+    DMLLossCosine - Deep Metric Learning Loss using Cosine Similarity.
+    
+    This loss function measures the cosine similarity between embeddings and
+    computes the Mean Squared Error (MSE) loss with the target distances.
+
+    Attributes:
+        similarity (nn.CosineSimilarity): Cosine similarity module.
+
+    Methods:
+        forward: Computes the forward pass of the loss function.
+        embeddings_distance_pairs: Computes pairs of embeddings and their distances.
+
+    """
+    def __init__(self):
+        super(DMLLossCosine, self).__init__()
+        self.similarity = nn.CosineSimilarity(dim=-1, eps=1e-7) 
+        
+    def forward(self, embeddings, target):
+        """
+        Computes the forward pass of the loss function.
+
+        Parameters:
+            embeddings (torch.Tensor): Input embeddings tensor.
+            target (torch.Tensor): Target tensor.
+
+        Returns:
+            loss (torch.Tensor): Computed loss.
+
+        """
+        first, second, distance = self.embeddings_distance_pairs(embeddings=embeddings, target=target)
+        distance = distance.to("cuda")
+        score = self.similarity(first, second)
+        return nn.MSELoss()(score, distance)
+    
+    def embeddings_distance_pairs(self, embeddings, target):
+        """
+        Computes pairs of embeddings and their distances.
+
+        Parameters:
+            embeddings (torch.Tensor): Input embeddings tensor.
+            target (torch.Tensor): Target tensor.
+
+        Returns:
+            first (torch.Tensor): First tensor containing embeddings.
+            second (torch.Tensor): Second tensor containing embeddings.
+            distance (torch.Tensor): Tensor containing distances.
+
+        """
+        distance = []
+        first = []
+        second = []
+        for i, val1 in enumerate(target):
+            for j, val2 in enumerate(target[i:]):
+                if val1 == val2:
+                    distance.append(torch.tensor(1.))
+                else:
+                    distance.append(torch.tensor(0.))   
+                first.append(embeddings[i])
+                second.append(embeddings[i+j])
+
+        return torch.stack(first), torch.stack(second), torch.stack(distance)
+    
+    
+
+    
+    
+    
+
+    
+    
+
+
+

utils/data.py

@@ -0,0 +1,202 @@
+import numpy as np
+from torchvision import datasets, transforms
+from utils.toolkit import split_images_labels
+from torchvision.datasets import VisionDataset
+from torch.utils.data import Dataset, DataLoader, random_split
+from typing import Any, Callable, cast, Dict, List, Optional, Tuple, Union
+from typing import Any
+import os
+from PIL import Image 
+import logging
+import torch
+
+class iData(object):
+    train_trsf = []
+    test_trsf = []
+    common_trsf = []
+    class_order = None
+
+
+class iCIFAR10(iData):
+    use_path = False
+    train_trsf = [
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(p=0.5),
+        transforms.ColorJitter(brightness=63 / 255),
+        transforms.ToTensor(),
+    ]
+    test_trsf = [transforms.ToTensor()]
+    common_trsf = [
+        transforms.Normalize(
+            mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)
+        ),
+    ]
+
+    class_order = np.arange(10).tolist()
+
+    def download_data(self):
+        train_dataset = datasets.cifar.CIFAR10("./data", train=True, download=True)
+        test_dataset = datasets.cifar.CIFAR10("./data", train=False, download=True)
+        self.train_data, self.train_targets = train_dataset.data, np.array(
+            train_dataset.targets
+        )
+        self.test_data, self.test_targets = test_dataset.data, np.array(
+            test_dataset.targets
+        )
+
+
+class iCIFAR100(iData):
+    use_path = False
+    train_trsf = [
+        
+        transforms.RandomCrop(32, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.ColorJitter(brightness=63 / 255),
+        transforms.ToTensor()
+    ]
+    test_trsf = [transforms.ToTensor()]
+    common_trsf = [
+        transforms.Normalize(
+            mean=(0.5071, 0.4867, 0.4408), std=(0.2675, 0.2565, 0.2761)
+        ),
+    ]
+
+    class_order = np.arange(100).tolist()
+
+    def download_data(self):
+        train_dataset = datasets.cifar.CIFAR100("./data", train=True, download=True)
+        test_dataset = datasets.cifar.CIFAR100("./data", train=False, download=True)
+        
+        '''print(type(train_dataset))
+        print(type(test_dataset))
+        print('type of each pair of data', type(train_dataset[0]))
+        print(train_dataset.data[0].shape)
+        print(train_dataset.targets[0])'''
+    
+        
+        
+        self.train_data, self.train_targets = train_dataset.data, np.array(
+            train_dataset.targets
+        )
+        self.test_data, self.test_targets = test_dataset.data, np.array(
+            test_dataset.targets
+        )
+
+
+class iImageNet1000(iData):
+    use_path = True
+    train_trsf = [
+        transforms.RandomResizedCrop(224),
+        transforms.RandomHorizontalFlip(),
+        transforms.ColorJitter(brightness=63 / 255),
+    ]
+    test_trsf = [
+        transforms.Resize(256),
+        transforms.CenterCrop(224),
+    ]
+    common_trsf = [
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+
+    class_order = np.arange(1000).tolist()
+
+    def download_data(self):
+        assert 0, "You should specify the folder of your dataset"
+        train_dir = "[DATA-PATH]/train/"
+        test_dir = "[DATA-PATH]/val/"
+
+        train_dset = datasets.ImageFolder(train_dir)
+        test_dset = datasets.ImageFolder(test_dir)
+
+        self.train_data, self.train_targets = split_images_labels(train_dset.imgs)
+        self.test_data, self.test_targets = split_images_labels(test_dset.imgs)
+
+
+class iImageNet100(iData):
+    use_path = True
+    train_trsf = [
+        transforms.RandomResizedCrop(224),
+        transforms.RandomHorizontalFlip(),
+    ]
+    test_trsf = [
+        transforms.Resize(256),
+        transforms.CenterCrop(224),
+    ]
+    common_trsf = [
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+
+    class_order = np.arange(1000).tolist()
+
+    def download_data(self):
+        assert 0, "You should specify the folder of your dataset"
+        train_dir = "[DATA-PATH]/train/"
+        test_dir = "[DATA-PATH]/val/"
+
+        train_dset = datasets.ImageFolder(train_dir)
+        test_dset = datasets.ImageFolder(test_dir)
+
+        self.train_data, self.train_targets = split_images_labels(train_dset.imgs)
+        self.test_data, self.test_targets = split_images_labels(test_dset.imgs)
+    
+
+class iData(object):
+    train_trsf = []
+    test_trsf = []
+    common_trsf = []
+    class_order = None
+
+
+        
+def split_images_labels(imgs):
+    images = []
+    labels = []
+    for item in imgs:
+        images.append(item[0])
+        labels.append(item[1])
+
+    return np.array(images), np.array(labels)
+
+
+class CustomImageFolder(datasets.ImageFolder):
+    def find_classes(self, directory: str) -> Tuple[List[str], Dict[str, int]]:
+        classes = sorted(entry.name for entry in os.scandir(directory) if entry.is_dir())
+        if not classes:
+            raise FileNotFoundError(f"Couldn't find any class folder in {directory}.")
+        class_to_idx = dict()
+        for i, cls_name in enumerate(classes):
+            if int(cls_name) > 5:
+                class_to_idx[cls_name] = int(cls_name) - 1
+            else:
+                class_to_idx[cls_name] = int(cls_name)
+        return classes, class_to_idx
+
+class GNSS(iData):
+    use_path = True
+    
+    common_trsf = [
+        transforms.ToTensor()
+    ]
+
+    class_order = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    def download_data(self):
+        
+        train_dir = "./Dataset/GNSS/Train/"
+        test_dir = "./Dataset/GNSS/Test/"
+        
+        train_dset = CustomImageFolder(train_dir)
+        test_dset = CustomImageFolder(test_dir)
+        
+        self.train_data, self.train_targets = split_images_labels(train_dset.imgs)
+        self.test_data, self.test_targets = split_images_labels(test_dset.imgs)
+        
+
+if __name__ == "__main__":
+    obj = GNSS()
+    obj.download_data()
+    
+
+    

utils/data_manager.py

@@ -0,0 +1,324 @@
+import logging
+import numpy as np
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+from utils.data import iCIFAR10, iCIFAR100, iImageNet100, iImageNet1000, GNSS
+from tqdm import tqdm
+import os
+import torch
+
+class DataManager(object):
+    def __init__(self, dataset_name, shuffle, seed, init_cls, increment):
+        self.dataset_name = dataset_name
+        self._setup_data(dataset_name, shuffle, seed)
+        assert init_cls <= len(self._class_order), "No enough classes."
+        self._increments = [init_cls]
+        while sum(self._increments) + increment < len(self._class_order):
+            self._increments.append(increment)
+        offset = len(self._class_order) - sum(self._increments)
+        if offset > 0:
+            self._increments.append(offset)
+        
+    @property
+    def nb_tasks(self):
+        return len(self._increments)
+
+    def get_task_size(self, task):
+        return self._increments[task]
+    
+    def get_accumulate_tasksize(self,task):
+        return sum(self._increments[:task+1])
+    
+    def get_total_classnum(self):
+        return len(self._class_order)
+
+    def get_dataset(
+        self, indices, source, mode, appendent=None, ret_data=False, m_rate=None, dataset_type="normal"):
+        if source == "train":
+            x, y = self._train_data, self._train_targets
+        elif source == "test":
+            x, y = self._test_data, self._test_targets
+        else:
+            raise ValueError("Unknown data source {}.".format(source))
+
+        if mode == "train":
+            trsf = transforms.Compose([*self._train_trsf, *self._common_trsf])
+        elif mode == "flip":
+            trsf = transforms.Compose(
+                [
+                    *self._test_trsf,
+                    transforms.RandomHorizontalFlip(p=1.0),
+                    *self._common_trsf,
+                ]
+            )
+        elif mode == "test":
+            trsf = transforms.Compose([*self._test_trsf, *self._common_trsf])
+        else:
+            raise ValueError("Unknown mode {}.".format(mode))
+
+        data, targets = [], []
+        for idx in indices:
+            if m_rate is None:
+                class_data, class_targets = self._select(
+                    x, y, low_range=idx, high_range=idx + 1
+                )
+            else:
+                class_data, class_targets = self._select_rmm(
+                    x, y, low_range=idx, high_range=idx + 1, m_rate=m_rate
+                )
+            data.append(class_data)
+            targets.append(class_targets)
+
+        if appendent is not None and len(appendent) != 0:
+            appendent_data, appendent_targets = appendent
+            data.append(appendent_data)
+            targets.append(appendent_targets)
+
+        data, targets = np.concatenate(data), np.concatenate(targets)
+
+  
+        if ret_data:
+            return data, targets, DummyDataset(data, targets, trsf, self.use_path, self.dataset_name)
+        else:
+            return DummyDataset(data, targets, trsf, self.use_path, self.dataset_name)
+
+        
+    def get_finetune_dataset(self,known_classes,total_classes,source,mode,appendent,type="ratio"):
+        if source == 'train':
+            x, y = self._train_data, self._train_targets
+        elif source == 'test':
+            x, y = self._test_data, self._test_targets
+        else:
+            raise ValueError('Unknown data source {}.'.format(source))
+
+        if mode == 'train':
+            trsf = transforms.Compose([*self._train_trsf, *self._common_trsf])
+        elif mode == 'test':
+            trsf = transforms.Compose([*self._test_trsf, *self._common_trsf])
+        else:
+            raise ValueError('Unknown mode {}.'.format(mode))
+        val_data = []
+        val_targets = []
+
+        old_num_tot = 0
+        appendent_data, appendent_targets = appendent
+
+        for idx in range(0, known_classes):
+            append_data, append_targets = self._select(appendent_data, appendent_targets,
+                                                       low_range=idx, high_range=idx+1)
+            num=len(append_data)
+            if num == 0:
+                continue
+            old_num_tot += num
+            val_data.append(append_data)
+            val_targets.append(append_targets)
+        if type == "ratio":
+            new_num_tot = int(old_num_tot*(total_classes-known_classes)/known_classes)
+        elif type == "same":
+            new_num_tot = old_num_tot
+        else:
+            assert 0, "not implemented yet"
+        new_num_average = int(new_num_tot/(total_classes-known_classes))
+        for idx in range(known_classes,total_classes):
+            class_data, class_targets = self._select(x, y, low_range=idx, high_range=idx+1)
+            val_indx = np.random.choice(len(class_data),new_num_average, replace=False)
+            val_data.append(class_data[val_indx])
+            val_targets.append(class_targets[val_indx])
+        val_data=np.concatenate(val_data)
+        val_targets = np.concatenate(val_targets)
+        return DummyDataset(val_data, val_targets, trsf, self.use_path)
+
+    def get_dataset_with_split(
+        self, indices, source, mode, appendent=None, val_samples_per_class=0
+    ):
+        if source == "train":
+            x, y = self._train_data, self._train_targets
+        elif source == "test":
+            x, y = self._test_data, self._test_targets
+        else:
+            raise ValueError("Unknown data source {}.".format(source))
+
+        if mode == "train":
+            trsf = transforms.Compose([*self._train_trsf, *self._common_trsf])
+        elif mode == "test":
+            trsf = transforms.Compose([*self._test_trsf, *self._common_trsf])
+        else:
+            raise ValueError("Unknown mode {}.".format(mode))
+
+        train_data, train_targets = [], []
+        val_data, val_targets = [], []
+        for idx in indices:
+            class_data, class_targets = self._select(
+                x, y, low_range=idx, high_range=idx + 1
+            )
+            val_indx = np.random.choice(
+                len(class_data), val_samples_per_class, replace=False
+            )
+            train_indx = list(set(np.arange(len(class_data))) - set(val_indx))
+            val_data.append(class_data[val_indx])
+            val_targets.append(class_targets[val_indx])
+            train_data.append(class_data[train_indx])
+            train_targets.append(class_targets[train_indx])
+
+        if appendent is not None:
+            appendent_data, appendent_targets = appendent
+            for idx in range(0, int(np.max(appendent_targets)) + 1):
+                append_data, append_targets = self._select(
+                    appendent_data, appendent_targets, low_range=idx, high_range=idx + 1
+                )
+                val_indx = np.random.choice(
+                    len(append_data), val_samples_per_class, replace=False
+                )
+                train_indx = list(set(np.arange(len(append_data))) - set(val_indx))
+                val_data.append(append_data[val_indx])
+                val_targets.append(append_targets[val_indx])
+                train_data.append(append_data[train_indx])
+                train_targets.append(append_targets[train_indx])
+
+        train_data, train_targets = np.concatenate(train_data), np.concatenate(
+            train_targets
+        )
+        val_data, val_targets = np.concatenate(val_data), np.concatenate(val_targets)
+
+        return DummyDataset(
+            train_data, train_targets, trsf, self.use_path
+        ), DummyDataset(val_data, val_targets, trsf, self.use_path)
+
+    def _setup_data(self, dataset_name, shuffle, seed):
+        idata = _get_idata(dataset_name)
+        idata.download_data()
+        shuffle = False
+        # Data
+        self._train_data, self._train_targets = idata.train_data, idata.train_targets        
+        self._test_data, self._test_targets = idata.test_data, idata.test_targets
+        self.use_path = idata.use_path
+
+        # Transforms
+        self._train_trsf = idata.train_trsf
+        self._test_trsf = idata.test_trsf
+        self._common_trsf = idata.common_trsf
+
+        # Order
+        order = [i for i in range(len(np.unique(self._train_targets)))]
+
+        if shuffle:
+            np.random.seed(seed)
+            order = np.random.permutation(len(order)).tolist()
+        else:
+            order = idata.class_order
+        self._class_order = order
+        # Map indices
+        
+        self._train_targets = _map_new_class_index(self._train_targets, self._class_order)
+        self._test_targets = _map_new_class_index(self._test_targets, self._class_order)
+
+    def _select(self, x, y, low_range, high_range):
+        idxes = np.where(np.logical_and(y >= low_range, y < high_range))[0]
+        
+        if isinstance(x,np.ndarray):
+            x_return = x[idxes]
+        else:
+            x_return = []
+            for id in idxes:
+                x_return.append(x[id])
+        return x_return, y[idxes]
+
+    def _select_rmm(self, x, y, low_range, high_range, m_rate):
+        assert m_rate is not None
+        if m_rate != 0:
+            idxes = np.where(np.logical_and(y >= low_range, y < high_range))[0]
+            selected_idxes = np.random.randint(
+                0, len(idxes), size=int((1 - m_rate) * len(idxes))
+            )
+            new_idxes = idxes[selected_idxes]
+            new_idxes = np.sort(new_idxes)
+        else:
+            new_idxes = np.where(np.logical_and(y >= low_range, y < high_range))[0]
+        return x[new_idxes], y[new_idxes]
+
+    def getlen(self, index):
+        y = self._train_targets
+        return np.sum(np.where(y == index))
+
+
+class DummyDataset(Dataset):
+    def __init__(self, images, labels, trsf, use_path=False, dataset_name='cifar'):
+        assert len(images) == len(labels), "Data size error!"
+        self.images = images
+        self.labels = labels
+        self.trsf = trsf
+        self.use_path = use_path
+        self.dataset_name = dataset_name
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        if self.use_path:
+            image = self.trsf(pil_loader(self.images[idx]))
+        else:
+            image = self.trsf(Image.fromarray(self.images[idx]))
+        label = self.labels[idx]
+
+        return idx, image, label
+
+
+def _map_new_class_index(y, order):
+    return np.array(list(map(lambda x: order.index(x), y)))
+
+
+def _get_idata(dataset_name):
+    name = dataset_name.lower()
+    if name == "cifar10":
+        return iCIFAR10()
+    elif name == "cifar100":
+        return iCIFAR100()
+    elif name == "imagenet1000":
+        return iImageNet1000()
+    elif name == "imagenet100":
+        return iImageNet100()
+    elif name == "gnss":
+        return GNSS()
+    else:
+        raise NotImplementedError("Unknown dataset {}.".format(dataset_name))
+    
+
+def pil_loader(path):
+    """
+    Ref:
+    https://pytorch.org/docs/stable/_modules/torchvision/datasets/folder.html#ImageFolder
+    """
+    # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835)
+    with open(path, "rb") as f:
+        img = Image.open(f)
+        return img.convert("RGB")
+
+
+def accimage_loader(path):
+    """
+    Ref:
+    https://pytorch.org/docs/stable/_modules/torchvision/datasets/folder.html#ImageFolder
+    accimage is an accelerated Image loader and preprocessor leveraging Intel IPP.
+    accimage is available on conda-forge.
+    """
+    import accimage
+
+    try:
+        return accimage.Image(path)
+    except IOError:
+        # Potentially a decoding problem, fall back to PIL.Image
+        return pil_loader(path)
+
+
+def default_loader(path):
+    """
+    Ref:
+    https://pytorch.org/docs/stable/_modules/torchvision/datasets/folder.html#ImageFolder
+    """
+    from torchvision import get_image_backend
+
+    if get_image_backend() == "accimage":
+        return accimage_loader(path)
+    else:
+        return pil_loader(path)

utils/factory.py

@@ -0,0 +1,27 @@
+def get_model(model_name, args):
+    name = model_name.lower()
+    if name == "icarl":
+        from models.icarl import iCaRL
+        return iCaRL(args)
+    
+    elif name == "lwf":
+        from models.lwf import LwF
+        return LwF(args)
+    elif name == "ewc":
+        from models.ewc import EWC
+        return EWC(args)
+    elif name == "finetune":
+        from models.finetune import Finetune
+        return Finetune(args)
+    elif name == "replay":
+        from models.replay import Replay
+        return Replay(args)
+    elif name == "memo":   
+        from models.memo import MEMO
+        return MEMO(args)
+    elif name == "blcl":   
+        from models.blcl import BLCL
+        return BLCL(args)
+    
+    else:
+        assert 0

utils/inc_net.py

@@ -0,0 +1,897 @@
+import copy
+import logging
+import torch
+from torch import nn
+from convs.cifar_resnet import resnet32
+from convs.resnet import resnet18, resnet34, resnet50, resnet101, resnet152
+from convs.ucir_cifar_resnet import resnet32 as cosine_resnet32
+from convs.ucir_resnet import resnet18 as cosine_resnet18
+from convs.ucir_resnet import resnet34 as cosine_resnet34
+from convs.ucir_resnet import resnet50 as cosine_resnet50
+from convs.linears import SimpleLinear, SplitCosineLinear, CosineLinear
+from convs.modified_represnet import resnet18_rep,resnet34_rep
+from convs.resnet_cbam import resnet18_cbam,resnet34_cbam,resnet50_cbam
+from convs.memo_resnet import  get_resnet18_imagenet as get_memo_resnet18 #for MEMO imagenet
+from convs.memo_cifar_resnet import get_resnet32_a2fc as get_memo_resnet32 #for MEMO cifar
+from convs.memo_cifar_resnet import get_resnet56_a2fc as get_memo_resnet56 #for MEMO cifar
+import convs.memo_resnet as memor
+import numpy as np
+
+def get_convnet(args, pretrained=False):
+    name = args["convnet_type"].lower()
+    if name == "resnet32":
+        return resnet32()
+    elif name == "resnet18":
+        return resnet18(pretrained=pretrained,args=args)
+    elif name == "resnet34":
+        return resnet34(pretrained=pretrained,args=args)
+    elif name == "resnet50":
+        return resnet50(pretrained=pretrained,args=args)
+    # MEMO benchmark backbone
+    elif name == 'memo_resnet18':
+        _basenet, _adaptive_net = get_memo_resnet18(args=args)
+        return _basenet, _adaptive_net
+      
+    elif name == 'memo_resnet32':
+        _basenet, _adaptive_net = get_memo_resnet32(args=args)
+        return _basenet, _adaptive_net
+    
+    elif name == 'memo_resnet56':
+        _basenet, _adaptive_net = get_memo_resnet56(args=args)
+        return _basenet, _adaptive_net
+    else:
+        raise NotImplementedError("Unknown type {}".format(name))
+
+
+class BaseNet(nn.Module):
+    def __init__(self, args, pretrained):
+        super(BaseNet, self).__init__()
+
+        self.convnet = get_convnet(args, pretrained)
+        self.fc = None
+
+    @property
+    def feature_dim(self):
+        return self.convnet.out_dim
+
+    def extract_vector(self, x):
+        return self.convnet(x)["features"]
+
+    def forward(self, x):
+        x = self.convnet(x)
+        out = self.fc(x["features"])
+        """
+        {
+            'fmaps': [x_1, x_2, ..., x_n],
+            'features': features
+            'logits': logits
+        }
+        """
+        out.update(x)
+
+        return out
+
+    def update_fc(self, nb_classes):
+        pass
+
+    def generate_fc(self, in_dim, out_dim):
+        pass
+
+    def copy(self):
+        return copy.deepcopy(self)
+
+    def freeze(self):
+        for param in self.parameters():
+            param.requires_grad = False
+        self.eval()
+
+        return self
+    
+    def load_checkpoint(self, args):
+        if args["init_cls"] == 50:
+            pkl_name = "{}_{}_{}_B{}_Inc{}".format( 
+                args["dataset"],
+                args["seed"],
+                args["convnet_type"],
+                0,
+                args["init_cls"],
+            )
+            checkpoint_name = f"checkpoints/finetune_{pkl_name}_0.pkl"
+        else:
+            checkpoint_name = f"checkpoints/finetune_{args['csv_name']}_0.pkl"
+        model_infos = torch.load(checkpoint_name)
+        self.convnet.load_state_dict(model_infos['convnet'])
+        self.fc.load_state_dict(model_infos['fc'])
+        test_acc = model_infos['test_acc']
+        return test_acc
+
+class IncrementalNet(BaseNet):
+    def __init__(self, args, pretrained, gradcam=False):
+        super().__init__(args, pretrained)
+        self.gradcam = gradcam
+        if hasattr(self, "gradcam") and self.gradcam:
+            self._gradcam_hooks = [None, None]
+            self.set_gradcam_hook()
+
+    def update_fc(self, nb_classes):
+        
+        fc = self.generate_fc(self.feature_dim, nb_classes)
+        if self.fc is not None:
+            nb_output = self.fc.out_features
+            weight = copy.deepcopy(self.fc.weight.data)
+            bias = copy.deepcopy(self.fc.bias.data)
+            fc.weight.data[:nb_output] = weight
+            fc.bias.data[:nb_output] = bias
+
+        del self.fc
+        self.fc = fc
+
+    def weight_align(self, increment):
+        weights = self.fc.weight.data
+        newnorm = torch.norm(weights[-increment:, :], p=2, dim=1)
+        oldnorm = torch.norm(weights[:-increment, :], p=2, dim=1)
+        meannew = torch.mean(newnorm)
+        meanold = torch.mean(oldnorm)
+        gamma = meanold / meannew
+        self.fc.weight.data[-increment:, :] *= gamma
+
+    def generate_fc(self, in_dim, out_dim):
+        fc = SimpleLinear(in_dim, out_dim)
+
+        return fc
+
+    def forward(self, x):
+        x = self.convnet(x)
+        out = self.fc(x["features"])
+        out.update(x)
+        if hasattr(self, "gradcam") and self.gradcam:
+            out["gradcam_gradients"] = self._gradcam_gradients
+            out["gradcam_activations"] = self._gradcam_activations
+
+        return out
+
+    def unset_gradcam_hook(self):
+        self._gradcam_hooks[0].remove()
+        self._gradcam_hooks[1].remove()
+        self._gradcam_hooks[0] = None
+        self._gradcam_hooks[1] = None
+        self._gradcam_gradients, self._gradcam_activations = [None], [None]
+
+    def set_gradcam_hook(self):
+        self._gradcam_gradients, self._gradcam_activations = [None], [None]
+
+        def backward_hook(module, grad_input, grad_output):
+            self._gradcam_gradients[0] = grad_output[0]
+            return None
+
+        def forward_hook(module, input, output):
+            self._gradcam_activations[0] = output
+            return None
+
+        self._gradcam_hooks[0] = self.convnet.last_conv.register_backward_hook(
+            backward_hook
+        )
+        self._gradcam_hooks[1] = self.convnet.last_conv.register_forward_hook(
+            forward_hook
+        )
+
+class IL2ANet(IncrementalNet):
+
+    def update_fc(self, num_old, num_total, num_aux):
+        fc = self.generate_fc(self.feature_dim, num_total+num_aux)
+        if self.fc is not None:
+            weight = copy.deepcopy(self.fc.weight.data)
+            bias = copy.deepcopy(self.fc.bias.data)
+            fc.weight.data[:num_old] = weight[:num_old]
+            fc.bias.data[:num_old] = bias[:num_old]
+        del self.fc
+        self.fc = fc
+
+class CosineIncrementalNet(BaseNet):
+    def __init__(self, args, pretrained, nb_proxy=1):
+        super().__init__(args, pretrained)
+        self.nb_proxy = nb_proxy
+
+    def update_fc(self, nb_classes, task_num):
+        fc = self.generate_fc(self.feature_dim, nb_classes)
+        if self.fc is not None:
+            if task_num == 1:
+                fc.fc1.weight.data = self.fc.weight.data
+                fc.sigma.data = self.fc.sigma.data
+            else:
+                prev_out_features1 = self.fc.fc1.out_features
+                fc.fc1.weight.data[:prev_out_features1] = self.fc.fc1.weight.data
+                fc.fc1.weight.data[prev_out_features1:] = self.fc.fc2.weight.data
+                fc.sigma.data = self.fc.sigma.data
+
+        del self.fc
+        self.fc = fc
+
+    def generate_fc(self, in_dim, out_dim):
+        if self.fc is None:
+            fc = CosineLinear(in_dim, out_dim, self.nb_proxy, to_reduce=True)
+        else:
+            prev_out_features = self.fc.out_features // self.nb_proxy
+            # prev_out_features = self.fc.out_features
+            fc = SplitCosineLinear(
+                in_dim, prev_out_features, out_dim - prev_out_features, self.nb_proxy
+            )
+
+        return fc
+
+
+class BiasLayer_BIC(nn.Module):
+    def __init__(self):
+        super(BiasLayer_BIC, self).__init__()
+        self.alpha = nn.Parameter(torch.ones(1, requires_grad=True))
+        self.beta = nn.Parameter(torch.zeros(1, requires_grad=True))
+
+    def forward(self, x, low_range, high_range):
+        ret_x = x.clone()
+        ret_x[:, low_range:high_range] = (
+            self.alpha * x[:, low_range:high_range] + self.beta
+        )
+        return ret_x
+
+    def get_params(self):
+        return (self.alpha.item(), self.beta.item())
+
+
+class IncrementalNetWithBias(BaseNet):
+    def __init__(self, args, pretrained, bias_correction=False):
+        super().__init__(args, pretrained)
+
+        # Bias layer
+        self.bias_correction = bias_correction
+        self.bias_layers = nn.ModuleList([])
+        self.task_sizes = []
+
+    def forward(self, x):
+        x = self.convnet(x)
+        out = self.fc(x["features"])
+        if self.bias_correction:
+            logits = out["logits"]
+            for i, layer in enumerate(self.bias_layers):
+                logits = layer(
+                    logits, sum(self.task_sizes[:i]), sum(self.task_sizes[: i + 1])
+                )
+            out["logits"] = logits
+
+        out.update(x)
+
+        return out
+
+    def update_fc(self, nb_classes):
+        fc = self.generate_fc(self.feature_dim, nb_classes)
+        if self.fc is not None:
+            nb_output = self.fc.out_features
+            weight = copy.deepcopy(self.fc.weight.data)
+            bias = copy.deepcopy(self.fc.bias.data)
+            fc.weight.data[:nb_output] = weight
+            fc.bias.data[:nb_output] = bias
+
+        del self.fc
+        self.fc = fc
+
+        new_task_size = nb_classes - sum(self.task_sizes)
+        self.task_sizes.append(new_task_size)
+        self.bias_layers.append(BiasLayer_BIC())
+
+    def generate_fc(self, in_dim, out_dim):
+        fc = SimpleLinear(in_dim, out_dim)
+
+        return fc
+
+    def get_bias_params(self):
+        params = []
+        for layer in self.bias_layers:
+            params.append(layer.get_params())
+
+        return params
+
+    def unfreeze(self):
+        for param in self.parameters():
+            param.requires_grad = True
+
+
+class DERNet(nn.Module):
+    def __init__(self, args, pretrained):
+        super(DERNet, self).__init__()
+        self.convnet_type = args["convnet_type"]
+        self.convnets = nn.ModuleList()
+        self.pretrained = pretrained
+        self.out_dim = None
+        self.fc = None
+        self.aux_fc = None
+        self.task_sizes = []
+        self.args = args
+
+    @property
+    def feature_dim(self):
+        if self.out_dim is None:
+            return 0
+        return self.out_dim * len(self.convnets)
+
+    def extract_vector(self, x):
+        features = [convnet(x)["features"] for convnet in self.convnets]
+        features = torch.cat(features, 1)
+        return features
+
+    def forward(self, x):
+        features = [convnet(x)["features"] for convnet in self.convnets]
+        features = torch.cat(features, 1)
+
+        out = self.fc(features)  # {logics: self.fc(features)}
+
+        aux_logits = self.aux_fc(features[:, -self.out_dim :])["logits"]
+
+        out.update({"aux_logits": aux_logits, "features": features})
+        return out
+        """
+        {
+            'features': features
+            'logits': logits
+            'aux_logits':aux_logits
+        }
+        """
+
+    def update_fc(self, nb_classes):
+        if len(self.convnets) == 0:
+            self.convnets.append(get_convnet(self.args))
+        else:
+            self.convnets.append(get_convnet(self.args))
+            self.convnets[-1].load_state_dict(self.convnets[-2].state_dict())
+
+        if self.out_dim is None:
+            self.out_dim = self.convnets[-1].out_dim
+        fc = self.generate_fc(self.feature_dim, nb_classes)
+        if self.fc is not None:
+            nb_output = self.fc.out_features
+            weight = copy.deepcopy(self.fc.weight.data)
+            bias = copy.deepcopy(self.fc.bias.data)
+            fc.weight.data[:nb_output, : self.feature_dim - self.out_dim] = weight
+            fc.bias.data[:nb_output] = bias
+
+        del self.fc
+        self.fc = fc
+
+        new_task_size = nb_classes - sum(self.task_sizes)
+        self.task_sizes.append(new_task_size)
+
+        self.aux_fc = self.generate_fc(self.out_dim, new_task_size + 1)
+
+    def generate_fc(self, in_dim, out_dim):
+        fc = SimpleLinear(in_dim, out_dim)
+
+        return fc
+
+    def copy(self):
+        return copy.deepcopy(self)
+
+    def freeze(self):
+        for param in self.parameters():
+            param.requires_grad = False
+        self.eval()
+
+        return self
+
+    def freeze_conv(self):
+        for param in self.convnets.parameters():
+            param.requires_grad = False
+        self.convnets.eval()
+
+    def weight_align(self, increment):
+        weights = self.fc.weight.data
+        newnorm = torch.norm(weights[-increment:, :], p=2, dim=1)
+        oldnorm = torch.norm(weights[:-increment, :], p=2, dim=1)
+        meannew = torch.mean(newnorm)
+        meanold = torch.mean(oldnorm)
+        gamma = meanold / meannew
+        #print("alignweights,gamma=", gamma)
+        self.fc.weight.data[-increment:, :] *= gamma
+
+    def load_checkpoint(self, args):
+        checkpoint_name = f"checkpoints/finetune_{args['csv_name']}_0.pkl"
+        model_infos = torch.load(checkpoint_name)
+        assert len(self.convnets) == 1
+        self.convnets[0].load_state_dict(model_infos['convnet'])
+        self.fc.load_state_dict(model_infos['fc'])
+        test_acc = model_infos['test_acc']
+        return test_acc
+
+
+class SimpleCosineIncrementalNet(BaseNet):
+    def __init__(self, args, pretrained):
+        super().__init__(args, pretrained)
+
+    def update_fc(self, nb_classes, nextperiod_initialization=None):
+        fc = self.generate_fc(self.feature_dim, nb_classes).cuda()
+        if self.fc is not None:
+            nb_output = self.fc.out_features
+            weight = copy.deepcopy(self.fc.weight.data)
+            fc.sigma.data = self.fc.sigma.data
+            if nextperiod_initialization is not None:
+
+                weight = torch.cat([weight, nextperiod_initialization])
+            else:
+                weight = torch.cat([weight, torch.zeros(nb_classes - nb_output, self.feature_dim).cuda()])
+            fc.weight = nn.Parameter(weight)
+        del self.fc
+        self.fc = fc
+
+    def generate_fc(self, in_dim, out_dim):
+        fc = CosineLinear(in_dim, out_dim)
+        return fc
+
+
+class FOSTERNet(nn.Module):
+    def __init__(self, args, pretrained):
+        super(FOSTERNet, self).__init__()
+        self.convnet_type = args["convnet_type"]
+        self.convnets = nn.ModuleList()
+        self.pretrained = pretrained
+        self.out_dim = None
+        self.fc = None
+        self.fe_fc = None
+        self.task_sizes = []
+        self.oldfc = None
+        self.args = args
+
+    @property
+    def feature_dim(self):
+        if self.out_dim is None:
+            return 0
+        return self.out_dim * len(self.convnets)
+
+    def extract_vector(self, x):
+        features = [convnet(x)["features"] for convnet in self.convnets]
+        features = torch.cat(features, 1)
+        return features
+
+    def forward(self, x):
+        features = [convnet(x)["features"] for convnet in self.convnets]
+        features = torch.cat(features, 1)
+        out = self.fc(features)
+        fe_logits = self.fe_fc(features[:, -self.out_dim :])["logits"]
+
+        out.update({"fe_logits": fe_logits, "features": features})
+
+        if self.oldfc is not None:
+            old_logits = self.oldfc(features[:, : -self.out_dim])["logits"]
+            out.update({"old_logits": old_logits})
+
+        out.update({"eval_logits": out["logits"]})
+        return out
+
+    def update_fc(self, nb_classes):
+        self.convnets.append(get_convnet(self.args))
+        if self.out_dim is None:
+            self.out_dim = self.convnets[-1].out_dim
+        fc = self.generate_fc(self.feature_dim, nb_classes)
+        if self.fc is not None:
+            nb_output = self.fc.out_features
+            weight = copy.deepcopy(self.fc.weight.data)
+            bias = copy.deepcopy(self.fc.bias.data)
+            fc.weight.data[:nb_output, : self.feature_dim - self.out_dim] = weight
+            fc.bias.data[:nb_output] = bias
+            self.convnets[-1].load_state_dict(self.convnets[-2].state_dict())
+
+        self.oldfc = self.fc
+        self.fc = fc
+        new_task_size = nb_classes - sum(self.task_sizes)
+        self.task_sizes.append(new_task_size)
+        self.fe_fc = self.generate_fc(self.out_dim, nb_classes)
+
+    def generate_fc(self, in_dim, out_dim):
+        fc = SimpleLinear(in_dim, out_dim)
+        return fc
+
+    def copy(self):
+        return copy.deepcopy(self)
+
+    def copy_fc(self, fc):
+        weight = copy.deepcopy(fc.weight.data)
+        bias = copy.deepcopy(fc.bias.data)
+        n, m = weight.shape[0], weight.shape[1]
+        self.fc.weight.data[:n, :m] = weight
+        self.fc.bias.data[:n] = bias
+
+    def freeze(self):
+        for param in self.parameters():
+            param.requires_grad = False
+        self.eval()
+        return self
+
+    def freeze_conv(self):
+        for param in self.convnets.parameters():
+            param.requires_grad = False
+        self.convnets.eval()
+
+    def weight_align(self, old, increment, value):
+        weights = self.fc.weight.data
+        newnorm = torch.norm(weights[-increment:, :], p=2, dim=1)
+        oldnorm = torch.norm(weights[:-increment, :], p=2, dim=1)
+        meannew = torch.mean(newnorm)
+        meanold = torch.mean(oldnorm)
+        gamma = meanold / meannew * (value ** (old / increment))
+        logging.info("align weights, gamma = {} ".format(gamma))
+        self.fc.weight.data[-increment:, :] *= gamma
+    
+    def load_checkpoint(self, args):
+        if args["init_cls"] == 50:
+            pkl_name = "{}_{}_{}_B{}_Inc{}".format( 
+                args["dataset"],
+                args["seed"],
+                args["convnet_type"],
+                0,
+                args["init_cls"],
+            )
+            checkpoint_name = f"checkpoints/finetune_{pkl_name}_0.pkl"
+        else:
+            checkpoint_name = f"checkpoints/finetune_{args['csv_name']}_0.pkl"
+        model_infos = torch.load(checkpoint_name)
+        assert len(self.convnets) == 1
+        self.convnets[0].load_state_dict(model_infos['convnet'])
+        self.fc.load_state_dict(model_infos['fc'])
+        test_acc = model_infos['test_acc']
+        return test_acc
+    
+
+class BiasLayer(nn.Module):
+    def __init__(self):
+        super(BiasLayer, self).__init__()
+        self.alpha = nn.Parameter(torch.zeros(1, requires_grad=True))
+        self.beta = nn.Parameter(torch.zeros(1, requires_grad=True))
+
+    def forward(self, x , bias=True):
+        ret_x = x.clone()
+        ret_x = (self.alpha+1) * x # + self.beta
+        if bias:
+            ret_x = ret_x + self.beta
+        return ret_x
+
+    def get_params(self):
+        return (self.alpha.item(), self.beta.item())
+
+
+class BEEFISONet(nn.Module):
+    def __init__(self, args, pretrained):
+        super(BEEFISONet, self).__init__()
+        self.convnet_type = args["convnet_type"]
+        self.convnets = nn.ModuleList()
+        self.pretrained = pretrained
+        self.out_dim = None
+        self.old_fc = None
+        self.new_fc = None
+        self.task_sizes = []
+        self.forward_prototypes = None
+        self.backward_prototypes = None
+        self.args = args
+        self.biases = nn.ModuleList()
+
+    @property
+    def feature_dim(self):
+        if self.out_dim is None:
+            return 0
+        return self.out_dim * len(self.convnets)
+
+    def extract_vector(self, x):
+        features = [convnet(x)["features"] for convnet in self.convnets]
+        features = torch.cat(features, 1)
+        return features
+
+    def forward(self, x):
+        features = [convnet(x)["features"] for convnet in self.convnets]
+        features = torch.cat(features, 1)
+        
+        if self.old_fc is None:
+            fc = self.new_fc
+            out = fc(features)
+        else:
+            '''
+            merge the weights
+            '''
+            new_task_size = self.task_sizes[-1]
+            fc_weight = torch.cat([self.old_fc.weight,torch.zeros((new_task_size,self.feature_dim-self.out_dim)).cuda()],dim=0)             
+            new_fc_weight = self.new_fc.weight
+            new_fc_bias = self.new_fc.bias
+            for i in range(len(self.task_sizes)-2,-1,-1):
+                new_fc_weight = torch.cat([*[self.biases[i](self.backward_prototypes.weight[i].unsqueeze(0),bias=False) for _ in range(self.task_sizes[i])],new_fc_weight],dim=0)
+                new_fc_bias = torch.cat([*[self.biases[i](self.backward_prototypes.bias[i].unsqueeze(0),bias=True) for _ in range(self.task_sizes[i])], new_fc_bias])
+            fc_weight = torch.cat([fc_weight,new_fc_weight],dim=1)
+            fc_bias = torch.cat([self.old_fc.bias,torch.zeros(new_task_size).cuda()])
+            fc_bias=+new_fc_bias
+            logits = features@fc_weight.permute(1,0)+fc_bias
+            out = {"logits":logits}        
+
+            new_fc_weight = self.new_fc.weight
+            new_fc_bias = self.new_fc.bias
+            for i in range(len(self.task_sizes)-2,-1,-1):
+                new_fc_weight = torch.cat([self.backward_prototypes.weight[i].unsqueeze(0),new_fc_weight],dim=0)
+                new_fc_bias = torch.cat([self.backward_prototypes.bias[i].unsqueeze(0), new_fc_bias])
+            out["train_logits"] = features[:,-self.out_dim:]@new_fc_weight.permute(1,0)+new_fc_bias 
+        out.update({"eval_logits": out["logits"],"energy_logits":self.forward_prototypes(features[:,-self.out_dim:])["logits"]})
+        return out
+
+    def update_fc_before(self, nb_classes):
+        new_task_size = nb_classes - sum(self.task_sizes)
+        self.biases = nn.ModuleList([BiasLayer() for i in range(len(self.task_sizes))])
+        self.convnets.append(get_convnet(self.args))
+        if self.out_dim is None:
+            self.out_dim = self.convnets[-1].out_dim
+        if self.new_fc is not None:
+            self.fe_fc = self.generate_fc(self.out_dim, nb_classes)
+            self.backward_prototypes = self.generate_fc(self.out_dim,len(self.task_sizes))
+            self.convnets[-1].load_state_dict(self.convnets[0].state_dict())
+        self.forward_prototypes = self.generate_fc(self.out_dim, nb_classes)
+        self.new_fc = self.generate_fc(self.out_dim,new_task_size)
+        self.task_sizes.append(new_task_size)
+    def generate_fc(self, in_dim, out_dim):
+        fc = SimpleLinear(in_dim, out_dim)
+        return fc
+    
+    def update_fc_after(self):
+        if self.old_fc is not None:
+            old_fc = self.generate_fc(self.feature_dim, sum(self.task_sizes))
+            new_task_size = self.task_sizes[-1]
+            old_fc.weight.data = torch.cat([self.old_fc.weight.data,torch.zeros((new_task_size,self.feature_dim-self.out_dim)).cuda()],dim=0)             
+            new_fc_weight = self.new_fc.weight.data
+            new_fc_bias = self.new_fc.bias.data
+            for i in range(len(self.task_sizes)-2,-1,-1):
+                new_fc_weight = torch.cat([*[self.biases[i](self.backward_prototypes.weight.data[i].unsqueeze(0),bias=False) for _ in range(self.task_sizes[i])], new_fc_weight],dim=0)
+                new_fc_bias = torch.cat([*[self.biases[i](self.backward_prototypes.bias.data[i].unsqueeze(0),bias=True) for _ in range(self.task_sizes[i])], new_fc_bias])
+            old_fc.weight.data = torch.cat([old_fc.weight.data,new_fc_weight],dim=1)
+            old_fc.bias.data = torch.cat([self.old_fc.bias.data,torch.zeros(new_task_size).cuda()])
+            old_fc.bias.data+=new_fc_bias
+            self.old_fc = old_fc
+        else:
+            self.old_fc  = self.new_fc
+
+    def copy(self):
+        return copy.deepcopy(self)
+
+    def copy_fc(self, fc):
+        weight = copy.deepcopy(fc.weight.data)
+        bias = copy.deepcopy(fc.bias.data)
+        n, m = weight.shape[0], weight.shape[1]
+        self.fc.weight.data[:n, :m] = weight
+        self.fc.bias.data[:n] = bias
+
+    def freeze(self):
+        for param in self.parameters():
+            param.requires_grad = False
+        self.eval()
+        return self
+
+    def freeze_conv(self):
+        for param in self.convnets.parameters():
+            param.requires_grad = False
+        self.convnets.eval()
+
+    def weight_align(self, old, increment, value):
+        weights = self.fc.weight.data
+        newnorm = torch.norm(weights[-increment:, :], p=2, dim=1)
+        oldnorm = torch.norm(weights[:-increment, :], p=2, dim=1)
+        meannew = torch.mean(newnorm)
+        meanold = torch.mean(oldnorm)
+        gamma = meanold / meannew * (value ** (old / increment))
+        logging.info("align weights, gamma = {} ".format(gamma))
+        self.fc.weight.data[-increment:, :] *= gamma
+
+
+class AdaptiveNet(nn.Module):
+    def __init__(self, args, pretrained):
+        super(AdaptiveNet, self).__init__()
+        self.convnet_type = args["convnet_type"]
+        self.TaskAgnosticExtractor , _ = get_convnet(args, pretrained) #Generalized blocks
+        self.TaskAgnosticExtractor.train()
+        self.AdaptiveExtractors = nn.ModuleList() #Specialized Blocks
+        self.pretrained=pretrained
+        self.out_dim=None
+        self.fc = None
+        self.aux_fc=None
+        self.task_sizes = []
+        self.args=args
+        self.avg_threshold = args["init_cls"] + 2 * args["increment"]
+        self.inc_cls = args["increment"]
+
+    @property
+    def feature_dim(self):
+        if self.out_dim is None:
+            return 0
+        return self.out_dim*len(self.AdaptiveExtractors)
+    
+    def extract_vector(self, x):
+        base_feature_map = self.TaskAgnosticExtractor(x)
+        features = [extractor(base_feature_map) for extractor in self.AdaptiveExtractors]
+        features = torch.cat(features, 1)
+        return features
+
+    def forward(self, x):
+        base_feature_map = self.TaskAgnosticExtractor(x)
+        features = [extractor(base_feature_map) for extractor in self.AdaptiveExtractors]
+        features = torch.cat(features, 1)
+        out=self.fc(features) #{logits: self.fc(features)}
+
+        aux_logits=self.aux_fc(features[:,-self.out_dim:])["logits"] 
+
+        out.update({"aux_logits":aux_logits,"features":features})
+        out.update({"base_features":base_feature_map})
+        return out
+                
+        '''
+        {
+            'features': features
+            'logits': logits
+            'aux_logits':aux_logits
+        }
+        '''
+        
+    def merge_and_average_state_dicts(self, extractors):
+        """
+        Merge and average state dictionaries of two modules.
+
+        Given two modules, this method merges their state dictionaries and averages the values of common keys.
+
+        Parameters:
+            extractors (list): List of module instances.
+
+        Returns:
+            dict: Merged and averaged state dictionary.
+        """
+        module1 = extractors[0].state_dict()
+        module2 = extractors[1].state_dict()
+        all_keys = module1.keys() | module2.keys()
+        result_module = {}
+        for key in all_keys:
+            if key in module1 and key in module2:    
+                avg_value = (module1[key] + module2[key]) / 2.0
+                result_module[key] = avg_value
+            elif key in module1:    
+                result_module[key] = module1[key]
+            elif key in module2:   
+                result_module[key] = module2[key]
+        return result_module
+    
+    def merge_prev_layers(self):
+        """
+        Merge layers from previous tasks.
+
+        This method merges layers from the previous two tasks based on their index values.
+
+        Returns:
+            list: Merged list of layers from the previous tasks.
+        """
+        curr_task = self.args["curr"]
+        p = curr_task - 1
+        pp = curr_task - 2
+        lst1 = self.args["layers"][p]
+        lst2 = self.args["layers"][pp]
+        if len(lst1) == 1:
+            lst1.append(0)
+        if len(lst2) == 1:
+            lst2.append(0)
+        lst3 = []
+        for x, y in zip(lst1, lst2):
+            lst3.append(x if x > y else y)
+        if lst3[-1] == 0:
+            lst3 = lst3[:-1]  
+            
+        return lst3
+    
+    def return_specialized_block(self, nconv):
+        """
+        Return a specialized block based on the given convolutional layers.
+
+        This method returns a specialized ResNet block with a specific number of convolutional layers.
+
+        Parameters:
+            nconv (list): list of no of convolutional layers.
+
+        Returns:
+            nn.Module: Specialized ResNet block.
+        """
+        return memor.SpecializedResNet_imagenet(memor.BasicBlock, layers=[2,2,2,len(nconv)], nconv=nconv)
+
+    def update_fc(self,nb_classes):
+        _ , _new_extractor = get_convnet(self.args)
+
+        if len(self.AdaptiveExtractors)==0:
+            self.AdaptiveExtractors.append(_new_extractor)    
+
+        else:
+            if len(self.AdaptiveExtractors)==2 and self.args["type"] == "avg":
+                avg_vals = self.merge_and_average_state_dicts(self.AdaptiveExtractors)
+                new_layer = self.merge_prev_layers()
+                specialized_block = self.return_specialized_block(nconv=new_layer)
+                self.AdaptiveExtractors = nn.ModuleList([specialized_block])
+                self.AdaptiveExtractors[0].load_state_dict(avg_vals)
+
+            self.AdaptiveExtractors.append(_new_extractor)
+            self.AdaptiveExtractors[-1].load_state_dict(self.AdaptiveExtractors[-2].state_dict(), strict=False)
+
+        if self.out_dim is None:
+            self.out_dim=self.AdaptiveExtractors[-1].feature_dim       
+
+        if self.fc is not None:
+            logging.debug("Previous FC is {}x{}".format(self.fc.in_features, self.fc.out_features))
+
+        logging.debug("Generating the FC of size --> {}x{}".format(self.feature_dim, nb_classes)) 
+
+        fc = self.generate_fc(self.feature_dim, nb_classes)             
+
+        if self.fc is not None:
+            nb_output = self.fc.out_features
+            weight = copy.deepcopy(self.fc.weight.data)
+
+            if nb_classes >= self.avg_threshold and self.args["type"] == "avg":
+                weight = torch.mean(weight.view(nb_classes-self.inc_cls, self.out_dim, 2), dim=2)
+
+            bias = copy.deepcopy(self.fc.bias.data)
+            fc.weight.data[:nb_output,:self.feature_dim-self.out_dim] = weight
+            fc.bias.data[:nb_output] = bias
+            
+        del self.fc
+        self.fc = fc
+        new_task_size = nb_classes - sum(self.task_sizes)
+        self.task_sizes.append(new_task_size)
+        self.aux_fc=self.generate_fc(self.out_dim,new_task_size+1)
+ 
+    def generate_fc(self, in_dim, out_dim):
+        fc = SimpleLinear(in_dim, out_dim)
+        return fc
+    
+
+    def copy(self):
+        return copy.deepcopy(self)
+
+    def weight_align(self, increment):
+        weights=self.fc.weight.data
+        newnorm=(torch.norm(weights[-increment:,:],p=2,dim=1))
+        oldnorm=(torch.norm(weights[:-increment,:],p=2,dim=1))
+        meannew=torch.mean(newnorm)
+        meanold=torch.mean(oldnorm)
+        gamma=meanold/meannew
+        print('alignweights,gamma=',gamma)
+        self.fc.weight.data[-increment:,:]*=gamma
+    
+    def load_checkpoint(self, args):
+        if args["init_cls"] == 50:
+            pkl_name = "{}_{}_{}_B{}_Inc{}".format( 
+                args["dataset"],
+                args["seed"],
+                args["convnet_type"],
+                0,
+                args["init_cls"],
+            )
+            checkpoint_name = f"checkpoints/finetune_{pkl_name}_0.pkl"
+        else:
+            checkpoint_name = f"checkpoints/finetune_{args['csv_name']}_0.pkl"
+        checkpoint_name = checkpoint_name.replace("memo_", "")
+        model_infos = torch.load(checkpoint_name)
+        model_dict = model_infos['convnet']
+        assert len(self.AdaptiveExtractors) == 1
+
+        base_state_dict = self.TaskAgnosticExtractor.state_dict()
+        adap_state_dict = self.AdaptiveExtractors[0].state_dict()
+
+        pretrained_base_dict = {
+            k:v
+            for k, v in model_dict.items()
+            if k in base_state_dict
+        }
+
+        pretrained_adap_dict = {
+            k:v
+            for k, v in model_dict.items()
+            if k in adap_state_dict
+        }
+
+        base_state_dict.update(pretrained_base_dict)
+        adap_state_dict.update(pretrained_adap_dict)
+
+        self.TaskAgnosticExtractor.load_state_dict(base_state_dict)
+        self.AdaptiveExtractors[0].load_state_dict(adap_state_dict)
+        self.fc.load_state_dict(model_infos['fc'])
+        test_acc = model_infos['test_acc']
+        return test_acc

utils/ops.py

@@ -0,0 +1,121 @@
+from PIL import Image, ImageEnhance, ImageOps
+import random
+import torch
+import numpy as np
+class Cutout(object):
+    def __init__(self, n_holes, length):
+        self.n_holes = n_holes
+        self.length = length
+
+    def __call__(self, img):
+        h = img.size(1)
+        w = img.size(2)
+
+        mask = np.ones((h, w), np.float32)
+
+        for n in range(self.n_holes):
+            y = np.random.randint(h)
+            x = np.random.randint(w)
+
+            y1 = np.clip(y - self.length // 2, 0, h)
+            y2 = np.clip(y + self.length // 2, 0, h)
+            x1 = np.clip(x - self.length // 2, 0, w)
+            x2 = np.clip(x + self.length // 2, 0, w)
+
+            mask[y1: y2, x1: x2] = 0.
+
+        mask = torch.from_numpy(mask)
+        mask = mask.expand_as(img)
+        img = img * mask
+
+        return img
+    
+class ShearX(object):
+    def __init__(self, fillcolor=(128, 128, 128)):
+        self.fillcolor = fillcolor
+
+    def __call__(self, x, magnitude):
+        return x.transform(
+            x.size, Image.AFFINE, (1, magnitude * random.choice([-1, 1]), 0, 0, 1, 0),
+            Image.BICUBIC, fillcolor=self.fillcolor)
+
+
+class ShearY(object):
+    def __init__(self, fillcolor=(128, 128, 128)):
+        self.fillcolor = fillcolor
+
+    def __call__(self, x, magnitude):
+        return x.transform(
+            x.size, Image.AFFINE, (1, 0, 0, magnitude * random.choice([-1, 1]), 1, 0),
+            Image.BICUBIC, fillcolor=self.fillcolor)
+
+
+class TranslateX(object):
+    def __init__(self, fillcolor=(128, 128, 128)):
+        self.fillcolor = fillcolor
+
+    def __call__(self, x, magnitude):
+        return x.transform(
+            x.size, Image.AFFINE, (1, 0, magnitude * x.size[0] * random.choice([-1, 1]), 0, 1, 0),
+            fillcolor=self.fillcolor)
+
+
+class TranslateY(object):
+    def __init__(self, fillcolor=(128, 128, 128)):
+        self.fillcolor = fillcolor
+
+    def __call__(self, x, magnitude):
+        return x.transform(
+            x.size, Image.AFFINE, (1, 0, 0, 0, 1, magnitude * x.size[1] * random.choice([-1, 1])),
+            fillcolor=self.fillcolor)
+
+
+class Rotate(object):
+    def __call__(self, x, magnitude):
+        rot = x.convert("RGBA").rotate(magnitude * random.choice([-1, 1]))
+        return Image.composite(rot, Image.new("RGBA", rot.size, (128,) * 4), rot).convert(x.mode)
+
+
+class Color(object):
+    def __call__(self, x, magnitude):
+        return ImageEnhance.Color(x).enhance(1 + magnitude * random.choice([-1, 1]))
+
+
+class Posterize(object):
+    def __call__(self, x, magnitude):
+        return ImageOps.posterize(x, magnitude)
+
+
+class Solarize(object):
+    def __call__(self, x, magnitude):
+        return ImageOps.solarize(x, magnitude)
+
+
+class Contrast(object):
+    def __call__(self, x, magnitude):
+        return ImageEnhance.Contrast(x).enhance(1 + magnitude * random.choice([-1, 1]))
+
+
+class Sharpness(object):
+    def __call__(self, x, magnitude):
+        return ImageEnhance.Sharpness(x).enhance(1 + magnitude * random.choice([-1, 1]))
+
+
+class Brightness(object):
+    def __call__(self, x, magnitude):
+        return ImageEnhance.Brightness(x).enhance(1 + magnitude * random.choice([-1, 1]))
+
+
+class AutoContrast(object):
+    def __call__(self, x, magnitude):
+        return ImageOps.autocontrast(x)
+
+
+class Equalize(object):
+    def __call__(self, x, magnitude):
+        return ImageOps.equalize(x)
+
+
+class Invert(object):
+    def __call__(self, x, magnitude):
+        return ImageOps.invert(x)

utils/rl_utils/ddpg.py

@@ -0,0 +1,206 @@
+import logging
+import torch
+from torch import nn
+import torch.nn.functional as F
+import numpy as np
+
+
+class PolicyNet(torch.nn.Module):
+    def __init__(self, state_dim, hidden_dim, action_dim, action_bound):
+        super(PolicyNet, self).__init__()
+        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)
+        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)
+        self.action_bound = action_bound
+
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        return torch.tanh(self.fc2(x)) * self.action_bound
+
+
+class RMMPolicyNet(torch.nn.Module):
+    def __init__(self, state_dim, hidden_dim, action_dim):
+        super(RMMPolicyNet, self).__init__()
+        self.fc1 = nn.Sequential(
+            nn.Linear(state_dim, hidden_dim),
+            nn.ReLU(inplace=True),
+            nn.Linear(hidden_dim, action_dim),
+        )
+        self.fc2 = nn.Sequential(
+            nn.Linear(state_dim+action_dim, hidden_dim),
+            nn.ReLU(inplace=True),
+            nn.Linear(hidden_dim, action_dim),
+        )
+    def forward(self, x):
+        a1 = torch.sigmoid(self.fc1(x))
+        x = torch.cat([x,a1],dim=1)
+        a2 = torch.tanh(self.fc2(x))
+        return torch.cat([a1,a2],dim=1)
+ 
+class QValueNet(torch.nn.Module):
+    def __init__(self, state_dim, hidden_dim, action_dim):
+        super(QValueNet, self).__init__()
+        self.fc1 = torch.nn.Linear(state_dim + action_dim, hidden_dim)
+        self.fc2 = torch.nn.Linear(hidden_dim, 1)
+
+    def forward(self, x, a):
+        cat = torch.cat([x, a], dim=1)
+        x = F.relu(self.fc1(cat))
+        return self.fc2(x)
+
+
+class TwoLayerFC(torch.nn.Module):
+    def __init__(
+        self, num_in, num_out, hidden_dim, activation=F.relu, out_fn=lambda x: x
+    ):
+        super().__init__()
+        self.fc1 = nn.Linear(num_in, hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, hidden_dim)
+        self.fc3 = nn.Linear(hidden_dim, num_out)
+
+        self.activation = activation
+        self.out_fn = out_fn
+
+    def forward(self, x):
+        x = self.activation(self.fc1(x))
+        x = self.activation(self.fc2(x))
+        x = self.out_fn(self.fc3(x))
+        return x
+
+
+class DDPG:
+    """DDPG algo"""
+
+    def __init__(
+        self,
+        num_in_actor,
+        num_out_actor,
+        num_in_critic,
+        hidden_dim,
+        discrete,
+        action_bound,
+        sigma,
+        actor_lr,
+        critic_lr,
+        tau,
+        gamma,
+        device,
+        use_rmm=True,
+    ):
+
+        out_fn = (lambda x: x) if discrete else (lambda x: torch.tanh(x) * action_bound)
+
+        if use_rmm:
+            self.actor = RMMPolicyNet(
+                num_in_actor,
+                hidden_dim,
+                num_out_actor,
+            ).to(device)
+            self.target_actor = RMMPolicyNet(
+                num_in_actor,
+                hidden_dim,
+                num_out_actor,
+            ).to(device)
+        else:
+            self.actor = TwoLayerFC(
+                num_in_actor,
+                num_out_actor,
+                hidden_dim,
+                activation=F.relu,
+                out_fn=out_fn,
+            ).to(device)
+            self.target_actor = TwoLayerFC(
+                num_in_actor,
+                num_out_actor,
+                hidden_dim,
+                activation=F.relu,
+                out_fn=out_fn,
+            ).to(device)
+
+        self.critic = TwoLayerFC(num_in_critic, 1, hidden_dim).to(device)
+        self.target_critic = TwoLayerFC(num_in_critic, 1, hidden_dim).to(device)
+        self.target_critic.load_state_dict(self.critic.state_dict())
+        self.target_actor.load_state_dict(self.actor.state_dict())
+        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)
+        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)
+        self.gamma = gamma
+        self.sigma = sigma
+        self.action_bound = action_bound
+        self.tau = tau
+        self.action_dim = num_out_actor
+        self.device = device
+
+    def take_action(self, state):
+        state = torch.tensor(np.expand_dims(state,0), dtype=torch.float).to(self.device)
+        action = self.actor(state)[0].detach().cpu().numpy()
+
+        action = action + self.sigma * np.random.randn(self.action_dim)
+        action[0]=np.clip(action[0],0,1)
+        action[1]=np.clip(action[1],-1,1)
+        return action
+    def save_state_dict(self,name):
+        dicts = {
+            "critic":self.critic.state_dict(),
+            "target_critic":self.target_critic.state_dict(),
+            "actor":self.actor.state_dict(),
+            "target_actor":self.target_actor.state_dict()
+        }
+        torch.save(dicts,name)
+    def load_state_dict(self,name):
+        dicts = torch.load(name)
+        self.critic.load_state_dict(dicts["critic"])
+        self.target_critic.load_state_dict(dicts["target_critic"])
+        self.actor.load_state_dict(dicts["actor"])
+        self.target_actor.load_state_dict(dicts["target_actor"])
+    def soft_update(self, net, target_net):
+        for param_target, param in zip(target_net.parameters(), net.parameters()):
+            param_target.data.copy_(
+                param_target.data * (1.0 - self.tau) + param.data * self.tau
+            )
+
+    def update(self, transition_dict):
+        states = torch.tensor(transition_dict["states"], dtype=torch.float).to(
+            self.device
+        )
+        actions = (
+            torch.tensor(transition_dict["actions"], dtype=torch.float)
+            .to(self.device)
+        )
+        rewards = (
+            torch.tensor(transition_dict["rewards"], dtype=torch.float)
+            .view(-1, 1)
+            .to(self.device)
+        )
+        next_states = torch.tensor(
+            transition_dict["next_states"], dtype=torch.float
+        ).to(self.device)
+        dones = (
+            torch.tensor(transition_dict["dones"], dtype=torch.float)
+            .view(-1, 1)
+            .to(self.device)
+        )
+
+        next_q_values = self.target_critic(
+            torch.cat([next_states, self.target_actor(next_states)], dim=1)
+        )
+        q_targets = rewards + self.gamma * next_q_values * (1 - dones)
+        critic_loss = torch.mean(
+            F.mse_loss(
+                self.critic(torch.cat([states, actions], dim=1)),
+                q_targets,
+            )
+        )
+        self.critic_optimizer.zero_grad()
+        critic_loss.backward()
+        self.critic_optimizer.step()
+
+        actor_loss = -torch.mean(
+            self.critic(
+                torch.cat([states, self.actor(states)], dim=1)
+            )
+        )
+        self.actor_optimizer.zero_grad()
+        actor_loss.backward()
+        self.actor_optimizer.step()
+        logging.info(f"update DDPG: actor loss {actor_loss.item():.3f}, critic loss {critic_loss.item():.3f},  ")
+        self.soft_update(self.actor, self.target_actor)  # soft-update the target policy net
+        self.soft_update(self.critic, self.target_critic)  # soft-update the target Q value net

utils/rl_utils/rl_utils.py

@@ -0,0 +1,20 @@
+from tqdm import tqdm
+import numpy as np
+import torch
+import collections
+import random
+
+class ReplayBuffer:
+    def __init__(self, capacity):
+        self.buffer = collections.deque(maxlen=capacity) 
+
+    def add(self, state, action, reward, next_state, done): 
+        self.buffer.append((state, action, reward, next_state, done)) 
+
+    def sample(self, batch_size): 
+        transitions = random.sample(self.buffer, batch_size)
+        state, action, reward, next_state, done = zip(*transitions)
+        return np.array(state), np.array(action), reward, np.array(next_state), done 
+
+    def size(self): 
+        return len(self.buffer)

utils/toolkit.py

@@ -0,0 +1,115 @@
+import os
+import numpy as np
+import torch
+import  json
+from enum import Enum
+
+class ConfigEncoder(json.JSONEncoder):
+    def default(self, o):
+        if isinstance(o, type):
+            return {'$class': o.__module__ + "." + o.__name__}
+        elif isinstance(o, Enum):
+            return {
+                '$enum': o.__module__ + "." + o.__class__.__name__ + '.' + o.name
+            }
+        elif callable(o):
+            return {
+                '$function': o.__module__ + "." + o.__name__
+            }
+        return json.JSONEncoder.default(self, o)
+
+def count_parameters(model, trainable=False):
+    if trainable:
+        return sum(p.numel() for p in model.parameters() if p.requires_grad)
+    return sum(p.numel() for p in model.parameters())
+
+
+def tensor2numpy(x):
+    return x.cpu().data.numpy() if x.is_cuda else x.data.numpy()
+
+
+def target2onehot(targets, n_classes):
+    onehot = torch.zeros(targets.shape[0], n_classes).to(targets.device)
+    onehot.scatter_(dim=1, index=targets.long().view(-1, 1), value=1.0)
+    return onehot
+
+
+def makedirs(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+
+def accuracy(y_pred, y_true, nb_old, increment=2):
+    assert len(y_pred) == len(y_true), "Data length error."
+    all_acc = {}
+    all_acc["total"] = np.around(
+        (y_pred == y_true).sum() * 100 / len(y_true), decimals=2
+    )
+
+    # Grouped accuracy
+    for class_id in range(0, np.max(y_true), increment):
+        idxes = np.where(
+            np.logical_and(y_true >= class_id, y_true < class_id + increment)
+        )[0]
+        label = "{}-{}".format(
+            str(class_id).rjust(2, "0"), str(class_id + increment - 1).rjust(2, "0")
+        )
+        all_acc[label] = np.around(
+            (y_pred[idxes] == y_true[idxes]).sum() * 100 / len(idxes), decimals=2
+        )
+
+    # Old accuracy
+    idxes = np.where(y_true < nb_old)[0]
+    all_acc["old"] = (
+        0
+        if len(idxes) == 0
+        else np.around(
+            (y_pred[idxes] == y_true[idxes]).sum() * 100 / len(idxes), decimals=2
+        )
+    )
+
+    # New accuracy
+    idxes = np.where(y_true >= nb_old)[0]
+    all_acc["new"] = np.around(
+        (y_pred[idxes] == y_true[idxes]).sum() * 100 / len(idxes), decimals=2
+    )
+
+    return all_acc
+
+
+def split_images_labels(imgs):
+    # split trainset.imgs in ImageFolder
+    #print('*****************split_images_labels******************')
+    images = []
+    labels = []
+    for item in imgs:
+        images.append(item[0])
+        labels.append(item[1])
+
+    return np.array(images), np.array(labels)
+
+def save_fc(args, model):
+    _path = os.path.join(args['logfilename'], "fc.pt")
+    if len(args['device']) > 1: 
+        fc_weight = model._network.fc.weight.data    
+    else:
+        fc_weight = model._network.fc.weight.data.cpu()
+    torch.save(fc_weight, _path)
+
+    _save_dir = os.path.join(f"./results/fc_weights/{args['prefix']}")
+    os.makedirs(_save_dir, exist_ok=True)
+    _save_path = os.path.join(_save_dir, f"{args['csv_name']}.csv")
+    with open(_save_path, "a+") as f:
+        f.write(f"{args['time_str']},{args['model_name']},{_path} \n")
+
+def save_model(args, model):
+    #used in PODNet
+    _path = os.path.join(args['logfilename'], "model.pt")
+    if len(args['device']) > 1:
+        weight = model._network   
+    else:
+        weight = model._network.cpu()
+    torch.save(weight, _path)
+
+
+    

utils/tsne.py

@@ -0,0 +1,388 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from glob import glob
+from tqdm import tqdm
+import sys
+
+def Hbeta(D=np.array([]), beta=1.0):
+    """
+    Compute the perplexity and the P-row for a specific value of the
+    precision of a Gaussian distribution.
+    
+    Args:
+        D (numpy.ndarray): Distance array.
+        beta (float): Precision of the Gaussian distribution.
+        
+    Returns:
+        tuple: A tuple containing perplexity (H) and the P-row (P).
+    """
+    P = np.exp(-D.copy() * beta)
+    sumP = sum(P)
+    H = np.log(sumP) + beta * np.sum(D * P) / sumP
+    P = P / sumP
+    return H, P
+
+
+def pca(X=np.array([]), no_dims=50):
+    # Runs PCA on the NxD array X in order to reduce its dimensionality to no_dims dimensions.
+    (n, d) = X.shape
+    X = X - np.tile(np.mean(X, 0), (n, 1))
+    (l, M) = np.linalg.eig(np.dot(X.T, X))
+    Y = np.dot(X, M[:, 0:no_dims])
+    return Y
+
+
+def x2p(X=np.array([]), tol=1e-5, perplexity=30.0):
+    """
+        Performs a binary search to get P-values in such a way that each
+        conditional Gaussian has the same perplexity.
+    """
+    (n, d) = X.shape
+    sum_X = np.sum(np.square(X), 1)
+    D = np.add(np.add(-2 * np.dot(X, X.T), sum_X).T, sum_X)
+    P = np.zeros((n, n))
+    beta = np.ones((n, 1))
+    logU = np.log(perplexity)
+
+    # Loop over all datapoints
+    for i in range(n):
+        if i % 100 == 0:
+            print("Computing P-values for point %d of %d..." % (i, n))
+
+        # Compute the Gaussian kernel and entropy for the current precision
+        betamin = -np.inf
+        betamax = np.inf
+        Di = D[i, np.concatenate((np.r_[0:i], np.r_[i+1:n]))]
+        (H, thisP) = Hbeta(Di, beta[i])
+
+        # Evaluate whether the perplexity is within tolerance
+        Hdiff = H - logU
+        tries = 0
+        while np.abs(Hdiff) > tol and tries < 50:
+            # If not, increase or decrease precision
+            if Hdiff > 0:
+                betamin = beta[i].copy()
+                if betamax == np.inf or betamax == -np.inf:
+                    beta[i] = beta[i] * 2.
+                else:
+                    beta[i] = (beta[i] + betamax) / 2.
+            else:
+                betamax = beta[i].copy()
+                if betamin == np.inf or betamin == -np.inf:
+                    beta[i] = beta[i] / 2.
+                else:
+                    beta[i] = (beta[i] + betamin) / 2.
+
+            # Recompute the values
+            (H, thisP) = Hbeta(Di, beta[i])
+            Hdiff = H - logU
+            tries += 1
+
+        # Set the final row of P
+        P[i, np.concatenate((np.r_[0:i], np.r_[i+1:n]))] = thisP
+
+    # Return final P-matrix
+    print("Mean value of sigma: %f" % np.mean(np.sqrt(1 / beta)))
+    return P
+
+
+def tsne(X=np.array([]), no_dims=2, initial_dims=50, perplexity=30.0):
+    """
+        Runs t-SNE on the dataset in the NxD array X to reduce its
+        dimensionality to no_dims dimensions. The syntaxis of the function is
+        `Y = tsne.tsne(X, no_dims, perplexity), where X is an NxD NumPy array.
+    """
+
+    if isinstance(no_dims, float):
+        print("Error: array X should have type float.")
+        return -1
+    if round(no_dims) != no_dims:
+        print("Error: number of dimensions should be an integer.")
+        return -1
+
+    X = pca(X, initial_dims).real
+    (n, d) = X.shape
+    max_iter = 1000
+    initial_momentum = 0.5
+    final_momentum = 0.8
+    eta = 500
+    min_gain = 0.01
+    Y = np.random.randn(n, no_dims)
+    dY = np.zeros((n, no_dims))
+    iY = np.zeros((n, no_dims))
+    gains = np.ones((n, no_dims))
+
+    # Compute P-values
+    P = x2p(X, 1e-5, perplexity)
+    P = P + np.transpose(P)
+    P = P / np.sum(P)
+    P = P * 4.
+    P = np.maximum(P, 1e-12)
+
+    for iter in range(max_iter):
+        # Compute pairwise affinities
+        sum_Y = np.sum(np.square(Y), 1)
+        num = -2. * np.dot(Y, Y.T)
+        num = 1. / (1. + np.add(np.add(num, sum_Y).T, sum_Y)) #
+        num[range(n), range(n)] = 0.
+        Q = num / np.sum(num)
+        Q = np.maximum(Q, 1e-12)
+
+        # Compute gradient
+        PQ = P - Q
+        for i in range(n):
+            dY[i, :] = np.sum(np.tile(PQ[:, i] * num[:, i], (no_dims, 1)).T * (Y[i, :] - Y), 0)
+
+        # Perform the update
+        if iter < 20:
+            momentum = initial_momentum
+        else:
+            momentum = final_momentum
+        gains = (gains + 0.2) * ((dY > 0.) != (iY > 0.)) + \
+                (gains * 0.8) * ((dY > 0.) == (iY > 0.))
+        gains[gains < min_gain] = min_gain
+        iY = momentum * iY - eta * (gains * dY)
+        Y = Y + iY
+        Y = Y - np.tile(np.mean(Y, 0), (n, 1))
+
+        # Compute current value of cost function
+        if (iter + 1) % 10 == 0:
+            C = np.sum(P * np.log(P / Q))
+            print("Iteration %d: error is %f" % (iter + 1, C))
+        if iter == 100:
+            P = P / 4.
+
+    return Y
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from glob import glob
+from tqdm import tqdm
+import sys
+
+def Hbeta(D=np.array([]), beta=1.0):
+    """
+    Compute the perplexity and the P-row for a specific value of the
+    precision of a Gaussian distribution.
+    
+    Args:
+        D (numpy.ndarray): Distance array.
+        beta (float): Precision of the Gaussian distribution.
+        
+    Returns:
+        tuple: A tuple containing perplexity (H) and the P-row (P).
+    """
+    # Compute P-row and corresponding perplexity
+    P = np.exp(-D.copy() * beta)
+    sumP = np.sum(P)
+    H = np.log(sumP) + beta * np.sum(D * P) / sumP
+    P = P / sumP
+    return H, P
+
+
+def pca(X=np.array([]), no_dims=50):
+    """
+    Performs PCA on the NxD array X to reduce its dimensionality to no_dims dimensions.
+    
+    Args:
+        X (numpy.ndarray): Input data array.
+        no_dims (int): Number of dimensions to reduce to.
+        
+    Returns:
+        numpy.ndarray: The reduced data array.
+    """
+    (n, d) = X.shape
+    X = X - np.tile(np.mean(X, axis=0), (n, 1))
+    (l, M) = np.linalg.eig(np.dot(X.T, X))
+    Y = np.dot(X, M[:, 0:no_dims])
+    return Y
+
+
+def x2p(X=np.array([]), tol=1e-5, perplexity=30.0):
+    """
+    Performs a binary search to get P-values such that each
+    conditional Gaussian has the same perplexity.
+    
+    Args:
+        X (numpy.ndarray): Input data array.
+        tol (float): Tolerance for the perplexity.
+        perplexity (float): Desired perplexity.
+        
+    Returns:
+        numpy.ndarray: The P-values matrix.
+    """
+    (n, d) = X.shape
+    sum_X = np.sum(np.square(X), axis=1)
+    D = np.add(np.add(-2 * np.dot(X, X.T), sum_X).T, sum_X)
+    P = np.zeros((n, n))
+    beta = np.ones((n, 1))
+    logU = np.log(perplexity)
+
+    # Loop over all data points
+    for i in range(n):
+        if i % 100 == 0:
+            print(f"Computing P-values for point {i} of {n}...")
+
+        # Compute the Gaussian kernel and entropy for the current precision
+        betamin = -np.inf
+        betamax = np.inf
+        Di = D[i, np.concatenate((np.r_[0:i], np.r_[i+1:n]))]
+        (H, thisP) = Hbeta(Di, beta[i])
+
+        # Evaluate whether the perplexity is within tolerance
+        Hdiff = H - logU
+        tries = 0
+        while np.abs(Hdiff) > tol and tries < 50:
+            # If not, adjust precision
+            if Hdiff > 0:
+                betamin = beta[i].copy()
+                if betamax in [np.inf, -np.inf]:
+                    beta[i] *= 2
+                else:
+                    beta[i] = (beta[i] + betamax) / 2
+            else:
+                betamax = beta[i].copy()
+                if betamin in [np.inf, -np.inf]:
+                    beta[i] /= 2
+                else:
+                    beta[i] = (beta[i] + betamin) / 2
+
+            # Recompute the values
+            (H, thisP) = Hbeta(Di, beta[i])
+            Hdiff = H - logU
+            tries += 1
+
+        # Set the final row of P
+        P[i, np.concatenate((np.r_[0:i], np.r_[i+1:n]))] = thisP
+
+    print("Mean value of sigma: %f" % np.mean(np.sqrt(1 / beta)))
+    return P
+
+
+def tsne(X=np.array([]), no_dims=2, initial_dims=50, perplexity=30.0):
+    """
+    Runs t-SNE on the dataset in the NxD array X to reduce its
+    dimensionality to no_dims dimensions.
+
+    Args:
+        X (numpy.ndarray): Input data array.
+        no_dims (int): Number of dimensions to reduce to.
+        initial_dims (int): Number of initial dimensions.
+        perplexity (float): Desired perplexity.
+        
+    Returns:
+        numpy.ndarray: The reduced data array.
+    """
+    if isinstance(no_dims, float):
+        print("Error: array X should have type float.")
+        return -1
+    if round(no_dims) != no_dims:
+        print("Error: number of dimensions should be an integer.")
+        return -1
+
+    X = pca(X, initial_dims).real
+    (n, d) = X.shape
+    max_iter = 1000
+    initial_momentum = 0.5
+    final_momentum = 0.8
+    eta = 500
+    min_gain = 0.01
+    Y = np.random.randn(n, no_dims)
+    dY = np.zeros((n, no_dims))
+    iY = np.zeros((n, no_dims))
+    gains = np.ones((n, no_dims))
+
+    # Compute P-values
+    P = x2p(X, 1e-5, perplexity)
+    P = P + np.transpose(P)  # Ensure symmetry
+    P = P / np.sum(P)  # Normalize
+    P = P * 4.  # Early exaggeration
+    P = np.maximum(P, 1e-12)  # Avoid numerical issues
+
+    for iter in range(max_iter):
+        # Compute pairwise affinities
+        sum_Y = np.sum(np.square(Y), axis=1)
+        num = -2. * np.dot(Y, Y.T)
+        num = 1. / (1. + np.add(np.add(num, sum_Y).T, sum_Y))
+        num[np.arange(n), np.arange(n)] = 0.  # Avoid self-affinity
+        Q = num / np.sum(num)
+        Q = np.maximum(Q, 1e-12)  # Avoid numerical issues
+
+        # Compute gradient
+        PQ = P - Q
+        for i in range(n):
+            dY[i, :] = np.sum(np.tile(PQ[:, i] * num[:, i], (no_dims, 1)).T * (Y[i, :] - Y), axis=0)
+
+        # Perform the update
+        momentum = initial_momentum if iter < 20 else final_momentum
+        gains = (gains + 0.2) * ((dY > 0.) != (iY > 0.)) + (gains * 0.8) * ((dY > 0.) == (iY > 0.))
+        gains[gains < min_gain] = min_gain
+        iY = momentum * iY - eta * (gains * dY)
+        Y = Y + iY
+        Y -= np.tile(np.mean(Y, axis=0), (n, 1))  # Center the data
+
+        # Compute current value of cost function
+        if (iter + 1) % 10 == 0:
+            C = np.sum(P * np.log(P / Q))
+            print(f"Iteration {iter + 1}: error is {C:.6f}")
+        if iter == 100:
+            P /= 4.  # Decrease early exaggeration
+
+    return Y
+
+
+if __name__ == '__main__':
+    
+    task = sys.argv[2]
+    if sys.argv[1] == "gnss":
+        task_class = {0: 3, 1: 5, 2: 7, 3: 9, 4: 11}
+        colors = {0: "#1f77b4", 1: "#ff7f0e", 2: "#2ca02c", 3: "#d62728", 
+                  4: "#9467bd", 5: "#8c564b", 6: "#e377c2", 7: "#7f7f7f", 
+                  8: "#bcbd22", 9: "#17becf", 10: "#000000"}
+    elif sys.argv[1] == "cifar":
+        task_class = {0: 4, 1: 6, 2: 8, 3: 10}
+        colors = {0: "#1f77b4", 1: "#ff7f0e", 2: "#2ca02c", 3: "#d62728", 
+                  4: "#9467bd", 5: "#8c564b", 6: "#e377c2", 7: "#7f7f7f", 
+                  8: "#bcbd22", 9: "#17becf"}
+    else:
+        raise Exception("Please provide the name of the dataset.")
+
+    # Load embeddings and ground truth of a task
+    emb_file = f"embeddings_{task}.npy"  
+    ground_truth_file = f"predictions_{task}_tr_pr.npy"  
+    points = np.load(emb_file)
+    ground_truth = np.load(ground_truth_file)
+    size = points.shape[1]
+    labels = ground_truth[:, 0]
+
+    # Check if t-SNE embeddings are already computed
+    tsne_file = f"tsne_embeddings/emb_tsne_{task}.npy"
+    if not os.path.isfile(tsne_file):
+        tsne_embs = tsne(points, 2, size, 30.0)
+        np.save(tsne_file, tsne_embs)
+
+    tsne_embs = np.load(tsne_file, allow_pickle=True)
+    x = tsne_embs
+    print('t-SNE embeddings shape:', x.shape)
+    y = labels
+    colors_list = [colors[cy] for cy in y]
+
+    # Plotting the t-SNE results
+    plt.figure(figsize=(5, 4))
+    for key, val in colors.items():
+        if key == task_class[int(task)]:
+            break
+        cur_x = x[y == key]
+        plt.scatter(cur_x[:, 0], cur_x[:, 1], s=8, color=val, label=f"Class: {key}")
+
+    # Add legend and save the plot
+    plt.legend(fontsize=10, loc="lower left", ncol=2, labelspacing=0.03, columnspacing=0.03,
+               handletextpad=0.03)
+    plt.tight_layout()
+    plt.xticks([], [])
+    plt.yticks([], [])
+    plt.savefig(f"tsne_plots/tsne_{task}.pdf", dpi=1200)
+    plt.close()