Add model definitions

benchmarks/cifar/models/cnncert.py

@@ -0,0 +1,36 @@
+import torch
+import torch.nn as nn
+
+def tanh_5layer_5_3():
+    layers = [
+        nn.Conv2d(3, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Flatten(start_dim=1, end_dim=-1),
+        nn.Linear(in_features=2880, out_features=10, bias=True),
+    ]
+    return nn.Sequential(*layers)
+
+def tanh_7layer_5_3():
+    layers = [
+        nn.Conv2d(3, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Conv2d(5, 5, kernel_size=(3, 3)),
+        nn.Tanh(),
+        nn.Flatten(start_dim=1, end_dim=-1),
+        nn.Linear(in_features=2000, out_features=10, bias=True),
+    ]
+    return nn.Sequential(*layers)

benchmarks/cifar/models/gelu.py

@@ -0,0 +1,43 @@
+import torch.nn as nn
+import numpy as np
+import torch
+
+class GELUOp(torch.autograd.Function):
+    @staticmethod
+    def symbolic(g, x):
+        return g.op('custom::Gelu', x)
+
+    @staticmethod
+    def forward(ctx, x):
+        ctx.save_for_backward(x)
+        return torch.nn.functional.gelu(x)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        x, = ctx.saved_tensors
+        grad_input = grad_output.clone()
+        grad = 0.5 * (1 + torch.erf(x / np.sqrt(2))) + x * torch.exp(-0.5 * x ** 2) / np.sqrt(2 * torch.pi)
+        return grad_input * grad
+
+class GELU(nn.Module):
+    def forward(self, x):
+        return GELUOp.apply(x)
+
+def gelu_fc(in_ch=3, in_dim=32, width=100, depth=4, omega=0.3, num_classes=10):
+    layers = [nn.Flatten(), nn.Linear(in_ch*in_dim**2, width), GELU()]
+    for _ in range(depth - 1):
+        layers.extend([nn.Linear(width, width), GELU()])
+    layers.append(nn.Linear(width, num_classes))
+    return nn.Sequential(*layers)
+
+
+def gelu_4fc_100(in_ch=3, in_dim=32):
+    return gelu_fc(in_ch, in_dim, width=100, depth=4)
+
+
+def gelu_4fc_200(in_ch=3, in_dim=32):
+    return gelu_fc(in_ch, in_dim, width=200, depth=4)
+
+
+def gelu_4fc_500(in_ch=3, in_dim=32):
+    return gelu_fc(in_ch, in_dim, width=500, depth=4)

benchmarks/cifar/models/lstm.py

@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+
+
+class LSTM(nn.Module):
+    def __init__(self, in_channels=3, width=100, patch_size=8, num_classes=10):
+        super().__init__()
+
+        self.patch_size = patch_size
+        self.width = width
+        self.num_classes = num_classes
+
+        self.projection = nn.Conv2d(
+            in_channels, width, kernel_size=patch_size, stride=patch_size)
+        self.cell_f = nn.LSTMCell(width, width)
+        self.fc = nn.Linear(width, num_classes)
+
+    def forward(self, x):
+        embed = self.projection(x)
+        embed = torch.flatten(embed, 2).permute(0, 2, 1)
+        h_f = torch.zeros(x.shape[0], self.width, device=x.device)
+        c_f = h_f.clone()
+        for i in range(embed.shape[1]):
+            h_f, c_f = self.cell_f(embed[:, i], (h_f, c_f))
+        logits = self.fc(h_f)
+        return logits
+
+
+def LSTM_patch_16_32(in_ch=3, in_dim=32):
+    assert in_ch == 3 and in_dim == 32
+    return LSTM(width=32, patch_size=16)
+
+def LSTM_patch_16_64(in_ch=3, in_dim=32):
+    assert in_ch == 3 and in_dim == 32
+    return LSTM(width=64, patch_size=16)

benchmarks/cifar/models/resnet2b_gelu.py

@@ -0,0 +1,150 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+
+class GELUOp(torch.autograd.Function):
+    @staticmethod
+    def symbolic(g, x):
+        return g.op('custom::Gelu', x)
+
+    @staticmethod
+    def forward(ctx, x):
+        ctx.save_for_backward(x)
+        return torch.nn.functional.gelu(x)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        x, = ctx.saved_tensors
+        grad_input = grad_output.clone()
+        grad = 0.5 * (1 + torch.erf(x / np.sqrt(2))) + x * torch.exp(-0.5 * x ** 2) / np.sqrt(2 * torch.pi)
+        return grad_input * grad
+
+def gelu(x):
+    return GELUOp.apply(x)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1, bn=True, kernel=3, part_gelu=False):
+        super(BasicBlock, self).__init__()
+        self.bn = bn
+        if part_gelu:
+            self.act = F.relu
+        else:
+            self.act = gelu
+        if kernel == 3:
+            self.conv1 = nn.Conv2d(
+                in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=(not self.bn))
+            if self.bn:
+                self.bn1 = nn.BatchNorm2d(planes)
+            self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                                   stride=1, padding=1, bias=(not self.bn))
+        elif kernel == 2:
+            self.conv1 = nn.Conv2d(
+                in_planes, planes, kernel_size=2, stride=stride, padding=1, bias=(not self.bn))
+            if self.bn:
+                self.bn1 = nn.BatchNorm2d(planes)
+            self.conv2 = nn.Conv2d(planes, planes, kernel_size=2,
+                                   stride=1, padding=0, bias=(not self.bn))
+        elif kernel == 1:
+            self.conv1 = nn.Conv2d(
+                in_planes, planes, kernel_size=1, stride=stride, padding=0, bias=(not self.bn))
+            if self.bn:
+                self.bn1 = nn.BatchNorm2d(planes)
+            self.conv2 = nn.Conv2d(planes, planes, kernel_size=1,
+                                   stride=1, padding=0, bias=(not self.bn))
+        else:
+            exit("kernel not supported!")
+
+        if self.bn:
+            self.bn2 = nn.BatchNorm2d(planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion*planes:
+            if self.bn:
+                self.shortcut = nn.Sequential(
+                    nn.Conv2d(in_planes, self.expansion*planes,
+                              kernel_size=1, stride=stride, bias=(not self.bn)),
+                    nn.BatchNorm2d(self.expansion*planes)
+                )
+            else:
+                self.shortcut = nn.Sequential(
+                    nn.Conv2d(in_planes, self.expansion*planes,
+                              kernel_size=1, stride=stride, bias=(not self.bn)),
+                )
+
+    def forward(self, x):
+        if self.bn:
+            out = self.act(self.bn1(self.conv1(x)))
+            out = self.bn2(self.conv2(out))
+        else:
+            out = self.act(self.conv1(x))
+            out = self.conv2(out)
+        out += self.shortcut(x)
+        out =  self.act(out)
+        return out
+
+
+
+class ResNet5(nn.Module):
+    def __init__(self, block, num_blocks=2, num_classes=10, in_planes=64, bn=True, last_layer="avg", part_gelu=False):
+        super(ResNet5, self).__init__()
+        self.in_planes = in_planes
+        self.bn = bn
+        self.last_layer = last_layer
+        if part_gelu:
+            self.act = F.relu
+        else:
+            self.act = gelu
+        self.conv1 = nn.Conv2d(3, in_planes, kernel_size=3,
+                               stride=2, padding=1, bias=not self.bn)
+        if self.bn: self.bn1 = nn.BatchNorm2d(in_planes)
+        self.layer1 = self._make_layer(block, in_planes*2, num_blocks, stride=2, bn=bn, kernel=3, part_gelu=part_gelu)
+        if self.last_layer == "avg":
+            self.avg2d = nn.AvgPool2d(4)
+            self.linear = nn.Linear(in_planes * 8 * block.expansion, num_classes)
+        elif self.last_layer == "dense":
+            self.linear1 = nn.Linear(in_planes * 8 * block.expansion * 16, 100)
+            self.linear2 = nn.Linear(100, num_classes)
+        else:
+            exit("last_layer type not supported!")
+
+    def _make_layer(self, block, planes, num_blocks, stride, bn, kernel, part_gelu):
+        strides = [stride] + [1]*(num_blocks-1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride, bn, kernel, part_gelu))
+            self.in_planes = planes * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        if self.bn:
+            out = self.act(self.bn1(self.conv1(x)))
+        else:
+            out = self.act(self.conv1(x))
+        out = self.layer1(out)
+        if self.last_layer == "avg":
+            out = self.avg2d(out)
+            out = torch.flatten(out, 1)
+            out = self.linear(out)
+        elif self.last_layer == "dense":
+            out = torch.flatten(out, 1)
+            out = gelu(self.linear1(out))
+            out = self.linear2(out)
+        return out
+
+
+def resnet2b_gelu_4():
+    return ResNet5(BasicBlock, num_blocks=2, in_planes=4, bn=False, last_layer="dense")
+
+def resnet2b_gelu_8():
+    return ResNet5(BasicBlock, num_blocks=2, in_planes=8, bn=False, last_layer="dense")
+
+def resnet2b_part_gelu_4():
+    return ResNet5(BasicBlock, num_blocks=2, in_planes=4, bn=False, last_layer="dense", part_gelu=True)
+
+def resnet2b_part_gelu_8():
+    return ResNet5(BasicBlock, num_blocks=2, in_planes=8, bn=False, last_layer="dense", part_gelu=True)

