graft-pytorch 0.1.7__py3-none-any.whl

graft/__init__.py

@@ -0,0 +1,20 @@
+"""
+GRAFT: Gradient-Aware Fast MaxVol Technique for Dynamic Data Sampling
+
+A PyTorch implementation of smart sampling for efficient deep learning training.
+"""
+
+__version__ = "0.1.7"
+__author__ = "Ashish Jha"
+__email__ = "ashish.jha@skoltech.ru"
+
+from .trainer import ModelTrainer, TrainingConfig
+from .decompositions import feature_sel
+from .genindices import sample_selection
+
+__all__ = [
+    "ModelTrainer",
+    "TrainingConfig", 
+    "feature_sel",
+    "sample_selection",
+]

graft/cli.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Command-line interface for GRAFT training.
+"""
+
+import sys
+from .trainer import *
+
+def main():
+    """Main entry point for the CLI."""
+    import argparse
+    from .trainer import TrainingConfig, get_model, prepare_data, ModelTrainer, setup_tracker
+    from .utils.loader import loader
+    
+    # Create argument parser (moved from trainer.py)
+    parser = argparse.ArgumentParser(description="Model Training with smart Sampling")
+    parser.add_argument('--batch_size', default='128', type=int, required=True, help='(default=%(default)s)')
+    parser.add_argument('--numEpochs', default='5', type=int, required=True, help='(default=%(default)s)')
+    parser.add_argument('--numClasses', default='10', type=int, required=True, help='(default=%(default)s)')
+    parser.add_argument('--lr', default='0.001', type=float, required=False, help='learning rate')
+    parser.add_argument('--device', default='cuda', type=str, required=False, help='device to use for decompositions')
+    parser.add_argument('--model', default='resnet50', type=str, required=False, help='model to train')
+    parser.add_argument('--dataset', default="cifar10", type=str, required=False, help='Indicate the dataset')
+    parser.add_argument('--dataset_dir', default="./cifar10", type=str, required=False, help='Imagenet folder')
+    parser.add_argument('--pretrained', default=False, action='store_true', help='use pretrained or not')
+    parser.add_argument('--weight_decay', default=0.0001, type=float, required=False, help='Weight Decay to be used')
+    parser.add_argument('--inp_channels', default="3", type=int, required=False, help='Number of input channels')
+    parser.add_argument('--save_pickle', default=False,  action='store_true', help='to save or not to save U, S, V components')
+    parser.add_argument('--decomp', default="numpy", type=str, required=False, help='To perform SVD using torch or numpy')
+    parser.add_argument('--optimizer', default="sgd", type=str, required=True, help='Choice for optimizer')
+    parser.add_argument('--select_iter', default="50", type=int, required=True, help='Data Selection Iteration')
+    parser.add_argument('--fraction', default="0.50", type=float, required=True, help='fraction of data')
+    parser.add_argument('--grad_clip', default=0.00, type=float, required=False, help='Gradient Clipping Value')
+    parser.add_argument('--warm_start', default=False, action='store_true', help='Train with a warm-start')
+    
+    args = parser.parse_args()
+
+    trainloader, valloader, trainset, valset = loader(
+        dataset=args.dataset, 
+        dirs=args.dataset_dir, 
+        trn_batch_size=args.batch_size, 
+        val_batch_size=args.batch_size, 
+        tst_batch_size=1000
+    )
+
+    config = TrainingConfig.from_args(args)
+    model = get_model(args)
+    data3 = prepare_data(args, trainloader)
+    
+    trainer = ModelTrainer(config, model, trainloader, valloader, trainset, data3)
+    
+    tracker = setup_tracker(args)
+    if tracker:
+        tracker.start()
+    
+    train_stats, val_stats = trainer.train()
+    
+    if tracker:
+        tracker.stop()
+
+if __name__ == '__main__':
+    main()

graft/config.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+
+@dataclass
+class TrainingConfig:
+    model_name: str
+    dataset_name: str
+    num_epochs: int 
+    batch_size: int
+    lr: float
+    device: str
+    optimizer: str
+    weight_decay: float
+    grad_clip: float
+    fraction: float
+    selection_iter: int
+    warm_start: bool
+    sched: str = "cosine"
+    num_workers: int = 4
+    
+    @classmethod
+    def from_args(cls, args):
+        return cls(
+            model_name=args.model,
+            dataset_name=args.dataset,
+            num_epochs=args.numEpochs,
+            batch_size=args.batch_size,
+            lr=args.lr,
+            device=args.device,
+            optimizer=args.optimizer,
+            weight_decay=args.weight_decay,
+            grad_clip=args.grad_clip,
+            fraction=args.fraction,
+            selection_iter=args.select_iter,
+            warm_start=args.warm_start,
+            sched=getattr(args, 'sched', 'cosine')
+        )

graft/decompositions.py

@@ -0,0 +1,54 @@
+import numpy as np
+from tqdm import tqdm
+import torch
+
+def index_sel(vh, r):
+    '''
+    Performs a Maximum Vol Index selection on batch-wise Vt elements from index_decomposition
+    A - is the input matrix (dataset)
+    r - is the desired rank
+    device - cpu or gpu
+    '''
+    # Move input tensor to GPU
+    device = "cuda" if torch.cuda.is_available() and isinstance(vh, torch.Tensor) else "cpu"
+
+    if isinstance(vh, torch.Tensor):
+        V = torch.transpose(vh, 0, 1).to(device)
+        V = V[:, :r]
+        icol = []
+        for i in range(0, r):
+            col_i = torch.where(torch.abs(V) == (torch.max(torch.abs(V[:, i]))))[0]
+            V[:, i+1:] = V[:, i+1:] - (V[:, 0:i+1] @ (torch.pinverse(V[col_i, 0:i+1]) @ V[col_i, i+1:]))
+            icol.append(col_i.cpu().numpy())
+    else:  # Assume numpy array
+        V = np.transpose(vh)
+        V = V[:, :r]
+        icol = []
+        for i in range(0, r):
+            col_i = np.where(np.abs(V) == (np.max(np.abs(V[:, i]))))[0]
+            V[:, i+1:] = V[:, i+1:] - (V[:, 0:i+1] @ (np.linalg.pinv(V[col_i, 0:i+1]) @ V[col_i, i+1:]))
+            icol.append(col_i)
+    return icol
+
+
+
+def feature_sel(trainloader, batch_size, device, decomp_type="numpy"):
+    '''
+    Performs a SVD Decomposition of each batch using either torch or numpy.
+    trainloader - the input trainloader on which training will be performed
+    batch_size - batch_size used for training(Note: training batch size and decomposition batch_size should be same)
+    device - "cuda" can only be used with torch (if the device is "cuda" and decomp_type is numpy "cpu" will be used by default.)
+    decomp_type - perform decomposition using "torch" or "numpy")
+    '''
+    V_list = []
+    for _, (trainsamples, _) in enumerate(tqdm(trainloader)):
+        
+        if decomp_type == "torch":
+            _, _, Vt = torch.linalg.svd(torch.reshape(trainsamples.to(device),(-1, trainsamples.shape[0])),full_matrices=False)
+        else:
+            _, _, Vt = np.linalg.svd(np.reshape(trainsamples.cpu().numpy(),(-1,trainsamples.shape[0])),full_matrices=False)
+        
+        V_list.append(Vt)
+        
+    return V_list
+        

graft/genindices.py

@@ -0,0 +1,122 @@
+import torch
+import itertools
+from .decompositions import index_sel
+from tqdm import tqdm
+from .grad_dist import calnorm
+import numpy as np
+import math
+import gc
+
+
+def process_indices(indices):
+    '''
+    Processes indices to generate a list of cumulative indices
+    '''
+
+    l2 = indices[0]
+    for i in range(len(indices) - 1):
+        l2 = l2 + list(np.array(l2[-1]) + np.array(indices[i + 1]))
+
+    return l2
+
+
+def sample_selection(trainloader, data3, net, clone_dict, batch_size, fraction, sel_iter, numEpochs, device, dataset_name):
+    # Note: Seeds should be set by the caller for reproducibility
+    
+    if dataset_name.lower() == 'boston':
+        loss_fn = torch.nn.MSELoss(reduction='mean')
+    else:
+        loss_fn = torch.nn.functional.cross_entropy
+    assert numEpochs > sel_iter, "Number of Epochs must be greater than sel_iter"
+    indices = []
+    l2 = []    
+    len_ranks = batch_size * fraction
+    min_range = int(len_ranks - (len_ranks * fraction))
+    max_range = int(len_ranks + (len_ranks * fraction))
+    
+    if max_range - min_range < 1:
+        ranks = np.arange((1, max_range),1, dtype=int)
+        num_selections = int(numEpochs / sel_iter)
+        candidates = ranks
+    else:    
+        ranks = np.arange(min_range, max_range, 1, dtype=int)
+        num_selections = int(numEpochs / sel_iter)
+        candidates = math.ceil(len(ranks) / num_selections)
+    
+    candidate_ranks = list(np.random.choice(list(ranks), size=candidates, replace=False))
+    if len(candidate_ranks) > 3:
+        candidate_ranks = list(np.random.choice(list(candidate_ranks), size=3, replace=False))
+    print("current selected rank candidates:", candidate_ranks)
+
+    
+    # Add success status tracking
+    total_samples = len(trainloader.dataset)
+    selected_count = 0
+    success_rate = 0.0
+    
+    for _, ((trainsamples, labels), V) in enumerate(tqdm(zip(trainloader, data3), desc="Sample Selection")):
+        
+        net.load_state_dict(clone_dict)
+        trainsamples = trainsamples.to(device)
+        labels = labels.to(device)
+        
+        
+        A = np.reshape(trainsamples.detach().cpu().numpy(),(-1,trainsamples.shape[0]))
+        out, _ = net(trainsamples, last=True, freeze=True)
+        
+        
+        loss = loss_fn(out, labels).sum()
+        l0_grad = torch.autograd.grad(loss, out)[0]
+        distance_dict = {}
+        for ranks in candidate_ranks:
+            net.load_state_dict(clone_dict)
+            idx2 = index_sel(V,  min(ranks, A.shape[1]))
+            idx2 = list(set((itertools.chain(*idx2))))
+            if dataset_name == "boston":
+                out_idx, _ = net(trainsamples[idx2,:], last=True, freeze=True)
+            else:
+                out_idx, _ = net(trainsamples[idx2,:,:,:], last=True, freeze=True)
+            loss_idx = loss_fn(out_idx, labels[idx2]).sum()
+            l0_idx_grad = torch.autograd.grad(loss_idx, out_idx)[0]
+            distance = calnorm(l0_idx_grad, l0_grad)
+            distance_dict[tuple(idx2)] = distance 
+    
+        indices.append(list(min(distance_dict, key=distance_dict.get)))
+        selected_count += len(idx2)
+        success_rate = (selected_count / total_samples) * 100
+        
+    print(f"Sample Selection Complete - Selected {selected_count}/{total_samples} samples ({success_rate:.2f}%)")
+    
+    del clone_dict
+    del net
+    torch.cuda.empty_cache()    
+    gc.collect()
+
+    # Process collected indices
+    batch_indices = []
+    total_indices = []
+    
+    for batch_idx in indices:
+        if isinstance(batch_idx, list):
+            batch_indices.extend(batch_idx)
+        else:
+            batch_indices.append(batch_idx)
+    
+    # Convert to occurrence count/scores
+    unique_indices = np.unique(batch_indices)
+    scores = np.zeros(len(trainloader.dataset))
+    for idx in batch_indices:
+        scores[idx] += 1
+    
+    # Select top fraction based on scores
+    num_to_select = int(len(trainloader.dataset) * fraction)
+    selected_indices = np.argsort(scores)[::-1][:num_to_select]
+    
+    # Ensure we have exactly the right number of unique indices
+    selected_indices = np.unique(selected_indices)[:num_to_select]
+    
+    final_success_rate = (len(selected_indices) / len(trainloader.dataset)) * 100
+    print(f"Final Selection - Kept {len(selected_indices)}/{len(trainloader.dataset)} samples ({final_success_rate:.2f}%)")
+    
+    return selected_indices
+

graft/grad_dist.py

@@ -0,0 +1,20 @@
+
+import torch
+import numpy as np
+import warnings
+
+# Suppress specific NumPy 2.0 warnings for backward compatibility
+warnings.filterwarnings("ignore", message="__array_wrap__ must accept context and return_scalar arguments")
+
+def calnorm(idxgrads, fgrads):
+    # Keep everything in PyTorch to avoid NumPy 2.0 warnings
+    ss_grad = torch.transpose(idxgrads.clone().detach().cpu(), 0, 1)
+    b_ = fgrads.sum(dim=0).detach().cpu()
+    
+    # Use PyTorch's pinverse instead of NumPy
+    pinverse = torch.pinverse(ss_grad.float())
+    x = torch.matmul(pinverse, b_.float())
+    
+    # Calculate residual norm
+    norm_residual = torch.norm(torch.matmul(ss_grad.float(), x) - b_.float())
+    return norm_residual

graft/models/BERT_model.py

@@ -0,0 +1,40 @@
+from transformers import AutoModelForSequenceClassification
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class bertmodel(nn.Module):
+    def __init__(self, device, numlabels=2):
+        super(bertmodel, self).__init__()
+        self.model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=numlabels)
+        self.device = device
+            
+    def forward(self, x, indices, last=False, freeze=False):
+        if freeze and last and not indices:
+            for param in self.model.parameters():
+                param.requires_grad = False
+            for param in self.model.classifier.parameters():
+                param.requires_grad = True
+            
+            output = self.model(x["input_ids"].to(self.device), 
+                        attention_mask=x["attention_mask"].to(self.device), labels=x["label"].to(self.device))
+        elif freeze and last and indices:
+            for param in self.model.parameters():
+                param.requires_grad = False
+            for param in self.model.classifier.parameters():
+                param.requires_grad = True
+            
+            output = self.model(x["input_ids"][indices].to(self.device), 
+                        attention_mask=x["attention_mask"][indices].to(self.device), labels=x["label"][indices].to(self.device))
+            
+        else:
+#             for param in self.model.parameters():
+#                 param.requires_grad = True
+            output = self.model(x["input_ids"].to(self.device), 
+                        attention_mask=x["attention_mask"].to(self.device), labels=x["label"].to(self.device))
+         
+            
+        return output
+        
+   

graft/models/MobilenetV2.py

@@ -0,0 +1,111 @@
+'''MobileNetV2 in PyTorch.
+
+Reference
+    Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification, Detection and Segmentation
+    https://arxiv.org/abs/1801.04381
+'''
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Block(nn.Module):
+    '''expand + depthwise + pointwise'''
+    
+    def __init__(self, in_planes, out_planes, expansion, stride):
+        super(Block, self).__init__()
+        self.stride = stride
+
+        planes = expansion * in_planes
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, stride=1, padding=0, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, groups=planes, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, out_planes, kernel_size=1, stride=1, padding=0, bias=False)
+        self.bn3 = nn.BatchNorm2d(out_planes)
+
+        self.shortcut = nn.Sequential()
+        if stride == 1 and in_planes != out_planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=1, padding=0, bias=False),
+                nn.BatchNorm2d(out_planes),
+            )
+
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = F.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        out = out + self.shortcut(x) if self.stride==1 else out
+        return out
+
+
+class MobileNetV2(nn.Module):
+    # (expansion, out_planes, num_blocks, stride)
+    cfg = [(1,  16, 1, 1),
+           (6,  24, 2, 1),  # NOTE: change stride 2 -> 1 for CIFAR10
+           (6,  32, 3, 2),
+           (6,  64, 4, 2),
+           (6,  96, 3, 1),
+           (6, 160, 3, 2),
+           (6, 320, 1, 1)]
+
+
+    def __init__(self, num_classes=10):
+        super(MobileNetV2, self).__init__()
+        self.embDim = 1280
+        
+        # NOTE: change conv1 stride 2 -> 1 for CIFAR10
+        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(32)
+        self.layers = self._make_layers(in_planes=32)
+        self.conv2 = nn.Conv2d(320, 1280, kernel_size=1, stride=1, padding=0, bias=False)
+        self.bn2 = nn.BatchNorm2d(1280)
+        self.linear = nn.Linear(1280, num_classes)
+
+
+    def _make_layers(self, in_planes):
+        layers = []
+        for expansion, out_planes, num_blocks, stride in self.cfg:
+            strides = [stride] + [1]*(num_blocks-1)
+            for stride in strides:
+                layers.append(Block(in_planes, out_planes, expansion, stride))
+                in_planes = out_planes
+        return nn.Sequential(*layers)
+
+
+    def forward(self, x, last=False, freeze=False):
+        if freeze:
+            with torch.no_grad():
+                out = F.relu(self.bn1(self.conv1(x)))
+                out = self.layers(out)
+                out = F.relu(self.bn2(self.conv2(out)))
+                # NOTE: change pooling kernel_size 7 -> 4 for CIFAR10
+                out = F.avg_pool2d(out, 4)
+                e = out.view(out.size(0), -1)
+        else:
+            out = F.relu(self.bn1(self.conv1(x)))
+            out = self.layers(out)
+            out = F.relu(self.bn2(self.conv2(out)))
+            # NOTE: change pooling kernel_size 7 -> 4 for CIFAR10
+            out = F.avg_pool2d(out, 4)
+            e = out.view(out.size(0), -1)
+        out = self.linear(e)
+        if last:
+            return out, e
+        else:
+            return out
+
+    def get_embedding_dim(self):
+        return self.embDim
+
+
+def test():
+    net = MobileNetV2()
+    x = torch.randn(2, 3, 32, 32)
+    y = net(x)
+    print(y.size())
+
+# test()

graft/models/ResNeXt.py

@@ -0,0 +1,154 @@
+"""
+ResNeXt is a simple, highly modularized network architecture for image classification. The
+network is constructed by repeating a building block that aggregates a set of transformations 
+with the same topology. The simple design results in a homogeneous, multi-branch architecture 
+that has only a few hyper-parameters to set. This strategy exposes a new dimension, which is 
+referred as “cardinality” (the size of the set of transformations), as an essential factor in 
+addition to the dimensions of depth and width.
+
+We can think of cardinality as the set of separate conv block representing same complexity as 
+when those blocks are combined together to make a single block.
+
+Blog: https://towardsdatascience.com/review-resnext-1st-runner-up-of-ilsvrc-2016-image-classification-15d7f17b42ac
+
+#### Citation ####
+
+PyTorch Code: https://github.com/prlz77/ResNeXt.pytorch
+
+@article{Xie2016,
+  title={Aggregated Residual Transformations for Deep Neural Networks},
+  author={Saining Xie and Ross Girshick and Piotr Dollár and Zhuowen Tu and Kaiming He},
+  journal={arXiv preprint arXiv:1611.05431},
+  year={2016}
+}
+
+"""
+
+import torch.nn as nn
+import torch.nn.functional as F
+import torch
+
+
+class Block(nn.Module):
+    expansion = 2  
+    """
+    '''Grouped convolution block.'''
+    groups: Integer 
+    It controls the connections between inputs and outputs. in_channels and out_channels must 
+    both be divisible by groups. For example,
+
+    At groups=1, all inputs are convolved to all outputs.
+    At groups=2, the operation becomes equivalent to having two conv layers side by side, each 
+    seeing half the input channels and producing half the output channels, and both subsequently 
+    concatenated.
+    At groups= in_channels, each input channel is convolved with its own set of filters 
+    (of size (out_channels/in_channels))
+
+    group parameter in Conv2d, splits the output_channel by cardinality.
+
+    """
+  
+    def __init__(self, in_planes, cardinality=32, bottleneck_width=4, stride=1):
+        super(Block, self).__init__()
+        group_width = cardinality * bottleneck_width
+        self.conv1 = nn.Conv2d(in_planes, group_width, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(group_width)
+        """group=cardinality, it divides the out_channel by 32(cardinality) i.e. thus, divides channel 128 into 4"""
+        self.conv2 = nn.Conv2d(group_width, group_width, kernel_size=3, stride=stride, padding=1, groups=cardinality, bias=False)
+        self.bn2 = nn.BatchNorm2d(group_width)
+        self.conv3 = nn.Conv2d(group_width, self.expansion*group_width, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(self.expansion*group_width)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion*group_width:
+            self.shortcut = nn.Sequential(
+              nn.Conv2d(in_planes, self.expansion*group_width, kernel_size=1, stride=stride, bias=False),
+              nn.BatchNorm2d(self.expansion*group_width)
+          )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = F.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class ResNeXt(nn.Module):
+    def __init__(self, input_channel, num_blocks, cardinality, bottleneck_width, n_classes=10):
+        super(ResNeXt, self).__init__()
+        self.cardinality = cardinality
+        self.bottleneck_width = bottleneck_width
+        self.in_planes = 64
+
+        self.conv1 = nn.Conv2d(input_channel, 64, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.layer1 = self._make_layer(num_blocks[0], 1)
+        self.layer2 = self._make_layer(num_blocks[1], 2)
+        self.layer3 = self._make_layer(num_blocks[2], 2)
+        # self.layer4 = self._make_layer(num_blocks[3], 2)
+        self.pool = nn.AdaptiveAvgPool2d(1)
+        self.linear = nn.Linear(cardinality*bottleneck_width*8, n_classes)
+
+    def _make_layer(self, num_blocks, stride):
+        strides = [stride] + [1]*(num_blocks-1)
+        layers = []
+        for stride in strides:
+            layers.append(Block(self.in_planes, self.cardinality, self.bottleneck_width, stride))
+            self.in_planes = Block.expansion * self.cardinality * self.bottleneck_width
+        # Increase bottleneck_width by 2 after each stage.
+        self.bottleneck_width *= 2
+        return nn.Sequential(*layers)
+
+#     def forward(self, x):
+#         out = F.relu(self.bn1(self.conv1(x)))
+#         out = self.layer1(out)
+#         out = self.layer2(out)
+#         out = self.layer3(out)
+#         # out = self.layer4(out)
+#         out = self.pool(out)
+#         out = out.view(out.size(0), -1)
+#         out = self.linear(out)
+#         return out
+    
+    def forward(self, x, last=False, freeze=False):
+        if freeze:
+            with torch.no_grad():
+                out = F.relu(self.bn1(self.conv1(x)))
+                out = self.layer1(out)
+                out = self.layer2(out)
+                out = self.layer3(out)
+                
+#                 out = F.relu(self.bn2(self.conv2(out)))
+                # NOTE: change pooling kernel_size 7 -> 4 for CIFAR10
+                out = self.pool(out)
+                e = out.view(out.size(0), -1)
+        else:
+            out = F.relu(self.bn1(self.conv1(x)))
+            out = self.layer1(out)
+            out = self.layer2(out)
+            out = self.layer3(out)
+#             out = F.relu(self.bn2(self.conv2(out)))
+            # NOTE: change pooling kernel_size 7 -> 4 for CIFAR10
+            out = self.pool(out)
+            e = out.view(out.size(0), -1)
+        out = self.linear(e)
+        if last:
+            return out, e
+        else:
+            return out
+
+
+
+def ResNeXt29_2x64d(input_channel, n_classes):
+    return ResNeXt(input_channel=input_channel, num_blocks=[3,3,3], cardinality=2, bottleneck_width=64, n_classes=n_classes)
+
+def ResNeXt29_4x64d(input_channel, n_classes):
+    return ResNeXt(input_channel, num_blocks=[3,3,3], cardinality=4, bottleneck_width=64, n_classes=n_classes)
+
+def ResNeXt29_8x64d(input_channel, n_classes):
+    return ResNeXt(input_channel, num_blocks=[3,3,3], cardinality=8, bottleneck_width=64, n_classes=n_classes)
+
+def ResNeXt29_32x4d(input_channel, n_classes):
+    return ResNeXt(input_channel, num_blocks=[3,3,3], cardinality=32, bottleneck_width=4, n_classes=n_classes)

graft/models/__init__.py

@@ -0,0 +1,22 @@
+from .efficientnet import EfficientNetB0
+from .efficientnetb7 import EfficientNet
+from .ResNeXt import ResNeXt29_2x64d 
+from .ResNeXt import ResNeXt29_4x64d
+from .ResNeXt import ResNeXt29_8x64d
+from .ResNeXt import ResNeXt29_32x4d
+from .resnet import ResNext50_32x4d
+from .resnet import ResNext101_32x8d
+from .resnet import ResNext101_64x4d
+from .mobilenet import MobileNet
+from .MobilenetV2 import MobileNetV2
+from .resnet import ResNet18
+from .resnet import ResNet34
+from .resnet import ResNet50
+from .resnet import ResNet101
+from .resnet import ResNet152
+from .resnet9 import ResNet9
+from .fashioncnn import FashionCNN
+# from .regression import TwoLayerNet
+# from .regression import ThreeLayerNet
+from .BERT_model import bertmodel
+# from .regression import DualNet