benchmarks/cifar/models/sigmoid.py

@@ -0,0 +1,25 @@
+import torch.nn as nn
+
+
+def sigmoid_fc(in_ch=3, in_dim=32, width=100, depth=4, num_classes=10):
+    layers = [nn.Flatten(), nn.Linear(in_ch*in_dim**2, width), nn.Sigmoid()]
+    for _ in range(depth - 1):
+        layers.extend([nn.Linear(width, width), nn.Sigmoid()])
+    layers.append(nn.Linear(width, num_classes))
+    return nn.Sequential(*layers)
+
+
+def sigmoid_4fc_100(in_ch=3, in_dim=32):
+    return sigmoid_fc(in_ch, in_dim, width=100, depth=4)
+
+
+def sigmoid_4fc_500(in_ch=3, in_dim=32):
+    return sigmoid_fc(in_ch, in_dim, width=500, depth=4)
+
+
+def sigmoid_6fc_100(in_ch=3, in_dim=32):
+    return sigmoid_fc(in_ch, in_dim, width=100, depth=6)
+
+
+def sigmoid_6fc_200(in_ch=3, in_dim=32):
+    return sigmoid_fc(in_ch, in_dim, width=200, depth=6)

benchmarks/cifar/models/sin.py

@@ -0,0 +1,42 @@
+import torch.nn as nn
+import torch
+
+class Sin_layer(nn.Module):
+    def __init__(self, omega=0.3):
+        super().__init__()
+        self.omega = omega
+
+    def forward(self, x):
+        return torch.sin(self.omega * x)
+
+
+def sin_fc(in_ch=3, in_dim=32, width=100, depth=4, num_classes=10):
+    layers = [nn.Flatten(), nn.Linear(in_ch*in_dim**2, width), Sin_layer()]
+    for _ in range(depth - 1):
+        layers.extend([nn.Linear(width, width), Sin_layer()])
+    layers.append(nn.Linear(width, num_classes))
+    return nn.Sequential(*layers)
+
+def sin_fc_sigmoid(in_ch=3, in_dim=32, width=100, depth=4, omega=0.3, num_classes=10):
+    layers = [nn.Flatten(), nn.Linear(in_ch*in_dim**2, width), nn.Sigmoid()]
+    for _ in range(depth - 2):
+        layers.extend([nn.Linear(width, width), Sin_layer(omega=omega)])
+    layers.extend([nn.Linear(width, width), nn.Sigmoid()])
+    layers.append(nn.Linear(width, num_classes))
+    return nn.Sequential(*layers)
+
+
+def sin_4fc_100(in_ch=3, in_dim=32):
+    return sin_fc(in_ch, in_dim, width=100, depth=4)
+
+
+def sin_4fc_100_sigmoid(in_ch=3, in_dim=32):
+    return sin_fc_sigmoid(in_ch, in_dim, width=100, depth=4, omega=1)
+
+
+def sin_4fc_200(in_ch=3, in_dim=32):
+    return sin_fc(in_ch, in_dim, width=200, depth=4)
+
+
+def sin_4fc_500(in_ch=3, in_dim=32):
+    return sin_fc(in_ch, in_dim, width=500, depth=4)

benchmarks/cifar/models/tanh.py

@@ -0,0 +1,18 @@
+import torch.nn as nn
+
+
+def tanh_fc(in_ch=3, in_dim=32, width=100, depth=4, num_classes=10):
+    layers = [nn.Flatten(), nn.Linear(in_ch*in_dim**2, width), nn.Tanh()]
+    for _ in range(depth - 1):
+        layers.extend([nn.Linear(width, width), nn.Tanh()])
+    layers.append(nn.Linear(width, num_classes))
+    return nn.Sequential(*layers)
+
+
+def tanh_4fc_100(in_ch=3, in_dim=32):
+    return tanh_fc(in_ch, in_dim, width=100, depth=4)
+
+
+def tanh_6fc_100(in_ch=3, in_dim=32):
+    return tanh_fc(in_ch, in_dim, width=100, depth=6)
+

benchmarks/cifar/models/vit.py

@@ -0,0 +1,200 @@
+import torch
+import torch.nn.functional as F
+from torch import nn
+import math
+from torch import Tensor
+
+
+class Reduce(nn.Module):
+    def forward(self, x):
+        return x.mean(dim=1)
+
+
+class PatchEmbedding(nn.Module):
+    def __init__(self, in_channels: int = 3, patch_size: int = 16, emb_size: int = 768, img_size: int = 224):
+        self.patch_size = patch_size
+        super().__init__()
+        self.projection = nn.Conv2d(in_channels, emb_size, kernel_size=patch_size, stride=patch_size)
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, emb_size))
+        self.positions = nn.Parameter(torch.zeros((img_size // patch_size) * (img_size // patch_size) + 1, emb_size))
+
+        
+    def forward(self, x: Tensor) -> Tensor:
+        b, _, _, _ = x.shape
+        x = self.projection(x)
+        x = x.flatten(2).transpose(1, 2)
+        cls_tokens = self.cls_token.expand(b, -1, -1)
+        # prepend the cls token to the input
+        x = torch.cat([cls_tokens, x], dim=1)
+        # add position embedding
+        x += self.positions
+        return x
+
+
+class MultiHeadAttention(nn.Module):
+    def __init__(self, d_model = 123, num_heads = 6, dropout = 0.):
+        super().__init__()
+        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
+        
+        self.d_model = d_model
+        self.num_heads = num_heads
+        self.head_dim = d_model // num_heads
+        
+        self.query = nn.Linear(d_model, d_model)
+        self.key = nn.Linear(d_model, d_model)
+        self.value = nn.Linear(d_model, d_model)
+        self.out = nn.Linear(d_model, d_model)
+        
+        self.dropout = nn.Dropout(dropout)
+        
+    def split_heads(self, x, batch_size):
+        x = x.view(batch_size, -1, self.num_heads, self.head_dim)
+        return x.transpose(1, 2)
+        
+    def forward(self, x):
+        batch_size = x.size(0)
+        
+        query = self.query(x)
+        key = self.key(x)
+        value = self.value(x)
+        
+        query = self.split_heads(query, batch_size)
+        key = self.split_heads(key, batch_size)
+        value = self.split_heads(value, batch_size)
+        
+        scores = torch.matmul(query, key.transpose(-2, -1))
+        scores = scores / 8
+        
+        attn_weights = F.softmax(scores, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+        
+        attn_output = torch.matmul(attn_weights, value)
+        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
+        attn_output = self.out(attn_output)
+        
+        return attn_output
+
+
+class ResidualAdd(nn.Module):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+        
+    def forward(self, x, **kwargs):
+        res = x
+        x = self.fn(x, **kwargs)
+        x += res
+        return x
+
+
+class FeedForwardBlock(nn.Sequential):
+    def __init__(self, emb_size: int, expansion: int = 2, drop_p: float = 0.):
+        super().__init__(
+            nn.Linear(emb_size, expansion * emb_size),
+            nn.ReLU(),
+            nn.Dropout(drop_p),
+            nn.Linear(expansion * emb_size, emb_size),
+        )
+
+
+class TransformerEncoderBlock(nn.Sequential):
+    def __init__(self,
+                 emb_size: int = 768,
+                 drop_p: float = 0.,
+                 forward_expansion: int = 2,
+                 forward_drop_p: float = 0.,
+                 ** kwargs):
+        super().__init__(
+            ResidualAdd(nn.Sequential(
+                nn.LayerNorm(emb_size),
+                MultiHeadAttention(emb_size, **kwargs),
+                nn.Dropout(drop_p)
+            )),
+            ResidualAdd(nn.Sequential(
+                nn.LayerNorm(emb_size),
+                FeedForwardBlock(
+                    emb_size, expansion=forward_expansion, drop_p=forward_drop_p),
+                nn.Dropout(drop_p)
+            )
+            ))
+
+
+class TransformerEncoder(nn.Sequential):
+    def __init__(self, depth: int = 1, **kwargs):
+        super().__init__(*[TransformerEncoderBlock(**kwargs) for _ in range(depth)])
+
+
+class ClassificationHead(nn.Sequential):
+    def __init__(self, emb_size: int = 768, n_classes: int = 1000):
+        super().__init__(
+            Reduce(),
+            nn.LayerNorm(emb_size), 
+            nn.Linear(emb_size, n_classes))
+
+
+class ViT_1_3(nn.Sequential):
+    def __init__(self,     
+                in_channels: int = 3,
+                num_heads: int = 3,
+                patch_size: int = 16,
+                emb_size: int = 48,
+                img_size: int = 32,
+                depth: int = 1,
+                n_classes: int = 10,
+                **kwargs):
+        super().__init__(
+            PatchEmbedding(in_channels, patch_size, emb_size, img_size),
+            TransformerEncoder(depth, emb_size=emb_size, num_heads=num_heads, **kwargs),
+            ClassificationHead(emb_size, n_classes)
+        )
+
+
+class ViT_1_6(nn.Sequential):
+    def __init__(self,     
+                in_channels: int = 3,
+                num_heads: int = 6,
+                patch_size: int = 16,
+                emb_size: int = 96,
+                img_size: int = 32,
+                depth: int = 1,
+                n_classes: int = 10,
+                **kwargs):
+        super().__init__(
+            PatchEmbedding(in_channels, patch_size, emb_size, img_size),
+            TransformerEncoder(depth, emb_size=emb_size, num_heads=num_heads, **kwargs),
+            ClassificationHead(emb_size, n_classes)
+        )
+
+
+class ViT_2_3(nn.Sequential):
+    def __init__(self,     
+                in_channels: int = 3,
+                num_heads: int = 3,
+                patch_size: int = 16,
+                emb_size: int = 48,
+                img_size: int = 32,
+                depth: int = 2,
+                n_classes: int = 10,
+                **kwargs):
+        super().__init__(
+            PatchEmbedding(in_channels, patch_size, emb_size, img_size),
+            TransformerEncoder(depth, emb_size=emb_size, num_heads=num_heads, **kwargs),
+            ClassificationHead(emb_size, n_classes)
+        )
+
+
+class ViT_2_6(nn.Sequential):
+    def __init__(self,     
+                in_channels: int = 3,
+                num_heads: int = 6,
+                patch_size: int = 16,
+                emb_size: int = 48,
+                img_size: int = 32,
+                depth: int = 2,
+                n_classes: int = 10,
+                **kwargs):
+        super().__init__(
+            PatchEmbedding(in_channels, patch_size, emb_size, img_size),
+            TransformerEncoder(depth, emb_size=emb_size, num_heads=num_heads, **kwargs),
+            ClassificationHead(emb_size, n_classes)
+        )