chore: Clean test directory (remove old folders/zips, rename db)

test/lemur_data_sync.zip

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

test/nn/AirNet-626c3eb9-5c0a-43be-bcba-745592729769.py

@@ -1,97 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class AirInitBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super().__init__()
-        self.layers = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True)
-        )
-
-    def forward(self, x):
-        return self.layers(x)
-
-
-class AirUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, stride):
-        super().__init__()
-        self.layers = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1),
-            nn.BatchNorm2d(out_channels)
-        )
-        self.downsample = (
-            nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=2, stride=stride, bias=False),
-                nn.BatchNorm2d(out_channels)
-            ) if stride != 1 or in_channels != out_channels else nn.Identity()
-        )
-        self.relu = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        residual = self.downsample(x)
-        x = self.layers(x)
-        return self.relu(x + residual)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.in_channels = in_shape[1]
-        self.image_size = in_shape[2]
-        self.num_classes = out_shape[0]
-        self.learning_rate = prm['lr']
-        self.momentum = prm['momentum']
-
-        channels = [64, 128, 256, 512]
-        init_block_channels = 64
-
-        self.features = self.build_features(init_block_channels, channels)
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.classifier = nn.Linear(channels[-1], self.num_classes)
-
-    def build_features(self, init_block_channels, channels):
-        layers = [AirInitBlock(self.in_channels, init_block_channels)]
-        for i, out_channels in enumerate(channels):
-            layers.append(AirUnit(
-                in_channels=init_block_channels if i == 0 else channels[i - 1],
-                out_channels=out_channels,
-                stride=1 if i == 0 else 2))
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        return self.classifier(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(
-            self.parameters(),
-            lr=self.learning_rate,
-            momentum=self.momentum
-        )
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/AirNet-777bc9dc-e6c7-4bff-8be1-a1b02adea68f.py

@@ -1,97 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class AirInitBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super().__init__()
-        self.layers = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True)
-        )
-
-    def forward(self, x):
-        return self.layers(x)
-
-
-class AirUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, stride):
-        super().__init__()
-        self.layers = nn.Sequential(
-            nn.Conv2d(in_channels, 3, kernel_size=3, stride=stride, padding=1),
-            nn.BatchNorm2d(3),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(3, out_channels, kernel_size=3, stride=1, padding=1),
-            nn.BatchNorm2d(out_channels)
-        )
-        self.downsample = (
-            nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
-                nn.BatchNorm2d(out_channels)
-            ) if stride != 1 or in_channels != out_channels else nn.Identity()
-        )
-        self.relu = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        residual = self.downsample(x)
-        x = self.layers(x)
-        return self.relu(x + residual)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.in_channels = in_shape[1]
-        self.image_size = in_shape[2]
-        self.num_classes = out_shape[0]
-        self.learning_rate = prm['lr']
-        self.momentum = prm['momentum']
-
-        channels = [64, 128, 256, 512]
-        init_block_channels = 64
-
-        self.features = self.build_features(init_block_channels, channels)
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.classifier = nn.Linear(channels[-1], self.num_classes)
-
-    def build_features(self, init_block_channels, channels):
-        layers = [AirInitBlock(self.in_channels, init_block_channels)]
-        for i, out_channels in enumerate(channels):
-            layers.append(AirUnit(
-                in_channels=init_block_channels if i == 0 else channels[i - 1],
-                out_channels=out_channels,
-                stride=1 if i == 0 else 2))
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        return self.classifier(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(
-            self.parameters(),
-            lr=self.learning_rate,
-            momentum=self.momentum
-        )
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/AirNext-1c889567-e226-44b8-9ced-2cbb8ad0a561.py

@@ -1,126 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import math
-
-
-class AirBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, groups=2, ratio=3):
-        super(AirBlock, self).__init__()
-        mid_channels = out_channels // ratio
-        self.conv1 = nn.Conv2d(in_channels, mid_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn1 = nn.BatchNorm2d(mid_channels)
-        self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        self.conv2 = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, stride=1, padding=1, groups=groups, bias=False)
-        self.bn2 = nn.BatchNorm2d(mid_channels)
-        self.conv3 = nn.Conv2d(mid_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn3 = nn.BatchNorm2d(out_channels)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        x = torch.relu(self.bn1(self.conv1(x)))
-        x = self.pool(x)
-        x = torch.relu(self.bn2(self.conv2(x)))
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        x = self.bn3(self.conv3(x))
-        x = self.sigmoid(x)
-        return x
-
-
-class AirNeXtUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, stride, cardinality, bottleneck_width, ratio):
-        super(AirNeXtUnit, self).__init__()
-        mid_channels = out_channels // 4
-        D = int(math.floor(mid_channels * (bottleneck_width / 64.0)))
-        group_width = cardinality * D
-        self.use_air_block = (stride == 1 and mid_channels < 512)
-
-        self.conv1 = nn.Conv2d(in_channels, group_width, kernel_size=1, stride=1, padding=0, bias=False)
-        self.conv2 = nn.Conv2d(group_width, group_width, kernel_size=3, stride=stride, padding=1, groups=cardinality, bias=False)
-        self.conv3 = nn.Conv2d(group_width, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        if self.use_air_block:
-            self.air = AirBlock(in_channels, group_width, groups=cardinality // ratio, ratio=ratio)
-
-        self.resize_identity = (in_channels != out_channels) or (stride != 1)
-        if self.resize_identity:
-            self.identity_conv = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        if self.use_air_block:
-            att = self.air(x)
-            att = F.interpolate(att, size=x.shape[2:], mode="bilinear", align_corners=True)  # Ensure att matches x dimensions
-        identity = self.identity_conv(x) if self.resize_identity else x
-        x = self.conv1(x)
-        x = self.conv2(x)
-        if self.use_air_block:
-            x = x * att
-        x = self.conv3(x)
-        x = x + identity
-        x = self.activ(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-
-        channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        init_block_channels = 64
-        cardinality = 32
-        bottleneck_width = 4
-        ratio = 2
-
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, init_block_channels, kernel_size=7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(init_block_channels),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        )
-        in_channels = init_block_channels
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                stride = 2 if (j == 0) and (i != 0) else 1
-                stage.add_module("unit{}".format(j + 1), AirNeXtUnit(in_channels, out_channels, stride, cardinality, bottleneck_width, ratio))
-                in_channels = out_channels
-            self.features.add_module("stage{}".format(i + 1), stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, class_number)
-
-    def forward(self, x):
-        x = self.features(x)
-        x = x.view(x.size(0), -1)
-        x = self.output(x)
-        return x
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.Adam(self.parameters(), lr=prm['lr'], weight_decay=1e-4)
-        self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=5, gamma=0.5)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-        self.scheduler.step()
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}

test/nn/AirNext-31e78268-e095-43be-bc9b-ad8b34e76201.py

@@ -1,128 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import math
-
-
-class AirBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, groups=1, ratio=2):
-        super(AirBlock, self).__init__()
-        mid_channels = out_channels // ratio
-        self.conv1 = nn.Conv2d(in_channels, mid_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn1 = nn.BatchNorm2d(mid_channels)
-        self.pool = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
-        self.conv2 = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, stride=1, padding=1, groups=groups, bias=False)
-        self.bn2 = nn.BatchNorm2d(mid_channels)
-        self.conv3 = nn.Conv2d(mid_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn3 = nn.BatchNorm2d(out_channels)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        x = torch.relu(self.bn1(self.conv1(x)))
-        x = self.pool(x)
-        x = torch.relu(self.bn2(self.conv2(x)))
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        x = self.bn3(self.conv3(x))
-        x = self.sigmoid(x)
-        return x
-
-
-class AirNeXtUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, stride, cardinality, bottleneck_width, ratio):
-        super(AirNeXtUnit, self).__init__()
-        mid_channels = out_channels // 4
-        D = int(math.floor(mid_channels * (bottleneck_width / 64.0)))
-        group_width = cardinality * D
-        self.use_air_block = (stride == 1 and mid_channels < 512)
-
-        self.conv1 = nn.Conv2d(in_channels, group_width, kernel_size=1, stride=1, padding=0, bias=False)
-        self.conv2 = nn.Conv2d(group_width, group_width, kernel_size=3, stride=stride, padding=1, groups=cardinality, bias=False)
-        self.conv3 = nn.Conv2d(group_width, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        if self.use_air_block:
-            self.air = AirBlock(in_channels, group_width, groups=(cardinality // ratio), ratio=ratio)
-
-        self.resize_identity = (in_channels!= out_channels) or (stride!= 1)
-        if self.resize_identity:
-            self.identity_conv = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        if self.use_air_block:
-            att = self.air(x)
-            att = F.interpolate(att, size=x.shape[2:], mode="bilinear", align_corners=True)  # Ensure att matches x dimensions
-        identity = self.identity_conv(x) if self.resize_identity else x
-        x = self.conv1(x)
-        x = self.conv2(x)
-        if self.use_air_block:
-            x = x * att
-        x = self.conv3(x)
-        x = x + identity
-        x = self.activ(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-
-        channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256, 512], [512, 512, 512, 512]]
-        init_block_channels = 64
-        cardinality = 32
-        bottleneck_width = 4
-        ratio = 2
-
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, init_block_channels, kernel_size=7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(init_block_channels),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        )
-        in_channels = init_block_channels
-        self.in_channels = in_channels
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                stride = 2 if (j == 0) and (i!= 0) else 1
-                stage.add_module("unit{}".format(j + 1), AirNeXtUnit(in_channels, out_channels, stride, cardinality, bottleneck_width, ratio))
-                in_channels = out_channels
-            self.features.add_module("stage{}".format(i + 1), stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, class_number)
-
-    def forward(self, x):
-        x = self.features(x)
-        x = x.view(x.size(0), -1)
-        x = self.output(x)
-        return x
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.Adam(self.parameters(), lr=prm['lr'], weight_decay=1e-4)
-        self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=5, gamma=0.5)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-        self.scheduler.step()
-
-
-def supported_hyperparameters():
-    return {'lr','momentum', 'dropout'}
-

test/nn/AirNext-8c916d56-4362-4ab3-8f8a-94b73fe876fb.py

@@ -1,126 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import math
-
-
-class AirBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, groups=3, ratio=4):
-        super(AirBlock, self).__init__()
-        mid_channels = out_channels // ratio
-        self.conv1 = nn.Conv2d(in_channels, mid_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn1 = nn.BatchNorm2d(mid_channels)
-        self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        self.conv2 = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, stride=1, padding=1, groups=groups, bias=False)
-        self.bn2 = nn.BatchNorm2d(mid_channels)
-        self.conv3 = nn.Conv2d(mid_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn3 = nn.BatchNorm2d(out_channels)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        x = torch.relu(self.bn1(self.conv1(x)))
-        x = self.pool(x)
-        x = torch.relu(self.bn2(self.conv2(x)))
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        x = self.bn3(self.conv3(x))
-        x = self.sigmoid(x)
-        return x
-
-
-class AirNeXtUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, stride, cardinality=8, bottleneck_width=4, ratio=3):
-        super(AirNeXtUnit, self).__init__()
-        mid_channels = out_channels // 4
-        D = int(math.floor(mid_channels * (bottleneck_width / 64.0)))
-        group_width = cardinality * D
-        self.use_air_block = (stride == 1 and mid_channels < 512)
-
-        self.conv1 = nn.Conv2d(in_channels, group_width, kernel_size=1, stride=1, padding=0, bias=False)
-        self.conv2 = nn.Conv2d(group_width, group_width, kernel_size=3, stride=stride, padding=1, groups=cardinality, bias=False)
-        self.conv3 = nn.Conv2d(group_width, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        if self.use_air_block:
-            self.air = AirBlock(in_channels, group_width, groups=(cardinality // ratio), ratio=ratio)
-
-        self.resize_identity = (in_channels != out_channels) or (stride != 1)
-        if self.resize_identity:
-            self.identity_conv = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        if self.use_air_block:
-            att = self.air(x)
-            att = F.interpolate(att, size=x.shape[2:], mode="bilinear", align_corners=True)  # Ensure att matches x dimensions
-        identity = self.identity_conv(x) if self.resize_identity else x
-        x = self.conv1(x)
-        x = self.conv2(x)
-        if self.use_air_block:
-            x = x * att
-        x = self.conv3(x)
-        x = x + identity
-        x = self.activ(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-
-        channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        init_block_channels = 64
-        cardinality = 32
-        bottleneck_width = 4
-        ratio = 2
-
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, init_block_channels, kernel_size=7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(init_block_channels),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        )
-        in_channels = init_block_channels
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                stride = 2 if (j == 0) and (i != 0) else 1
-                stage.add_module("unit{}".format(j + 1), AirNeXtUnit(in_channels, out_channels, stride, cardinality, bottleneck_width, ratio))
-                in_channels = out_channels
-            self.features.add_module("stage{}".format(i + 1), stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, class_number)
-
-    def forward(self, x):
-        x = self.features(x)
-        x = x.view(x.size(0), -1)
-        x = self.output(x)
-        return x
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.Adam(self.parameters(), lr=prm['lr'], weight_decay=1e-4)
-        self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=5, gamma=0.5)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-        self.scheduler.step()
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}

test/nn/AirNext.py

@@ -1,125 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import math
-
-
-class AirBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, groups=1, ratio=2):
-        super(AirBlock, self).__init__()
-        mid_channels = out_channels // ratio
-        self.conv1 = nn.Conv2d(in_channels, mid_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn1 = nn.BatchNorm2d(mid_channels)
-        self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        self.conv2 = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, stride=1, padding=1, groups=groups, bias=False)
-        self.bn2 = nn.BatchNorm2d(mid_channels)
-        self.conv3 = nn.Conv2d(mid_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        self.bn3 = nn.BatchNorm2d(out_channels)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        x = torch.relu(self.bn1(self.conv1(x)))
-        x = self.pool(x)
-        x = torch.relu(self.bn2(self.conv2(x)))
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        x = self.bn3(self.conv3(x))
-        x = self.sigmoid(x)
-        return x
-
-
-class AirNeXtUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, stride, cardinality, bottleneck_width, ratio):
-        super(AirNeXtUnit, self).__init__()
-        mid_channels = out_channels // 4
-        D = int(math.floor(mid_channels * (bottleneck_width / 64.0)))
-        group_width = cardinality * D
-        self.use_air_block = (stride == 1 and mid_channels < 512)
-
-        self.conv1 = nn.Conv2d(in_channels, group_width, kernel_size=1, stride=1, padding=0, bias=False)
-        self.conv2 = nn.Conv2d(group_width, group_width, kernel_size=3, stride=stride, padding=1, groups=cardinality, bias=False)
-        self.conv3 = nn.Conv2d(group_width, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
-        if self.use_air_block:
-            self.air = AirBlock(in_channels, group_width, groups=(cardinality // ratio), ratio=ratio)
-
-        self.resize_identity = (in_channels != out_channels) or (stride != 1)
-        if self.resize_identity:
-            self.identity_conv = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        if self.use_air_block:
-            att = self.air(x)
-            att = F.interpolate(att, size=x.shape[2:], mode="bilinear", align_corners=True)  # Ensure att matches x dimensions
-        identity = self.identity_conv(x) if self.resize_identity else x
-        x = self.conv1(x)
-        x = self.conv2(x)
-        if self.use_air_block:
-            x = x * att
-        x = self.conv3(x)
-        x = x + identity
-        x = self.activ(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-
-        channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        init_block_channels = 64
-        cardinality = 32
-        bottleneck_width = 4
-        ratio = 2
-
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, init_block_channels, kernel_size=7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(init_block_channels),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        )
-        in_channels = init_block_channels
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                stride = 2 if (j == 0) and (i != 0) else 1
-                stage.add_module("unit{}".format(j + 1), AirNeXtUnit(in_channels, out_channels, stride, cardinality, bottleneck_width, ratio))
-                in_channels = out_channels
-            self.features.add_module("stage{}".format(i + 1), stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, class_number)
-
-    def forward(self, x):
-        x = self.features(x)
-        x = x.view(x.size(0), -1)
-        x = self.output(x)
-        return x
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.Adam(self.parameters(), lr=prm['lr'], weight_decay=1e-4)
-        self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=5, gamma=0.5)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-        self.scheduler.step()
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}

test/nn/AlexNet-69c52339-4eac-45f1-bbfe-2c51949701f1.py

@@ -1,62 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 2)  # Changed from 3 to 2
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.features = nn.Sequential(
-            nn.Conv2d(in_shape[1], 64, kernel_size=7, stride=4, padding=2),  # Changed from 11 to 7
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(64, 192, kernel_size=5, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(192, 384, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(384, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(256, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-        )
-        dropout: float = prm['dropout']
-        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
-        self.classifier = nn.Sequential(
-            nn.Dropout(p=dropout),
-            nn.Linear(256 * 6 * 6, 4096),
-            nn.ReLU(inplace=True),
-            nn.Dropout(p=dropout),
-            nn.Linear(4096, 4096),
-            nn.ReLU(inplace=True),
-            nn.Linear(4096, out_shape[0]),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.classifier(x)
-        return x

test/nn/AlexNet-ad69700d-0e12-458f-afad-93f03988a4e7.py

@@ -1,64 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.features = nn.Sequential(
-            nn.Conv2d(in_shape[1], 64, kernel_size=11, stride=4, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(64, 256, kernel_size=5, padding=2),  # Changed from 192 to 256
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(256, 384, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(384, 256, kernel_size=3, padding=1),  # Changed from 384 to 256
-            nn.ReLU(inplace=True),
-            nn.Conv2d(256, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(256, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-        )
-        dropout: float = prm['dropout']
-        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
-        self.classifier = nn.Sequential(
-            nn.Dropout(p=dropout),
-            nn.Linear(256 * 6 * 6, 4096),
-            nn.ReLU(inplace=True),
-            nn.Dropout(p=dropout),
-            nn.Linear(4096, 4096),
-            nn.ReLU(inplace=True),
-            nn.Linear(4096, out_shape[0]),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.classifier(x)
-        return x

test/nn/AlexNet-bb84fa5d-5dd8-4cc0-8a30-5c41958bcd94.py

@@ -1,63 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.features = nn.Sequential(
-            nn.Conv2d(in_shape[1], 64, kernel_size=9, stride=4, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(64, 192, kernel_size=7, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(192, 384, kernel_size=5, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(384, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(256, 256, kernel_size=4, padding=1),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-        )
-        dropout: float = prm['dropout']
-        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
-        self.classifier = nn.Sequential(
-            nn.Dropout(p=dropout),
-            nn.Linear(256 * 6 * 6, 4096),
-            nn.ReLU(inplace=True),
-            nn.Dropout(p=dropout),
-            nn.Linear(4096, 4096),
-            nn.ReLU(inplace=True),
-            nn.Linear(4096, out_shape[0]),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.classifier(x)
-        return x
-

test/nn/AlexNet.py

@@ -1,61 +0,0 @@
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.features = nn.Sequential(
-            nn.Conv2d(in_shape[1], 64, kernel_size=11, stride=4, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(64, 192, kernel_size=5, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(192, 384, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(384, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(256, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-        )
-        dropout: float = prm['dropout']
-        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
-        self.classifier = nn.Sequential(
-            nn.Dropout(p=dropout),
-            nn.Linear(256 * 6 * 6, 4096),
-            nn.ReLU(inplace=True),
-            nn.Dropout(p=dropout),
-            nn.Linear(4096, 4096),
-            nn.ReLU(inplace=True),
-            nn.Linear(4096, out_shape[0]),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.classifier(x)
-        return x

test/nn/BagNet-001bf3e2-17c2-4fdf-948e-493677e58a3b.py

@@ -1,134 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-class BagNetBottleneck(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride, bottleneck_factor=4):
-        super().__init__()
-        mid_channels = out_channels // bottleneck_factor
-
-        self.conv1 = self.conv1x1_block(in_channels, mid_channels)
-        self.conv2 = self.conv_block(mid_channels, mid_channels, kernel_size, stride)
-        self.conv3 = self.conv1x1_block(mid_channels, out_channels, activation=False)
-
-    @staticmethod
-    def conv1x1_block(in_channels, out_channels, activation=True):
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
-            nn.BatchNorm2d(out_channels) if activation else nn.Identity(),
-            nn.ReLU(inplace=True) if activation else nn.Identity(),
-        )
-
-    @staticmethod
-    def conv_block(in_channels, out_channels, kernel_size, stride):
-        padding = (kernel_size - 1) // 2
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-        )
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.conv2(x)
-        x = self.conv3(x)
-        return x
-
-
-class BagNetUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super().__init__()
-        self.resize_identity = (in_channels!= out_channels) or (stride!= 1)
-        self.body = BagNetBottleneck(in_channels, out_channels, kernel_size, stride)
-
-        if self.resize_identity:
-            self.identity_conv = self.conv1x1_block(in_channels, out_channels, activation=False)
-
-        self.activ = nn.ReLU(inplace=True)
-
-    @staticmethod
-    def conv1x1_block(in_channels, out_channels, activation=True):
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
-            nn.BatchNorm2d(out_channels) if activation else nn.Identity(),
-            nn.ReLU(inplace=True) if activation else nn.Identity(),
-        )
-
-    def forward(self, x):
-        identity = x
-        if self.resize_identity:
-            identity = self.identity_conv(x)
-
-        x = self.body(x)
-
-        if x.size(2)!= identity.size(2) or x.size(3)!= identity.size(3):
-            identity = nn.functional.interpolate(identity, size=(x.size(2), x.size(3)), mode='bilinear', align_corners=False)
-
-        return self.activ(x + identity)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-        learning_rate = prm['lr']
-        momentum = prm['momentum']
-        dropout = prm['dropout']
-
-        self.channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, 64, kernel_size=7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
-        )
-
-        in_channels = 64
-        for i, stage_channels in enumerate(self.channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(stage_channels):
-                stride = 2 if (j == 0 and i > 0) else 1
-                stage.add_module(f"unit{j + 1}", BagNetUnit(in_channels, out_channels, kernel_size=3, stride=stride))
-                in_channels = out_channels
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, self.num_classes)
-
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.dropout = dropout
-
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        return self.output(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'],)
-
-        if self.dropout > 0:
-            self.dropout_layer = nn.Dropout(self.dropout)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-

test/nn/BagNet-560341b5-15a8-4829-a8ac-ea4c7391a950.py

@@ -1,129 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class BagNetBottleneck(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride, bottleneck_factor=8):  # Changed 4 to 8
-        super().__init__()
-        mid_channels = out_channels // bottleneck_factor
-
-        self.conv1 = self.conv1x1_block(in_channels, mid_channels)
-        self.conv2 = self.conv_block(mid_channels, mid_channels, kernel_size, stride)
-        self.conv3 = self.conv1x1_block(mid_channels, out_channels, activation=False)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def conv_block(self, in_channels, out_channels, kernel_size, stride):
-        padding = (kernel_size - 1) // 2
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-        )
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.conv2(x)
-        x = self.conv3(x)
-        return x
-
-
-class BagNetUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super().__init__()
-        self.resize_identity = (in_channels != out_channels) or (stride != 1)
-        self.body = BagNetBottleneck(in_channels, out_channels, kernel_size, stride)
-
-        if self.resize_identity:
-            self.identity_conv = self.conv1x1_block(in_channels, out_channels, activation=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        identity = x
-        if self.resize_identity:
-            identity = self.identity_conv(x)
-
-        x = self.body(x)
-
-        if x.size(2) != identity.size(2) or x.size(3) != identity.size(3):
-            identity = nn.functional.interpolate(identity, size=(x.size(2), x.size(3)), mode='bilinear', align_corners=False)
-
-        return self.activ(x + identity)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-        learning_rate = prm['lr']
-        momentum = prm['momentum']
-        dropout = prm['dropout']
-
-        self.channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, 64, kernel_size=7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
-        )
-
-        in_channels = 64
-        for i, stage_channels in enumerate(self.channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(stage_channels):
-                stride = 2 if (j == 0 and i > 0) else 1
-                stage.add_module(f"unit{j + 1}", BagNetUnit(in_channels, out_channels, kernel_size=3, stride=stride))
-                in_channels = out_channels
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, self.num_classes)
-
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.dropout = dropout
-
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        return self.output(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'],)
-
-        if self.dropout > 0:
-            self.dropout_layer = nn.Dropout(self.dropout)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/BagNet-6ecd3fc7-5ce2-4876-86a6-5e8250c43d78.py

@@ -1,129 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class BagNetBottleneck(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride, bottleneck_factor=4):
-        super().__init__()
-        mid_channels = out_channels // bottleneck_factor
-
-        self.conv1 = self.conv1x1_block(in_channels, mid_channels)
-        self.conv2 = self.conv_block(mid_channels, mid_channels, kernel_size, stride)
-        self.conv3 = self.conv1x1_block(mid_channels, out_channels, activation=False)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def conv_block(self, in_channels, out_channels, kernel_size, stride):
-        padding = (kernel_size - 1) // 2
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-        )
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.conv2(x)
-        x = self.conv3(x)
-        return x
-
-
-class BagNetUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super().__init__()
-        self.resize_identity = (in_channels != out_channels) or (stride != 1)
-        self.body = BagNetBottleneck(in_channels, out_channels, kernel_size, stride)
-
-        if self.resize_identity:
-            self.identity_conv = self.conv1x1_block(in_channels, out_channels, activation=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        identity = x
-        if self.resize_identity:
-            identity = self.identity_conv(x)
-
-        x = self.body(x)
-
-        if x.size(2) != identity.size(2) or x.size(3) != identity.size(3):
-            identity = nn.functional.interpolate(identity, size=(x.size(2), x.size(3)), mode='bilinear', align_corners=False)
-
-        return self.activ(x + identity)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-        learning_rate = prm['lr']
-        momentum = prm['momentum']
-        dropout = prm['dropout']
-
-        self.channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, 64, kernel_size=5, stride=2, padding=3, bias=False),  # Changed kernel_size from 7 to 5
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
-        )
-
-        in_channels = 64
-        for i, stage_channels in enumerate(self.channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(stage_channels):
-                stride = 2 if (j == 0 and i > 0) else 1
-                stage.add_module(f"unit{j + 1}", BagNetUnit(in_channels, out_channels, kernel_size=3, stride=stride))
-                in_channels = out_channels
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, self.num_classes)
-
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.dropout = dropout
-
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        return self.output(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'],)
-
-        if self.dropout > 0:
-            self.dropout_layer = nn.Dropout(self.dropout)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/BagNet-7e541be1-6b60-445d-bbbf-3b655eeefc9a.py

@@ -1,129 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class BagNetBottleneck(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride, bottleneck_factor=6):
-        super().__init__()
-        mid_channels = out_channels // bottleneck_factor
-
-        self.conv1 = self.conv1x1_block(in_channels, mid_channels)
-        self.conv2 = self.conv_block(mid_channels, mid_channels, kernel_size, stride)
-        self.conv3 = self.conv1x1_block(mid_channels, out_channels, activation=False)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def conv_block(self, in_channels, out_channels, kernel_size, stride):
-        padding = (kernel_size - 1) // 2
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-        )
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.conv2(x)
-        x = self.conv3(x)
-        return x
-
-
-class BagNetUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super().__init__()
-        self.resize_identity = (in_channels != out_channels) or (stride != 1)
-        self.body = BagNetBottleneck(in_channels, out_channels, kernel_size, stride)
-
-        if self.resize_identity:
-            self.identity_conv = self.conv1x1_block(in_channels, out_channels, activation=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        identity = x
-        if self.resize_identity:
-            identity = self.identity_conv(x)
-
-        x = self.body(x)
-
-        if x.size(2) != identity.size(2) or x.size(3) != identity.size(3):
-            identity = nn.functional.interpolate(identity, size=(x.size(2), x.size(3)), mode='bilinear', align_corners=False)
-
-        return self.activ(x + identity)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-        learning_rate = prm['lr']
-        momentum = prm['momentum']
-        dropout = prm['dropout']
-
-        self.channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, 64, kernel_size=5, stride=2, padding=2, bias=False),
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=2, stride=2, padding=1),
-        )
-
-        in_channels = 64
-        for i, stage_channels in enumerate(self.channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(stage_channels):
-                stride = 2 if (j == 0 and i > 0) else 1
-                stage.add_module(f"unit{j + 1}", BagNetUnit(in_channels, out_channels, kernel_size=3, stride=stride))
-                in_channels = out_channels
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, self.num_classes)
-
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.dropout = dropout
-
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        return self.output(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'],)
-
-        if self.dropout > 0:
-            self.dropout_layer = nn.Dropout(self.dropout)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/BagNet-7ebe6562-46c6-4406-96a2-bf3914ac8516.py

@@ -1,139 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-class SupportedHyperparameters():
-    def __init__(self):
-        self.hyperparameters = {'lr','momentum', 'dropout'}
-
-    def check_hyperparameters(self, param):
-        return param in self.hyperparameters
-
-
-class BagNetBottleneck(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride, bottleneck_factor=4):
-        super().__init__()
-        mid_channels = out_channels // bottleneck_factor
-
-        self.conv1 = self.conv1x1_block(in_channels, mid_channels)
-        self.conv2 = self.conv_block(mid_channels, mid_channels, kernel_size, stride)
-        self.conv3 = self.conv1x1_block(mid_channels, out_channels, activation=False)
-
-    @staticmethod
-    def conv1x1_block(in_channels, out_channels, activation=True):
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
-            nn.BatchNorm2d(out_channels) if activation else nn.Identity(),
-            nn.ReLU(inplace=True) if activation else nn.Identity(),
-        )
-
-    @staticmethod
-    def conv_block(in_channels, out_channels, kernel_size, stride):
-        padding = (kernel_size - 1) // 2
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-        )
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.conv2(x)
-        x = self.conv3(x)
-        return x
-
-
-class BagNetUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super().__init__()
-        self.resize_identity = (in_channels!= out_channels) or (stride!= 1)
-        self.body = BagNetBottleneck(in_channels, out_channels, kernel_size, stride)
-
-        if self.resize_identity:
-            self.identity_conv = self.conv1x1_block(in_channels, out_channels, activation=False)
-
-        self.activ = nn.ReLU(inplace=True)
-
-    @staticmethod
-    def conv1x1_block(in_channels, out_channels, activation=True):
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
-            nn.BatchNorm2d(out_channels) if activation else nn.Identity(),
-            nn.ReLU(inplace=True) if activation else nn.Identity(),
-        )
-
-    def forward(self, x):
-        identity = x
-        if self.resize_identity:
-            identity = self.identity_conv(x)
-
-        x = self.body(x)
-
-        if x.size(2)!= identity.size(2) or x.size(3)!= identity.size(3):
-            identity = nn.functional.interpolate(identity, size=(x.size(2), x.size(3)), mode='bilinear', align_corners=False)
-
-        return self.activ(x + identity)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-        learning_rate = prm['lr']
-        momentum = prm['momentum']
-        dropout = prm['dropout']
-
-        self.channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, 64, kernel_size=7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
-        )
-
-        in_channels = 64
-        for i, stage_channels in enumerate(self.channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(stage_channels):
-                stride = 2 if (j == 0 and i > 0) else 1
-                stage.add_module(f"unit{j + 1}", BagNetUnit(in_channels, out_channels, kernel_size=3, stride=stride))
-                in_channels = out_channels
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, self.num_classes)
-
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.dropout = dropout
-
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        return self.output(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'],)
-
-        if self.dropout > 0:
-            self.dropout_layer = nn.Dropout(self.dropout)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/BagNet-7f792262-31cf-477e-a78a-3494c122332d.py

@@ -1,129 +0,0 @@
-
-import torch
-import torch.nn as nn
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class BagNetBottleneck(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride, bottleneck_factor=4):
-        super().__init__()
-        mid_channels = out_channels // bottleneck_factor
-
-        self.conv1 = self.conv1x1_block(in_channels, mid_channels)
-        self.conv2 = self.conv_block(mid_channels, mid_channels, kernel_size, stride)
-        self.conv3 = self.conv1x1_block(mid_channels, out_channels, activation=False)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def conv_block(self, in_channels, out_channels, kernel_size, stride):
-        padding = (kernel_size - 1) // 2
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-        )
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.conv2(x)
-        x = self.conv3(x)
-        return x
-
-
-class BagNetUnit(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride):
-        super().__init__()
-        self.resize_identity = (in_channels != out_channels) or (stride != 1)
-        self.body = BagNetBottleneck(in_channels, out_channels, kernel_size, stride)
-
-        if self.resize_identity:
-            self.identity_conv = self.conv1x1_block(in_channels, out_channels, activation=False)
-        self.activ = nn.ReLU(inplace=True)
-
-    def conv1x1_block(self, in_channels, out_channels, activation=True):
-        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)]
-        if activation:
-            layers.append(nn.ReLU(inplace=True))
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        identity = x
-        if self.resize_identity:
-            identity = self.identity_conv(x)
-
-        x = self.body(x)
-
-        if x.size(2) != identity.size(2) or x.size(3) != identity.size(3):
-            identity = nn.functional.interpolate(identity, size=(x.size(2), x.size(3)), mode='bilinear', align_corners=False)
-
-        return self.activ(x + identity)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        channel_number = in_shape[1]
-        image_size = in_shape[2]
-        class_number = out_shape[0]
-        learning_rate = prm['lr']
-        momentum = prm['momentum']
-        dropout = prm['dropout']
-
-        self.channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-        self.in_size = image_size
-        self.num_classes = class_number
-
-        self.features = nn.Sequential(
-            nn.Conv2d(channel_number, 64, kernel_size=5, stride=3, padding=2),  # Changed kernel_size from 7 to 5
-            nn.BatchNorm2d(64),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=5, stride=4, padding=0),  # Changed padding from 1 to 0
-        )
-
-        in_channels = 64
-        for i, stage_channels in enumerate(self.channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(stage_channels):
-                stride = 2 if (j == 0 and i > 0) else 1
-                stage.add_module(f"unit{j + 1}", BagNetUnit(in_channels, out_channels, kernel_size=3, stride=stride))
-                in_channels = out_channels
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1))
-        self.output = nn.Linear(in_channels, self.num_classes)
-
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.dropout = dropout
-
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        return self.output(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'],)
-
-        if self.dropout > 0:
-            self.dropout_layer = nn.Dropout(self.dropout)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/BayesianNet-024b0436-9ad5-4a1f-86d0-946e577ffc2d.py

@@ -1,244 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn import Parameter
-
-def calculate_kl(mu_q, sig_q, mu_p, sig_p, eps=1e-8):
-    kl = 0.5 * (2 * torch.log(sig_p / sig_q) - 1 + (sig_q / sig_p).pow(2) + ((mu_p - mu_q) / sig_p).pow(2)).sum() + eps
-    return kl
-
-class ModuleWrapper(nn.Module):
-    def __init__(self):
-        super(ModuleWrapper, self).__init__()
-
-    def set_flag(self, flag_name, value):
-        setattr(self, flag_name, value)
-        for m in self.children():
-            if hasattr(m,'set_flag'):
-                m.set_flag(flag_name, value)
-
-    def forward(self, x):
-        for module in self.children():
-            x = module(x)
-
-        kl = 0.0
-        for module in self.modules():
-            if hasattr(module, 'kl_loss'):
-                kl = kl + module.kl_loss()
-
-        return x, kl
-
-
-class FlattenLayer(ModuleWrapper):
-
-    def __init__(self, num_features):
-        super(FlattenLayer, self).__init__()
-        self.num_features = num_features
-
-    def forward(self, x):
-        return x.view(-1, self.num_features)
-
-
-class BBBLinear(ModuleWrapper):
-
-    def __init__(self, in_features, out_features, bias=True, priors=None):
-        super(BBBLinear, self).__init__()
-        self.in_features = in_features
-        self.out_features = out_features
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,  # Randomly changed from 0.5
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-5, 0.1),
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_features, in_features))
-        self.W_rho = Parameter(torch.Tensor(out_features, in_features))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_features))
-            self.bias_rho = Parameter(torch.Tensor(out_features))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.linear(x, self.W_mu, self.bias_mu)
-        act_var = 1e-16 + F.linear(x ** 2, self.W_sigma ** 2, bias_var)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-class BBBConv2d(ModuleWrapper):
-
-    def __init__(self, in_channels, out_channels, kernel_size, stride=1,
-                 padding=0, dilation=1, bias=True, priors=None):
-        super(BBBConv2d, self).__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.kernel_size = (kernel_size, kernel_size)  # Randomly changed from 5 to 7
-        self.stride = stride
-        self.padding = padding
-        self.dilation = dilation
-        self.groups = 1
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,  # Randomly changed from 0.5
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-5, 0.1),
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        self.W_rho = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_channels))
-            self.bias_rho = Parameter(torch.Tensor(out_channels))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.conv2d(
-            x, self.W_mu, self.bias_mu, self.stride, self.padding, self.dilation, self.groups)
-        act_var = 1e-16 + F.conv2d(
-            x ** 2, self.W_sigma ** 2, bias_var, self.stride, self.padding, self.dilation, self.groups)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-def supported_hyperparameters():
-    return {'lr','momentum', 'kernel_size'}  # Randomly changed from'momentum' to 'kernel_size'
-
-
-class Net(ModuleWrapper):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-        if 'kernel_size' in prm:
-            self.kernal_size = prm['kernel_size']  # Randomly changed from default
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        inputs: int = in_shape[1]
-        outputs: int = out_shape[0]
-        self.num_classes = outputs
-        self.priors = {
-            'prior_mu': 0,
-            'prior_sigma': 0.1,
-            'posterior_mu_initial': (0, 0.1),
-            'posterior_rho_initial': (-5, 0.1),
-        }
-        self.act = nn.Softplus
-
-        self.conv1 = BBBConv2d(inputs, 64, 11, stride=4, padding=5, bias=True, priors=self.priors)
-        self.act1 = self.act()
-        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.conv2 = BBBConv2d(64, 192, 5, padding=2, bias=True, priors=self.priors)  # Randomly changed from 5 to 7
-        self.act2 = self.act()
-        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.conv3 = BBBConv2d(192, 384, 3, padding=1, bias=True, priors=self.priors)
-        self.act3 = self.act()
-
-        self.conv4 = BBBConv2d(384, 256, 3, padding=1, bias=True, priors=self.priors)
-        self.act4 = self.act()
-
-        self.conv5 = BBBConv2d(256, 128, 3, padding=1, bias=True, priors=self.priors)
-        self.act5 = self.act()
-        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.flatten = FlattenLayer(1 * 1 * 128)
-        self.classifier = BBBLinear(1 * 1 * 128, outputs, bias=True, priors=self.priors)
-
-    def __call__(self, *args):
-        return super().__call__(*args)[0]
-
-
-### END OF REPLY

test/nn/BayesianNet-0901ac22-d7f5-4deb-94c9-970e7955bd68.py

@@ -1,242 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn import Parameter
-
-
-def calculate_kl(mu_q, sig_q, mu_p, sig_p):
-    kl = 0.5 * (2 * torch.log(sig_p / sig_q) - 1 + (sig_q / sig_p).pow(2) + ((mu_p - mu_q) / sig_p).pow(2)).sum()
-    return kl
-
-
-class ModuleWrapper(nn.Module):
-    def __init__(self):
-        super(ModuleWrapper, self).__init__()
-
-    def set_flag(self, flag_name, value):
-        setattr(self, flag_name, value)
-        for m in self.children():
-            if hasattr(m,'set_flag'):
-                m.set_flag(flag_name, value)
-
-    def forward(self, x):
-        for module in self.children():
-            x = module(x)
-
-        kl = 0.0
-        for module in self.modules():
-            if hasattr(module, 'kl_loss'):
-                kl = kl + module.kl_loss()
-
-        return x, kl
-
-
-class FlattenLayer(ModuleWrapper):
-
-    def __init__(self, num_features):
-        super(FlattenLayer, self).__init__()
-        self.num_features = num_features
-
-    def forward(self, x):
-        return x.view(-1, self.num_features)
-
-
-class BBBLinear(ModuleWrapper):
-
-    def __init__(self, in_features, out_features, bias=True, priors=None):
-        super(BBBLinear, self).__init__()
-        self.in_features = in_features
-        self.out_features = out_features
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-3, 0.1),
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_features, in_features))
-        self.W_rho = Parameter(torch.Tensor(out_features, in_features))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_features))
-            self.bias_rho = Parameter(torch.Tensor(out_features))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.linear(x, self.W_mu, self.bias_mu)
-        act_var = 1e-16 + F.linear(x ** 2, self.W_sigma ** 2, bias_var)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-class BBBConv2d(ModuleWrapper):
-
-    def __init__(self, in_channels, out_channels, kernel_size, stride=1,
-                 padding=0, dilation=1, bias=True, priors=None):
-        super(BBBConv2d, self).__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.kernel_size = (kernel_size, kernel_size)
-        self.stride = stride
-        self.padding = padding
-        self.dilation = dilation
-        self.groups = 1
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-3, 0.1),
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        self.W_rho = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_channels))
-            self.bias_rho = Parameter(torch.Tensor(out_channels))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.conv2d(
-            x, self.W_mu, self.bias_mu, self.stride, self.padding, self.dilation, self.groups)
-        act_var = 1e-16 + F.conv2d(
-            x ** 2, self.W_sigma ** 2, bias_var, self.stride, self.padding, self.dilation, self.groups)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-def supported_hyperparameters():
-    return {'lr','momentum'}
-
-
-class Net(ModuleWrapper):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        inputs: int = in_shape[1]
-        outputs: int = out_shape[0]
-        self.num_classes = outputs
-        self.priors = self.priors = {
-            'prior_mu': 0,
-            'prior_sigma': 0.1,
-            'posterior_mu_initial': (0, 0.1),
-            'posterior_rho_initial': (-5, 0.1),
-        }
-        self.act = nn.Softplus
-
-        self.conv1 = BBBConv2d(inputs, 64, 11, stride=4, padding=5, bias=True, priors=self.priors)
-        self.act1 = self.act()
-        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.conv2 = BBBConv2d(64, 192, 5, padding=2, bias=True, priors=self.priors)
-        self.act2 = self.act()
-        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.conv3 = BBBConv2d(192, 384, 3, padding=1, bias=True, priors=self.priors)
-        self.act3 = self.act()
-
-        self.conv4 = BBBConv2d(384, 256, 3, padding=1, bias=True, priors=self.priors)
-        self.act4 = self.act()
-
-        self.conv5 = BBBConv2d(256, 128, 3, padding=1, bias=True, priors=self.priors)
-        self.act5 = self.act()
-        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.flatten = FlattenLayer(1 * 1 * 128)
-        self.classifier = BBBLinear(1 * 1 * 128, outputs, bias=True, priors=self.priors)
-
-    def __call__(self, *args):
-        return super().__call__(*args)[0]

test/nn/BayesianNet-1.py

@@ -1,241 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn import Parameter
-
-
-def calculate_kl(mu_q, sig_q, mu_p, sig_p):
-    kl = 0.5 * (2 * torch.log(sig_p / sig_q) - 1 + (sig_q / sig_p).pow(2) + ((mu_p - mu_q) / sig_p).pow(2)).sum()
-    return kl
-
-
-class ModuleWrapper(nn.Module):
-    def __init__(self):
-        super(ModuleWrapper, self).__init__()
-
-    def set_flag(self, flag_name, value):
-        setattr(self, flag_name, value)
-        for m in self.children():
-            if hasattr(m, 'set_flag'):
-                m.set_flag(flag_name, value)
-
-    def forward(self, x):
-        for module in self.children():
-            x = module(x)
-
-        kl = 0.0
-        for module in self.modules():
-            if hasattr(module, 'kl_loss'):
-                kl = kl + module.kl_loss()
-
-        return x, kl
-
-
-class FlattenLayer(ModuleWrapper):
-
-    def __init__(self, num_features):
-        super(FlattenLayer, self).__init__()
-        self.num_features = num_features
-
-    def forward(self, x):
-        return x.view(-1, self.num_features)
-
-
-class BBBLinear(ModuleWrapper):
-
-    def __init__(self, in_features, out_features, bias=True, priors=None):
-        super(BBBLinear, self).__init__()
-        self.in_features = in_features
-        self.out_features = out_features
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-3, 0.1),
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_features, in_features))
-        self.W_rho = Parameter(torch.Tensor(out_features, in_features))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_features))
-            self.bias_rho = Parameter(torch.Tensor(out_features))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.linear(x, self.W_mu, self.bias_mu)
-        act_var = 1e-16 + F.linear(x ** 2, self.W_sigma ** 2, bias_var)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-class BBBConv2d(ModuleWrapper):
-
-    def __init__(self, in_channels, out_channels, kernel_size, stride=1,
-                 padding=0, dilation=1, bias=True, priors=None):
-        super(BBBConv2d, self).__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.kernel_size = (kernel_size, kernel_size)
-        self.stride = stride
-        self.padding = padding
-        self.dilation = dilation
-        self.groups = 1
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-3, 0.1),
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        self.W_rho = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_channels))
-            self.bias_rho = Parameter(torch.Tensor(out_channels))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.conv2d(
-            x, self.W_mu, self.bias_mu, self.stride, self.padding, self.dilation, self.groups)
-        act_var = 1e-16 + F.conv2d(
-            x ** 2, self.W_sigma ** 2, bias_var, self.stride, self.padding, self.dilation, self.groups)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class Net(ModuleWrapper):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        inputs: int = in_shape[1]
-        outputs: int = out_shape[0]
-        self.num_classes = outputs
-        self.priors = {
-            'prior_mu': 0,
-            'prior_sigma': 0.1,
-            'posterior_mu_initial': (0, 0.1),
-            'posterior_rho_initial': (-5, 0.1),
-        }
-        self.act = nn.Softplus
-
-        self.conv1 = BBBConv2d(inputs, 32, 5, padding=2, bias=True, priors=self.priors)
-        self.act1 = self.act()
-        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2)
-
-        self.conv2 = BBBConv2d(32, 64, 5, padding=2, bias=True, priors=self.priors)
-        self.act2 = self.act()
-        self.pool2 = nn.MaxPool2d(kernel_size=3, stride=2)
-
-        self.conv3 = BBBConv2d(64, 128, 5, padding=1, bias=True, priors=self.priors)
-        self.act3 = self.act()
-        self.pool3 = nn.MaxPool2d(kernel_size=3, stride=2)
-
-        self.flatten = FlattenLayer(2 * 2 * 128)
-        self.fc1 = BBBLinear(2 * 2 * 128, 1000, bias=True, priors=self.priors)
-        self.act4 = self.act()
-
-        self.fc2 = BBBLinear(1000, 1000, bias=True, priors=self.priors)
-        self.act5 = self.act()
-
-        self.fc3 = BBBLinear(1000, outputs, bias=True, priors=self.priors)
-
-    def __call__(self, *args):
-        return super().__call__(*args)[0]

test/nn/BayesianNet-4f11c8da-cfe1-46ba-b5d0-b5d899929a2e.py

@@ -1,238 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn import Parameter
-
-
-def calculate_kl(mu_q, sig_q, mu_p, sig_p):
-    kl = 0.5 * (2 * torch.log(sig_p / sig_q) - 1 + (sig_q / sig_p).pow(2) + ((mu_p - mu_q) / sig_p).pow(2)).sum()
-    return kl
-
-
-class ModuleWrapper(nn.Module):
-    def __init__(self):
-        super(ModuleWrapper, self).__init__()
-
-    def set_flag(self, flag_name, value):
-        setattr(self, flag_name, value)
-        for m in self.children():
-            if hasattr(m, 'set_flag'):
-                m.set_flag(flag_name, value)
-
-    def forward(self, x):
-        for module in self.children():
-            x = module(x)
-
-        kl = 0.0
-        for module in self.modules():
-            if hasattr(module, 'kl_loss'):
-                kl = kl + module.kl_loss()
-
-        return x, kl
-
-
-class FlattenLayer(ModuleWrapper):
-
-    def __init__(self, num_features):
-        super(FlattenLayer, self).__init__()
-        self.num_features = num_features
-
-    def forward(self, x):
-        return x.view(-1, self.num_features)
-
-
-class BBBLinear(ModuleWrapper):
-
-    def __init__(self, in_features, out_features, bias=True, priors=None):
-        super(BBBLinear, self).__init__()
-        self.in_features = in_features
-        self.out_features = out_features
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-4, 0.1),  # Changed from -3 to -4
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_features, in_features))
-        self.W_rho = Parameter(torch.Tensor(out_features, in_features))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_features))
-            self.bias_rho = Parameter(torch.Tensor(out_features))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.linear(x, self.W_mu, self.bias_mu)
-        act_var = 1e-16 + F.linear(x ** 2, self.W_sigma ** 2, bias_var)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-class BBBConv2d(ModuleWrapper):
-
-    def __init__(self, in_channels, out_channels, kernel_size, stride=1,
-                 padding=0, dilation=1, bias=True, priors=None):
-        super(BBBConv2d, self).__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.kernel_size = (kernel_size, kernel_size)
-        self.stride = stride
-        self.padding = padding
-        self.dilation = dilation
-        self.groups = 1
-        self.use_bias = bias
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-        if priors is None:
-            priors = {
-                'prior_mu': 0,
-                'prior_sigma': 0.1,
-                'posterior_mu_initial': (0, 0.1),
-                'posterior_rho_initial': (-3, 0.1),  # Changed from -5 to -6
-            }
-        self.prior_mu = priors['prior_mu']
-        self.prior_sigma = priors['prior_sigma']
-        self.posterior_mu_initial = priors['posterior_mu_initial']
-        self.posterior_rho_initial = priors['posterior_rho_initial']
-
-        self.W_mu = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        self.W_rho = Parameter(torch.Tensor(out_channels, in_channels, *self.kernel_size))
-        if self.use_bias:
-            self.bias_mu = Parameter(torch.Tensor(out_channels))
-            self.bias_rho = Parameter(torch.Tensor(out_channels))
-        else:
-            self.register_parameter('bias_mu', None)
-            self.register_parameter('bias_rho', None)
-
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.W_mu.data.normal_(*self.posterior_mu_initial)
-        self.W_rho.data.normal_(*self.posterior_rho_initial)
-
-        if self.use_bias:
-            self.bias_mu.data.normal_(*self.posterior_mu_initial)
-            self.bias_rho.data.normal_(*self.posterior_rho_initial)
-
-    def forward(self, x, sample=True):
-
-        self.W_sigma = torch.log1p(torch.exp(self.W_rho))
-        if self.use_bias:
-            self.bias_sigma = torch.log1p(torch.exp(self.bias_rho))
-            bias_var = self.bias_sigma ** 2
-        else:
-            self.bias_sigma = bias_var = None
-
-        act_mu = F.conv2d(
-            x, self.W_mu, self.bias_mu, self.stride, self.padding, self.dilation, self.groups)
-        act_var = 1e-16 + F.conv2d(
-            x ** 2, self.W_sigma ** 2, bias_var, self.stride, self.padding, self.dilation, self.groups)
-        act_std = torch.sqrt(act_var)
-
-        if self.training or sample:
-            eps = torch.empty(act_mu.size()).normal_(0, 1).to(self.device)
-            return act_mu + act_std * eps
-        else:
-            return act_mu
-
-    def kl_loss(self):
-        kl = calculate_kl(self.prior_mu, self.prior_sigma, self.W_mu, self.W_sigma)
-        if self.use_bias:
-            kl += calculate_kl(self.prior_mu, self.prior_sigma, self.bias_mu, self.bias_sigma)
-        return kl
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class Net(ModuleWrapper):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        inputs: int = in_shape[1]
-        outputs: int = out_shape[0]
-        self.num_classes = outputs
-        self.priors = self.priors = {
-            'prior_mu': 0,
-            'prior_sigma': 0.1,
-            'posterior_mu_initial': (0, 0.1),
-            'posterior_rho_initial': (-4, 0.1),  # Changed from -5 to -6
-        }
-        self.act = nn.Softplus
-
-        self.conv1 = BBBConv2d(inputs, 6, 5, padding=0, bias=True, priors=self.priors)
-        self.act1 = self.act()
-        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.conv2 = BBBConv2d(6, 16, 5, padding=0, bias=True, priors=self.priors)
-        self.act2 = self.act()
-        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        self.flatten = FlattenLayer(5 * 5 * 16)
-        self.fc1 = BBBLinear(5 * 5 * 16, 120, bias=True, priors=self.priors)
-        self.act3 = self.act()
-
-        self.fc2 = BBBLinear(120, 84, bias=True, priors=self.priors)
-        self.act4 = self.act()
-
-        self.fc3 = BBBLinear(84, outputs, bias=True, priors=self.priors)
-
-    def __call__(self, *args):
-        return super().__call__(*args)[0]

test/nn/C10C-RESNETLSTM-6a517327bf0ef897a22186a2061e85b3.py

@@ -1,180 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-def supported_hyperparameters():
-    return {'lr','momentum'}
-
-class SEBlock(nn.Module):
-    def __init__(self, channel, reduction=4):
-        super().__init__()
-        self.avg = nn.AdaptiveAvgPool2d(1)
-        self.fc1 = nn.Linear(channel, channel // reduction, bias=False)
-        self.fc2 = nn.Linear(channel // reduction, channel, bias=False)
-
-    def forward(self, x):
-        b, c, _, _ = x.size()
-        y = self.avg(x).view(b, c)
-        y = self.fc2(F.relu(self.fc1(y), inplace=True)).view(b, c, 1, 1)
-        return x * torch.sigmoid(y)
-
-class DepthwiseSeparableConv(nn.Module):
-    def __init__(self, in_ch, out_ch, k=3, s=1, p=1):
-        super().__init__()
-        self.dw = nn.Conv2d(in_ch, in_ch, k, s, p, groups=in_ch, bias=False)
-        self.pw = nn.Conv2d(in_ch, out_ch, 1, 1, bias=False)
-        self.bn = nn.BatchNorm2d(out_ch)
-
-    def forward(self, x):
-        x = self.dw(x)
-        x = self.pw(x)
-        return F.relu(self.bn(x), inplace=True)
-
-class YourEncoder(nn.Module):
-    def __init__(self, in_channels, hidden_dim=512):
-        super().__init__()
-        h2 = hidden_dim // 2
-        self.stem = nn.Sequential(
-            nn.Conv2d(in_channels, h2, 3, 2, 1, bias=False),
-            nn.BatchNorm2d(h2),
-            nn.ReLU(inplace=True),
-            DepthwiseSeparableConv(h2, hidden_dim),
-            SEBlock(hidden_dim),
-            nn.AdaptiveAvgPool2d((1,1))
-        )
-        self.fc = nn.Linear(hidden_dim, hidden_dim)
-
-    def forward(self, x):
-        x = self.stem(x)
-        x = x.view(x.size(0), -1)
-        x = self.fc(x)
-        return x
-
-class Attention(nn.Module):
-    def __init__(self, hidden_size, feature_dim):
-        super().__init__()
-        self.q = nn.Linear(hidden_size, hidden_size, bias=False)
-        self.k = nn.Linear(feature_dim, hidden_size, bias=False)
-        self.v = nn.Linear(feature_dim, hidden_size, bias=False)
-
-    def forward(self, h, feats):
-        if feats.dim()==2:
-            feats = feats.unsqueeze(1)
-        q = self.q(h)
-        k = self.k(feats)
-        v = self.v(feats)
-        score = torch.einsum('bh,brh->br', q, k)
-        attn = F.softmax(score, dim=1)
-        ctx = torch.einsum('br,brh->bh', attn, v)
-        return ctx
-
-class YourDecoder(nn.Module):
-    def __init__(self, vocab_size, feature_dim=512, hidden_size=512):
-        super().__init__()
-        self.embed = nn.Embedding(vocab_size, hidden_size)
-        self.attn = Attention(hidden_size, feature_dim)
-        self.cell = nn.GRUCell(input_size=hidden_size*2, hidden_size=hidden_size)
-        self.fc = nn.Linear(hidden_size, vocab_size)
-        self.hidden_size = hidden_size
-        self.vocab_size = vocab_size
-
-    def init_zero_hidden(self, batch, device):
-        h0 = torch.zeros(batch, self.hidden_size, device=device)
-        c0 = torch.zeros(batch, self.hidden_size, device=device)
-        return (h0, c0)
-
-    def forward(self, inputs, hidden_state, features):
-        B, T = inputs.size()
-        if features.dim()==3 and features.size(1)==1:
-            features = features.squeeze(1)
-        if hidden_state is None or hidden_state[0].size(0)!=B:
-            h = torch.zeros(B, self.hidden_size, device=inputs.device)
-        else:
-            h = hidden_state[0]
-        embs = self.embed(inputs)
-        outs = []
-        for t in range(T):
-            ctx = self.attn(h, features)
-            x = torch.cat([embs[:, t, :], ctx], dim=1)
-            h = self.cell(x, h)
-            outs.append(self.fc(h))
-        logits = torch.stack(outs, dim=1)
-        return logits, (h, torch.zeros_like(h))
-
-    @torch.no_grad()
-    def greedy_decode(self, features, max_len=50, start_id=1, end_id=2):
-        if features.dim()==3 and features.size(1)==1:
-            features = features.squeeze(1)
-        B = features.size(0)
-        device = features.device
-        h = torch.zeros(B, self.hidden_size, device=device)
-        cur = torch.full((B,), start_id, dtype=torch.long, device=device)
-        tokens = []
-        for _ in range(max_len):
-            emb = self.embed(cur)
-            ctx = self.attn(h, features)
-            x = torch.cat([emb, ctx], dim=1)
-            h = self.cell(x, h)
-            logit = self.fc(h)
-            cur = logit.argmax(dim=1)
-            tokens.append(cur)
-            if (cur==end_id).all():
-                break
-        if len(tokens)==0:
-            return torch.empty(B, 0, dtype=torch.long, device=device)
-        return torch.stack(tokens, dim=1)
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        in_channels = int(in_shape[1])
-        vocab_size  = int(out_shape[0])
-        hidden = 512
-        self.encoder = YourEncoder(in_channels, hidden_dim=hidden)
-        self.rnn     = YourDecoder(vocab_size, feature_dim=hidden, hidden_size=hidden)
-        self.criterion = nn.CrossEntropyLoss(ignore_index=0)
-        self.optimizer = None
-        self.vocab_size = vocab_size
-
-    def _norm_caps(self, caps):
-        if caps.ndim==3:
-            caps = caps[:,0,:]
-        elif caps.ndim==1:
-            caps = caps.unsqueeze(0)
-        return caps.long()
-
-    def forward(self, images, captions=None, hidden_state=None):
-        assert images.dim()==4
-        feats = self.encoder(images)
-        B = images.size(0)
-        if captions is None:
-            return self.rnn.greedy_decode(feats, max_len=50)
-        caps = self._norm_caps(captions)
-        inputs = caps[:, :-1]
-        if hidden_state is None or (isinstance(hidden_state, tuple) and hidden_state[0].size(0)!=B):
-            hidden_state = self.rnn.init_zero_hidden(B, images.device)
-        logits, _ = self.rnn(inputs, hidden_state, feats)
-        assert logits.dim()==3 and logits.size(1)==inputs.size(1)
-        return logits
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-        self.criterion = self.criterion.to(self.device)
-
-    def learn(self, train_data):
-        self.train()
-        for images, captions in train_data:
-            images = images.to(self.device)
-            captions = captions.to(self.device)
-            caps = self._norm_caps(captions)
-            self.optimizer.zero_grad()
-            logits = self(images, caps, None)
-            T = min(logits.size(1), caps.size(1)-1)
-            logits = logits[:, :T, :]
-            tgt = caps[:, 1:1+T]
-            loss = self.criterion(logits.reshape(-1, self.vocab_size), tgt.reshape(-1))
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3.0)
-            self.optimizer.step()

test/nn/C10C-RESNETLSTM-8f7ac9c241d5b9546f8cd3484e0e100b.py

@@ -1,245 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-# Optional: discover PAD/BOS/EOS ids from loader
-try:
-    from ab.nn.loader.coco_.Caption import GLOBAL_CAPTION_VOCAB
-except Exception:
-    GLOBAL_CAPTION_VOCAB = {}
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-# ---------- helpers ----------
-def _special_ids(vocab: dict, vocab_size: int):
-    def hit(keys, default):
-        for k in keys:
-            if k in vocab:
-                return int(vocab[k])
-        return max(0, min(default, vocab_size - 1))
-    pad = hit(['<PAD>', '<pad>', '<pad_token>', '<blank>', '<null>'], 0)
-    bos = hit(['<BOS>', '<bos>', '<s>', '<start>', '<SOS>', '<sos>'], 1)
-    eos = hit(['<EOS>', '<eos>', '</s>', '<end>', '<EOS_TOKEN>'], 2)
-    return pad, bos, eos
-
-class PositionalEncoding(nn.Module):
-    def __init__(self, d_model: int, max_len: int = 4096, dropout: float = 0.0):
-        super().__init__()
-        pe = torch.zeros(max_len, d_model)
-        pos = torch.arange(0, max_len).float().unsqueeze(1)
-        div = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
-        pe[:, 0::2] = torch.sin(pos * div)
-        pe[:, 1::2] = torch.cos(pos * div)
-        self.register_buffer('pe', pe.unsqueeze(0), persistent=False)  # (1, L, D)
-        self.drop = nn.Dropout(dropout)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # x: (B, L, D)
-        L = x.size(1)
-        return self.drop(x + self.pe[:, :L, :])
-
-# ---------- encoder ----------
-class BagNetBlock(nn.Module):
-    def __init__(self, in_ch, out_ch, k=3, s=1):
-        super().__init__()
-        mid = max(1, out_ch // 4)
-        self.conv1 = nn.Conv2d(in_ch, mid, 1, 1, 0, bias=False)
-        self.conv2 = nn.Conv2d(mid, mid, k, s, (k - 1)//2, bias=False)
-        self.bn2   = nn.BatchNorm2d(mid)
-        self.conv3 = nn.Conv2d(mid, out_ch, 1, 1, 0, bias=False)
-        self.proj  = None if (in_ch == out_ch and s == 1) else nn.Conv2d(in_ch, out_ch, 1, s, 0, bias=False)
-        self.act   = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        idt = x if self.proj is None else self.proj(x)
-        y = self.conv1(x)
-        y = self.conv2(y); y = self.bn2(y); y = self.act(y)
-        y = self.conv3(y)
-        if y.shape[-2:] != idt.shape[-2:]:
-            idt = F.interpolate(idt, size=y.shape[-2:], mode='bilinear', align_corners=False)
-        return self.act(y + idt)
-
-class CNNEncoder(nn.Module):
-    def __init__(self, in_ch: int, feat_ch: int = 384):
-        super().__init__()
-        self.stem = nn.Sequential(
-            nn.Conv2d(in_ch, 64, 3, 2, 1, bias=False),
-            nn.BatchNorm2d(64), nn.SiLU(),
-            nn.Conv2d(64, 128, 3, 2, 1, bias=False),
-            nn.BatchNorm2d(128), nn.SiLU(),
-        )
-        self.b1 = BagNetBlock(128, 256, k=3, s=2)   # (H/8, W/8)
-        self.b2 = BagNetBlock(256, feat_ch, k=3, s=1)
-
-    def forward(self, x):
-        x = self.stem(x)
-        x = self.b1(x)
-        x = self.b2(x)   # (B, C, h, w)
-        return x
-
-# ---------- decoder ----------
-class TransformerDecoder(nn.Module):
-    def __init__(self, vocab_size: int, d_model: int = 512, nhead: int = 8, num_layers: int = 4,
-                 dropout: float = 0.1, pad_idx: int = 0):
-        super().__init__()
-        self.pad_idx = pad_idx
-        self.embed = nn.Embedding(vocab_size, d_model, padding_idx=pad_idx)
-        self.pos   = PositionalEncoding(d_model, dropout=dropout)
-        layer = nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead,
-                                           dim_feedforward=2048, batch_first=True,
-                                           dropout=dropout, activation='gelu')
-        self.dec = nn.TransformerDecoder(layer, num_layers=num_layers)
-        self.fc  = nn.Linear(d_model, vocab_size)
-
-    @staticmethod
-    def _causal_mask(L, device, dtype):
-        # Make the dtype consistent with PyTorch recommendations to avoid warnings
-        m = torch.full((L, L), float('-inf'), device=device, dtype=dtype)
-        return torch.triu(m, diagonal=1)
-
-    def forward(self, tgt_tokens: torch.Tensor, memory: torch.Tensor) -> torch.Tensor:
-        """
-        tgt_tokens: (B, T), memory: (B, S, D)
-        returns logits: (B, T, V)
-        """
-        B, T = tgt_tokens.shape
-        x = self.embed(tgt_tokens)                    # (B,T,D)
-        x = self.pos(x)
-        # Use float mask to match attn_mask dtype
-        tgt_mask = self._causal_mask(T, x.device, x.dtype)      # (T,T)
-        tgt_kpm  = (tgt_tokens == self.pad_idx)                  # (B,T) bool
-        y = self.dec(tgt=x, memory=memory,
-                     tgt_mask=tgt_mask,
-                     tgt_key_padding_mask=tgt_kpm)
-        return self.fc(y)                             # (B,T,V)
-
-# ---------- full model ----------
-class Net(nn.Module):
-    """
-    Returns a Tensor from forward() (never a tuple), so metrics like BLEU can call .dim().
-    API:
-      - __init__(in_shape, out_shape, prm, device)
-      - forward(images, captions=None) -> logits Tensor
-      - train_setup(prm)
-      - learn(train_data)
-    """
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.in_channels = int(in_shape[1])
-        self.vocab_size = int(out_shape[0])
-
-        # Hyperparams (consumed)
-        self.dropout_p = float(prm.get('dropout', 0.1))
-        self.max_len   = int(prm.get('max_len', 20))
-
-        # Special tokens
-        self.pad_idx, self.bos_id, self.eos_id = _special_ids(GLOBAL_CAPTION_VOCAB or {}, self.vocab_size)
-
-        # Encoder -> sequence of d_model features
-        d_model = 512
-        enc_feat_ch = 384
-        self.encoder = CNNEncoder(self.in_channels, feat_ch=enc_feat_ch)
-        self.enc_proj = nn.Linear(enc_feat_ch, d_model)
-        self.enc_pos  = PositionalEncoding(d_model, dropout=self.dropout_p)
-        self.enc_drop = nn.Dropout(self.dropout_p)
-
-        # Transformer decoder
-        self.decoder = TransformerDecoder(self.vocab_size, d_model=d_model, nhead=8,
-                                          num_layers=4, dropout=self.dropout_p, pad_idx=self.pad_idx)
-
-        # Training attrs init in train_setup
-        self.criteria = None
-        self.optimizer = None
-        self.scaler = None
-
-    # -- encoder helper --
-    def _encode(self, images: torch.Tensor) -> torch.Tensor:
-        f = self.encoder(images)                     # (B,C,h,w)
-        B, C, h, w = f.shape
-        seq = f.view(B, C, h*w).permute(0, 2, 1)    # (B,S,C)
-        seq = self.enc_proj(seq)                    # (B,S,D)
-        seq = self.enc_pos(seq)
-        seq = self.enc_drop(seq)
-        return seq                                   # (B,S,D)
-
-    # -- forward --
-    def forward(self, images, captions=None):
-        """
-        Training (teacher forcing):
-            inputs = captions[:, :-1] -> logits over positions 1..T-1
-            returns logits: (B, T-1, V)
-        Inference (captions=None):
-            greedy decode up to max_len
-            returns logits: (B, L, V) of generated steps
-        """
-        assert images.dim() == 4, "images must be (B,C,H,W)"
-        memory = self._encode(images)  # (B,S,D)
-
-        if captions is not None:
-            if captions.ndim == 3:
-                captions = captions[:, 0, :]        # (B,T)
-            inputs = captions[:, :-1]               # (B,T-1)
-            logits = self.decoder(inputs, memory)   # (B,T-1,V)
-            return logits                           # Tensor ONLY
-
-        # Inference: greedy
-        B = images.size(0)
-        device = images.device
-        cur = torch.full((B, 1), self.bos_id, dtype=torch.long, device=device)
-        steps = []
-        for _ in range(self.max_len):
-            step_logits = self.decoder(cur, memory)[:, -1:, :]  # (B,1,V)
-            steps.append(step_logits)
-            next_tok = step_logits.argmax(dim=-1)                # (B,1)
-            cur = torch.cat([cur, next_tok], dim=1)
-            if (next_tok.squeeze(1) == self.eos_id).all():
-                break
-        logits = torch.cat(steps, dim=1) if steps else torch.zeros((B, 0, self.vocab_size), device=device)
-        return logits                                           # Tensor ONLY
-
-    # -- training setup --
-    def train_setup(self, prm):
-        self.to(self.device)
-        # Loss: ignore PAD; a bit of label smoothing helps BLEU
-        self.criteria = (nn.CrossEntropyLoss(ignore_index=self.pad_idx, label_smoothing=0.1).to(self.device),)
-        # Consume 'momentum' by mapping to AdamW beta1
-        beta1 = float(prm.get('momentum', 0.9))
-        self.optimizer = torch.optim.AdamW(self.parameters(),
-                                           lr=float(prm['lr']),
-                                           betas=(beta1, 0.999),
-                                           weight_decay=1e-4)
-        # New AMP API to avoid deprecation warning
-        self.scaler = torch.amp.GradScaler('cuda', enabled=(self.device.type == 'cuda'))
-
-    # -- one epoch training loop --
-    def learn(self, train_data):
-        """
-        Expects batches like (images, captions, *rest).
-        """
-        assert self.criteria and self.optimizer is not None and self.scaler is not None, "Call train_setup(prm) first."
-        self.train()
-        amp_device = 'cuda' if self.device.type == 'cuda' else 'cpu'
-        for batch in train_data:
-            if isinstance(batch, (list, tuple)):
-                images, captions = batch[0], batch[1]
-            else:
-                images, captions = batch
-            images = images.to(self.device, non_blocking=True)
-            captions = captions.to(self.device, non_blocking=True)
-
-            with torch.amp.autocast(amp_device, enabled=(self.device.type == 'cuda')):
-                if captions.ndim == 3:
-                    captions = captions[:, 0, :]
-                logits = self.forward(images, captions)          # (B,T-1,V) Tensor
-                targets = captions[:, 1:]                        # (B,T-1)
-                loss = self.criteria[0](logits.reshape(-1, logits.size(-1)),
-                                        targets.reshape(-1))
-
-            self.optimizer.zero_grad(set_to_none=True)
-            self.scaler.scale(loss).backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3.0)
-            self.scaler.step(self.optimizer)
-            self.scaler.update()

test/nn/C10C-RESNETLSTM-IMG-CAP-IMPROVED.py

@@ -1,230 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision.models as tv
-
-# --- AlexNet weights (safe fallback for older torchvision) ---
-try:
-    from torchvision.models import AlexNet_Weights
-    ALEXNET_W = AlexNet_Weights.IMAGENET1K_V1
-except Exception:
-    ALEXNET_W = None  # fallback: will use pretrained=True on older torchvision
-
-# Optional: discover PAD/BOS/EOS ids from loader
-try:
-    from ab.nn.loader.coco_.Caption import GLOBAL_CAPTION_VOCAB
-except Exception:
-    GLOBAL_CAPTION_VOCAB = {}
-
-def supported_hyperparameters():
-    # repo's train.py consumes lr/momentum/dropout via -p JSON or optuna ranges
-    return {'lr', 'momentum', 'dropout'}
-
-# ---------- helpers ----------
-def _special_ids(vocab: dict, vocab_size: int):
-    def hit(keys, default):
-        for k in keys:
-            if k in vocab:
-                return int(vocab[k])
-        return max(0, min(default, vocab_size - 1))
-    pad = hit(['<PAD>', '<pad>', '<pad_token>', '<blank>', '<null>'], 0)
-    bos = hit(['<BOS>', '<bos>', '<s>', '<start>', '<SOS>', '<sos>'], 1)
-    eos = hit(['<EOS>', '<eos>', '</s>', '<end>', '<EOS_TOKEN>'], 2)
-    return pad, bos, eos
-
-class PositionalEncoding(nn.Module):
-    def __init__(self, d_model: int, max_len: int = 4096, dropout: float = 0.0):
-        super().__init__()
-        pe = torch.zeros(max_len, d_model)
-        pos = torch.arange(0, max_len).float().unsqueeze(1)
-        div = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
-        pe[:, 0::2] = torch.sin(pos * div)
-        pe[:, 1::2] = torch.cos(pos * div)
-        self.register_buffer('pe', pe.unsqueeze(0), persistent=False)  # (1, L, D)
-        self.drop = nn.Dropout(dropout)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # x: (B, L, D)
-        L = x.size(1)
-        return self.drop(x + self.pe[:, :L, :])
-
-# ---------- encoder (AlexNet features) ----------
-class CNNEncoder(nn.Module):
-    """
-    AlexNet conv feature extractor.
-    Output: (B, 256, h, w)
-    """
-    def __init__(self, in_ch: int, feat_ch: int = 256):  # feat_ch kept for signature
-        super().__init__()
-        # torchvision AlexNet expects 3-channel RGB, repo's transforms should handle normalization/resize
-        if ALEXNET_W is None:
-            self.backbone = tv.alexnet(pretrained=True).features
-        else:
-            self.backbone = tv.alexnet(weights=ALEXNET_W).features
-
-    def forward(self, x):
-        return self.backbone(x)  # (B, 256, h, w)
-
-# ---------- decoder ----------
-class TransformerDecoder(nn.Module):
-    def __init__(self, vocab_size: int, d_model: int = 512, nhead: int = 8, num_layers: int = 4,
-                 dropout: float = 0.1, pad_idx: int = 0):
-        super().__init__()
-        self.pad_idx = pad_idx
-        self.embed = nn.Embedding(vocab_size, d_model, padding_idx=pad_idx)
-        self.pos   = PositionalEncoding(d_model, dropout=dropout)
-        layer = nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead,
-                                           dim_feedforward=2048, batch_first=True,
-                                           dropout=dropout, activation='gelu')
-        self.dec = nn.TransformerDecoder(layer, num_layers=num_layers)
-        self.fc  = nn.Linear(d_model, vocab_size)
-
-    @staticmethod
-    def _causal_mask(L, device, dtype):
-        m = torch.full((L, L), float('-inf'), device=device, dtype=dtype)
-        return torch.triu(m, diagonal=1)
-
-    def forward(self, tgt_tokens: torch.Tensor, memory: torch.Tensor) -> torch.Tensor:
-        """
-        tgt_tokens: (B, T), memory: (B, S, D)
-        returns logits: (B, T, V)
-        """
-        B, T = tgt_tokens.shape
-        x = self.embed(tgt_tokens)                    # (B,T,D)
-        x = self.pos(x)
-        tgt_mask = self._causal_mask(T, x.device, x.dtype)  # (T,T) float mask
-        tgt_kpm  = (tgt_tokens == self.pad_idx)              # (B,T) bool
-        y = self.dec(tgt=x, memory=memory,
-                     tgt_mask=tgt_mask,
-                     tgt_key_padding_mask=tgt_kpm)
-        return self.fc(y)                             # (B,T,V)
-
-# ---------- full model ----------
-class Net(nn.Module):
-    """
-    Returns a Tensor from forward() (never a tuple), so metrics like BLEU can call .dim().
-    API:
-      - __init__(in_shape, out_shape, prm, device)
-      - forward(images, captions=None) -> logits Tensor
-      - train_setup(prm)
-      - learn(train_data)
-    """
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.in_channels = int(in_shape[1])
-        self.vocab_size  = int(out_shape[0])
-
-        # Hyperparams
-        self.dropout_p = float(prm.get('dropout', 0.1))
-        self.max_len   = int(prm.get('max_len', 20))
-
-        # Special tokens
-        self.pad_idx, self.bos_id, self.eos_id = _special_ids(GLOBAL_CAPTION_VOCAB or {}, self.vocab_size)
-
-        # Encoder -> sequence of d_model features
-        d_model = 512
-        enc_feat_ch = 256   # AlexNet conv5 output channels
-        self.encoder = CNNEncoder(self.in_channels, feat_ch=enc_feat_ch)
-        self.enc_proj = nn.Linear(enc_feat_ch, d_model)
-        self.enc_pos  = PositionalEncoding(d_model, dropout=self.dropout_p)
-        self.enc_drop = nn.Dropout(self.dropout_p)
-
-        # Transformer decoder
-        self.decoder = TransformerDecoder(self.vocab_size, d_model=d_model, nhead=8,
-                                          num_layers=4, dropout=self.dropout_p, pad_idx=self.pad_idx)
-
-        # Training attrs init in train_setup
-        self.criteria = None
-        self.optimizer = None
-        self.scaler = None
-
-    # -- encoder helper --
-    def _encode(self, images: torch.Tensor) -> torch.Tensor:
-        f = self.encoder(images)                     # (B,C,h,w) with C=256
-        B, C, h, w = f.shape
-        seq = f.view(B, C, h*w).permute(0, 2, 1)    # (B,S,C) where S=h*w
-        seq = self.enc_proj(seq)                    # (B,S,D)
-        seq = self.enc_pos(seq)
-        seq = self.enc_drop(seq)
-        return seq                                   # (B,S,D)
-
-    # -- forward --
-    def forward(self, images, captions=None):
-        """
-        Training (teacher forcing):
-            inputs = captions[:, :-1] -> logits over positions 1..T-1
-            returns logits: (B, T-1, V)
-        Inference (captions=None):
-            greedy decode up to max_len
-            returns logits: (B, L, V) of generated steps
-        """
-        assert images.dim() == 4, "images must be (B,C,H,W)"
-        memory = self._encode(images)  # (B,S,D)
-
-        if captions is not None:
-            if captions.ndim == 3:
-                captions = captions[:, 0, :]        # (B,T)
-            inputs = captions[:, :-1]               # (B,T-1)
-            logits = self.decoder(inputs, memory)   # (B,T-1,V)
-            return logits                           # Tensor ONLY
-
-        # Inference: greedy
-        B = images.size(0)
-        device = images.device
-        cur = torch.full((B, 1), self.bos_id, dtype=torch.long, device=device)
-        steps = []
-        for _ in range(self.max_len):
-            step_logits = self.decoder(cur, memory)[:, -1:, :]  # (B,1,V)
-            steps.append(step_logits)
-            next_tok = step_logits.argmax(dim=-1)                # (B,1)
-            cur = torch.cat([cur, next_tok], dim=1)
-            if (next_tok.squeeze(1) == self.eos_id).all():
-                break
-        logits = torch.cat(steps, dim=1) if steps else torch.zeros((B, 0, self.vocab_size), device=device)
-        return logits                                           # Tensor ONLY
-
-    # -- training setup --
-    def train_setup(self, prm):
-        self.to(self.device)
-        # Loss: ignore PAD; label smoothing helps BLEU
-        self.criteria = (nn.CrossEntropyLoss(ignore_index=self.pad_idx, label_smoothing=0.1).to(self.device),)
-        # Map "momentum" → AdamW beta1 to keep CLI semantics
-        beta1 = float(prm.get('momentum', 0.9))
-        self.optimizer = torch.optim.AdamW(self.parameters(),
-                                           lr=float(prm['lr']),
-                                           betas=(beta1, 0.999),
-                                           weight_decay=1e-4)
-        # AMP (PyTorch 2.x API)
-        self.scaler = torch.amp.GradScaler('cuda', enabled=(self.device.type == 'cuda'))
-
-    # -- one epoch training loop --
-    def learn(self, train_data):
-        """
-        Expects batches like (images, captions, *rest).
-        """
-        assert self.criteria and self.optimizer is not None and self.scaler is not None, "Call train_setup(prm) first."
-        self.train()
-        amp_device = 'cuda' if self.device.type == 'cuda' else 'cpu'
-        for batch in train_data:
-            if isinstance(batch, (list, tuple)):
-                images, captions = batch[0], batch[1]
-            else:
-                images, captions = batch
-            images = images.to(self.device, non_blocking=True)
-            captions = captions.to(self.device, non_blocking=True)
-
-            with torch.amp.autocast(amp_device, enabled=(self.device.type == 'cuda')):
-                if captions.ndim == 3:
-                    captions = captions[:, 0, :]
-                logits = self.forward(images, captions)          # (B,T-1,V)
-                targets = captions[:, 1:]                        # (B,T-1)
-                loss = self.criteria[0](logits.reshape(-1, logits.size(-1)),
-                                        targets.reshape(-1))
-
-            self.optimizer.zero_grad(set_to_none=True)
-            self.scaler.scale(loss).backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3.0)
-            self.scaler.step(self.optimizer)
-            self.scaler.update()

test/nn/C10C-ResNetTransformer-187ccbee8050ac295637ecedecb4da1e.py

@@ -1,193 +0,0 @@
-import math
-from typing import Optional
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-def supported_hyperparameters():
-    return {"lr", "momentum"}
-
-
-# ---------------- blocks ----------------
-
-class SEBlock(nn.Module):
-    def __init__(self, c: int, r: int = 8):
-        super().__init__()
-        m = max(4, c // r)
-        self.fc1 = nn.Linear(c, m)
-        self.fc2 = nn.Linear(m, c)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        b, c, h, w = x.size()
-        s = x.mean(dim=(2, 3))
-        s = F.relu(self.fc1(s))
-        s = torch.sigmoid(self.fc2(s)).view(b, c, 1, 1)
-        return x * s
-
-
-class ConvBlock(nn.Module):
-    def __init__(self, in_c: int, out_c: int, stride: int = 1):
-        super().__init__()
-        self.conv1 = nn.Conv2d(in_c, out_c, 3, stride=stride, padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(out_c)
-        self.conv2 = nn.Conv2d(out_c, out_c, 3, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(out_c)
-        self.se = SEBlock(out_c)
-        self.skip = None
-        if stride != 1 or in_c != out_c:
-            self.skip = nn.Sequential(nn.Conv2d(in_c, out_c, 1, stride=stride, bias=False),
-                                      nn.BatchNorm2d(out_c))
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        id = x
-        x = F.relu(self.bn1(self.conv1(x)), inplace=True)
-        x = self.bn2(self.conv2(x))
-        if self.skip is not None:
-            id = self.skip(id)
-        x = F.relu(x + id, inplace=True)
-        x = self.se(x)
-        return x
-
-
-class PositionalEncodingBF(nn.Module):
-    def __init__(self, d_model: int, max_len: int = 512):
-        super().__init__()
-        pe = torch.zeros(max_len, d_model)
-        pos = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
-        div = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float) * (-math.log(10000.0) / d_model))
-        pe[:, 0::2] = torch.sin(pos * div)
-        pe[:, 1::2] = torch.cos(pos * div)
-        self.register_buffer("pe", pe, persistent=False)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # x: [B, T, D]
-        T = x.size(1)
-        return x + self.pe[:T].unsqueeze(0)
-
-
-# ---------------- encoder/decoder ----------------
-
-class CNNEncoder(nn.Module):
-    def __init__(self, in_ch: int, d_model: int):
-        super().__init__()
-        self.stem = nn.Sequential(
-            nn.Conv2d(in_ch, 64, 7, stride=2, padding=3, bias=False),
-            nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(3, stride=2, padding=1),
-        )
-        self.s1 = ConvBlock(64, 128, stride=2)
-        self.s2 = ConvBlock(128, 256, stride=2)
-        self.s3 = ConvBlock(256, 256, stride=1)
-        self.head = nn.Sequential(
-            nn.Conv2d(256, d_model, 1, bias=False), nn.BatchNorm2d(d_model), nn.ReLU(inplace=True),
-            nn.AdaptiveAvgPool2d(1),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.stem(x); x = self.s1(x); x = self.s2(x); x = self.s3(x)
-        x = self.head(x).squeeze(-1).squeeze(-1)        # [B, D]
-        return x.unsqueeze(1)                           # [B, 1, D]
-
-
-class TransformerCaptionDecoder(nn.Module):
-    def __init__(self, vocab: int, d_model: int = 640, nhead: int = 8, layers: int = 2, dim_ff: int = 2048, dropout: float = 0.2):
-        super().__init__()
-        assert d_model % nhead == 0
-        self.embed = nn.Embedding(vocab, d_model, padding_idx=0)
-        self.pe = PositionalEncodingBF(d_model)
-        layer = nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_ff,
-                                           dropout=dropout, batch_first=True)
-        self.dec = nn.TransformerDecoder(layer, num_layers=layers)
-        self.proj = nn.Linear(d_model, vocab, bias=False)
-        self.proj.weight = self.embed.weight
-
-    @staticmethod
-    def _causal_mask(T: int, device: torch.device):
-        m = torch.full((T, T), float("-inf"), device=device)
-        return torch.triu(m, diagonal=1)
-
-    def forward(self, tokens: torch.Tensor, memory: torch.Tensor) -> torch.Tensor:
-        x = self.embed(tokens) * math.sqrt(self.embed.embedding_dim)
-        x = self.pe(x)
-        mask = self._causal_mask(x.size(1), x.device)
-        x = self.dec(tgt=x, memory=memory, tgt_mask=mask)
-        return self.proj(x)                                   # [B, T, V]
-
-
-# ---------------- Net (API) ----------------
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device):
-        super().__init__()
-        self.device = device
-        in_ch = int(in_shape[1])
-        vocab = int(out_shape[0])
-
-        d_model = int(prm.get("hidden_dim", 640))
-        nhead = int(prm.get("nhead", 8))
-        layers = int(prm.get("dec_layers", 2))
-        dim_ff = int(prm.get("dim_ff", 2048))
-        dropout = float(prm.get("dropout", 0.2))
-
-        self.encoder = CNNEncoder(in_ch, d_model)
-        self.rnn = TransformerCaptionDecoder(vocab, d_model, nhead, layers, dim_ff, dropout)
-        self.vocab = vocab
-
-        self.criterion = nn.CrossEntropyLoss(ignore_index=0, label_smoothing=0.05)
-        self.optimizer = None
-
-    @staticmethod
-    def _norm_caps(caps: Optional[torch.Tensor]) -> Optional[torch.Tensor]:
-        if caps is None: return None
-        if caps.ndim == 1: caps = caps.unsqueeze(0)
-        elif caps.ndim == 3: caps = caps[:, 0, :]
-        return caps.long()
-
-    def train_setup(self, prm: dict):
-        self.to(self.device)
-        lr = max(float(prm.get("lr", 1e-3)), 1e-3)
-        b1 = min(0.99, max(0.7, float(prm.get("momentum", 0.9))))
-        self.optimizer = torch.optim.AdamW(self.parameters(), lr=lr, betas=(b1, 0.999), weight_decay=1e-4)
-        self.criterion = self.criterion.to(self.device)
-
-    def learn(self, train_data):
-        self.train()
-        for images, captions in train_data:
-            images = images.to(self.device, non_blocking=True)
-            captions = captions.to(self.device, non_blocking=True)
-
-            caps = self._norm_caps(captions)                 # [B, T]
-            inp, tgt = caps[:, :-1], caps[:, 1:]             # [B, T-1]
-
-            mem = self.encoder(images)                       # [B, 1, D]
-            logits = self.rnn(inp, mem)                      # [B, T-1, V]
-
-            assert logits.shape[1] == inp.shape[1] and logits.shape[-1] == self.vocab
-            loss = self.criterion(logits.reshape(-1, self.vocab), tgt.reshape(-1))
-
-            self.optimizer.zero_grad(set_to_none=True)
-            loss.backward()
-            torch.nn.utils.clip_grad_norm_(self.parameters(), 3.0)
-            self.optimizer.step()
-
-    def forward(self, images: torch.Tensor, captions: Optional[torch.Tensor] = None, hidden_state=None) -> torch.Tensor:
-        images = images.to(self.device, non_blocking=True)
-        mem = self.encoder(images)                           # [B, 1, D]
-
-        if captions is None:
-            # simple greedy stub
-            B = images.size(0)
-            seq = torch.full((B, 1), 1, dtype=torch.long, device=self.device)  # <SOS>=1
-            for _ in range(19):
-                lg = self.rnn(seq, mem)
-                nxt = lg[:, -1, :].argmax(-1, keepdim=True)
-                seq = torch.cat([seq, nxt], dim=1)
-                if (nxt == 2).all(): break                   # <EOS>=2
-            return self.rnn(seq, mem)
-
-        caps = self._norm_caps(captions).to(self.device)     # [B, T]
-        inp = caps[:, :-1]                                   # [B, T-1]
-        logits = self.rnn(inp, mem)                          # [B, T-1, V]
-        pad = torch.zeros((caps.size(0), 1, self.vocab), device=logits.device, dtype=logits.dtype)
-        return torch.cat([pad, logits], dim=1)               # [B, T, V]

test/nn/C5C-RESNETLSTM-4.py

@@ -1,222 +0,0 @@
-import torch
-from torch import nn, Tensor
-from typing import Any, Optional
-from collections import Counter
-
-
-def supported_hyperparameters():
-    # NN-GPT / NN-Dataset expect exactly {'lr','momentum'} at module level
-    return {"lr", "momentum"}
-
-
-def _first_int(x: Any) -> int:
-    if isinstance(x, int):
-        return x
-    if isinstance(x, (tuple, list)) and len(x) > 0:
-        return _first_int(x[0])
-    try:
-        return int(x)
-    except Exception:
-        return 10000
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: Any, out_shape: Any, prm: dict, device: torch.device, *_, **__):
-        super().__init__()
-
-        self.device = device
-        self.in_shape = in_shape
-        self.out_shape = out_shape
-        self.prm = dict(prm) if prm is not None else {}
-
-        # Infer channels from in_shape (supports (C,H,W) or (N,C,H,W))
-        if isinstance(in_shape, (tuple, list)) and len(in_shape) > 1:
-            self.in_channels = int(in_shape[1])
-        else:
-            self.in_channels = 3
-
-        # vocab_size from out_shape, e.g. (V,) or V
-        self.vocab_size = _first_int(out_shape)
-
-        emb_dim = 512
-        hid_dim = 512
-        drop = float(self.prm.get("dropout", 0.2))
-
-        # Stable CNN encoder -> [B, 256]
-        self.encoder = nn.Sequential(
-            nn.Conv2d(self.in_channels, 64, 3, 2, 1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(64, 128, 3, 2, 1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(128, 256, 3, 2, 1),
-            nn.ReLU(inplace=True),
-            nn.AdaptiveAvgPool2d((1, 1)),
-            nn.Flatten()
-        )
-        self.enc_fc = nn.Linear(256, emb_dim)
-
-        # Caption decoder
-        self.embed = nn.Embedding(self.vocab_size, emb_dim, padding_idx=0)
-        self.drop = nn.Dropout(drop)
-        self.lstm = nn.LSTM(emb_dim, hid_dim, batch_first=True)
-        self.fc = nn.Linear(hid_dim, self.vocab_size)
-
-        # Training helpers
-        self.criterion: Optional[nn.Module] = None
-        self.optimizer: Optional[torch.optim.Optimizer] = None
-
-        # Token stats for a simple fallback in predict()
-        self._token_counts = Counter()
-        self._have_stats = False
-        self._bos = 1
-        self._eos = 2
-        self._pad = 0
-        self._max_len = 16
-
-    # Class-level helper (not used by harness, but kept)
-    def supported_hyperparameters(self):
-        return {"lr", "momentum", "dropout"}
-
-    def _norm(self, caps: Tensor) -> Tensor:
-        # Normalize caption shape to [B, T]
-        if caps.dim() == 1:
-            return caps.unsqueeze(0)
-        if caps.dim() == 3:
-            # e.g. [B, 1, T]
-            return caps[:, 0, :]
-        return caps
-
-    def _enc(self, x: Tensor):
-        # Encode image -> initial LSTM hidden state
-        feats = self.encoder(x)          # [B, 256]
-        ctx = self.enc_fc(feats)         # [B, emb_dim]
-        h0 = torch.tanh(ctx).unsqueeze(0)  # [1, B, H]
-        c0 = torch.tanh(ctx).unsqueeze(0)  # [1, B, H]
-        return (h0, c0)
-
-    def forward(self, images: Tensor, captions: Optional[Tensor] = None):
-        images = images.to(self.device, dtype=torch.float32)
-
-        # Training / teacher forcing path
-        if captions is not None:
-            captions = captions.to(self.device, dtype=torch.long)
-            captions = self._norm(captions)  # [B, T]
-
-            if captions.size(1) <= 1:
-                # Degenerate case: no real caption content
-                B = captions.size(0)
-                dummy = torch.zeros(B, 1, self.lstm.hidden_size, device=self.device)
-                return self.fc(dummy)
-
-            # Update frequency stats for predict() fallback
-            with torch.no_grad():
-                valid = captions[captions != self._pad].reshape(-1)
-                for t in valid.tolist():
-                    self._token_counts[int(t)] += 1
-            self._have_stats = len(self._token_counts) > 0
-
-            dec_in = captions[:, :-1]                # [B, T-1]
-            emb = self.drop(self.embed(dec_in))      # [B, T-1, E]
-            h0, c0 = self._enc(images)               # ([1,B,H],[1,B,H])
-            out, _ = self.lstm(emb, (h0, c0))        # [B, T-1, H]
-            logits = self.fc(self.drop(out))         # [B, T-1, V]
-            return logits
-
-        # Inference path: generate tokens for BLEU
-        return self.predict(images)
-
-    def train_setup(self, prm: dict):
-        lr = float(prm.get("lr", 1e-3))
-        mom = float(prm.get("momentum", 0.9))
-        drop = float(prm.get("dropout", self.prm.get("dropout", 0.2)))
-        self.drop.p = drop
-
-        self.to(self.device)
-        self.train()
-
-        self.criterion = nn.CrossEntropyLoss(ignore_index=self._pad)
-        self.optimizer = torch.optim.AdamW(self.parameters(), lr=lr, betas=(mom, 0.999))
-
-    def learn(self, data):
-        if self.optimizer is None:
-            prm = getattr(data, "prm", self.prm)
-            self.train_setup(prm)
-
-        self.train()
-
-        for batch in data:
-            if isinstance(batch, (list, tuple)):
-                if len(batch) < 2:
-                    continue
-                imgs, caps = batch[0], batch[1]
-            elif isinstance(batch, dict):
-                imgs = batch.get("x", None)
-                caps = batch.get("y", None)
-                if imgs is None or caps is None:
-                    continue
-            else:
-                imgs = getattr(batch, "x", None)
-                caps = getattr(batch, "y", None)
-                if imgs is None or caps is None:
-                    continue
-
-            imgs = imgs.to(self.device)
-            caps = caps.to(self.device)
-            caps = self._norm(caps)
-            if caps.size(1) <= 1:
-                continue
-
-            logits = self.forward(imgs, caps)  # [B, T-1, V]
-            targets = caps[:, 1:]              # [B, T-1]
-
-            loss = self.criterion(
-                logits.reshape(-1, self.vocab_size),
-                targets.reshape(-1),
-            )
-
-            self.optimizer.zero_grad(set_to_none=True)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 1.0)
-            self.optimizer.step()
-
-    @torch.no_grad()
-    def predict(self, images: Tensor) -> Tensor:
-        """
-        Greedy decoding for BLEU eval.
-        Returns [B, T] token IDs.
-        """
-        self.eval()
-        images = images.to(self.device)
-        B = images.size(0)
-
-        # If we have token stats from training, return a simple "common tokens" caption
-        if self._have_stats:
-            common = [
-                t for (t, _) in self._token_counts.most_common(self._max_len + 4)
-                if t != self._pad
-            ]
-            if not common:
-                common = [self._bos]
-
-            base = common[: self._max_len - 2]
-            seq = [self._bos] + base + [self._eos]
-            tokens = torch.tensor(seq, dtype=torch.long, device=self.device)
-            return tokens.unsqueeze(0).repeat(B, 1)
-
-        # Otherwise, decode with LSTM
-        h0, c0 = self._enc(images)
-        tokens = torch.full((B, 1), self._bos, dtype=torch.long, device=self.device)
-
-        for _ in range(self._max_len - 1):
-            emb = self.drop(self.embed(tokens[:, -1:]))  # [B,1,E]
-            out, (h0, c0) = self.lstm(emb, (h0, c0))      # [B,1,H]
-            nxt = self.fc(out).argmax(-1)                 # [B,1]
-            tokens = torch.cat([tokens, nxt], dim=1)
-            if (nxt == self._eos).all():
-                break
-
-        return tokens
-
-
-def model_net(in_shape, out_shape, prm, device):
-    return Net(in_shape, out_shape, prm, device)

test/nn/C5C-RESNETLSTM-c42512d71480c8ef10f31e3e6c33bbdf.py

@@ -1,150 +0,0 @@
-import torch
-import torch.nn as nn
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-class Encoder(nn.Module):
-    def __init__(self, in_channels: int, embed_size: int):
-        super().__init__()
-        self.conv1 = nn.Conv2d(in_channels, 32, kernel_size=7, stride=2, padding=3)
-        self.bn1 = nn.BatchNorm2d(32)
-        self.relu = nn.ReLU(inplace=True)
-        self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
-        self.bn2 = nn.BatchNorm2d(64)
-        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
-        self.bn3 = nn.BatchNorm2d(128)
-        self.adap_pool = nn.AdaptiveMaxPool2d(7)
-        self.fc = nn.Linear(128 * 7 * 7, embed_size)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.relu(self.bn1(self.conv1(x)))
-        x = self.pool(x)
-        x = self.relu(self.bn2(self.conv2(x)))
-        x = self.pool(self.relu(self.bn3(self.conv3(x))))
-        x = self.adap_pool(x)
-        x = x.view(x.size(0), -1)
-        x = self.fc(x)
-        return x
-
-class DecoderRNN(nn.Module):
-    def __init__(self, embed_size: int, hidden_size: int, vocab_size: int, drop_prob: float = 0.0, num_layers: int = 1):
-        super().__init__()
-        self.embed = nn.Embedding(vocab_size, embed_size)
-        self.lstm = nn.LSTM(input_size=embed_size * 2, hidden_size=hidden_size, num_layers=num_layers, batch_first=True, dropout=0.0)
-        self.fc = nn.Linear(hidden_size, vocab_size)
-        self.hidden_size = hidden_size
-        self.embed_size = embed_size
-        self.vocab_size = vocab_size
-
-    def init_hidden(self, batch_size: int, device: torch.device):
-        h = torch.zeros(1, batch_size, self.hidden_size, device=device)
-        c = torch.zeros(1, batch_size, self.hidden_size, device=device)
-        return (h, c)
-
-    def init_zero_hidden(self, batch_size: int, device: torch.device):
-        return self.init_hidden(batch_size, device)
-
-    def forward(self, inputs: torch.Tensor, hidden: tuple, encoder_features: torch.Tensor):
-        B, T = inputs.size()
-        embeds = self.embed(inputs)
-        h, c = hidden
-        outputs = []
-        for t in range(T):
-            word_t = embeds[:, t, :]
-            step_in = torch.cat([word_t, encoder_features], dim=1)
-            out, (h, c) = self.lstm(step_in.unsqueeze(1), (h, c))
-            outputs.append(self.fc(out.squeeze(1)))
-        logits = torch.stack(outputs, dim=1)
-        return logits, (h, c)
-
-    @torch.no_grad()
-    def generate(self, encoder_features: torch.Tensor, hidden: tuple, max_len: int = 50, start_token: int = 1, end_token: int = 2):
-        device = encoder_features.device
-        B = encoder_features.size(0)
-        cur = torch.full((B,), start_token, dtype=torch.long, device=device)
-        generated = []
-        for _ in range(max_len):
-            step_logits, hidden = self.forward(cur.unsqueeze(1), hidden, encoder_features)
-            next_ids = step_logits.squeeze(1).argmax(dim=1)
-            generated.append(next_ids)
-            cur = next_ids
-            if (next_ids == end_token).all():
-                break
-        if len(generated) == 0:
-            return torch.empty(B, 0, dtype=torch.long, device=device), hidden
-        return torch.stack(generated, dim=1), hidden
-
-class Net(nn.Module):
-    def __init__(self, in_shape, out_shape, prm, device):
-        super().__init__()
-        self.device = device
-        in_channels = int(in_shape[1])
-        self.vocab_size = int(out_shape[0])
-        embed_size = 256
-        hidden_size = 512
-        self.encoder = Encoder(in_channels, embed_size)
-        self.rnn = DecoderRNN(embed_size, hidden_size, self.vocab_size, drop_prob=0.0)
-        self.criterion = nn.CrossEntropyLoss(ignore_index=0)
-        self.optimizer = None
-
-    @staticmethod
-    def _normalize_captions(captions: torch.Tensor) -> torch.Tensor:
-        if captions is None:
-            return None
-        if captions.ndim == 3:
-            captions = captions[:, 0, :]
-        elif captions.ndim == 1:
-            captions = captions.unsqueeze(0)
-        if captions.dtype != torch.long:
-            captions = captions.long()
-        return captions
-
-    def _ensure_hidden(self, hidden_state, batch_size: int):
-        if hidden_state is None:
-            return self.rnn.init_zero_hidden(batch_size, self.device)
-        h = hidden_state[0]
-        if h.size(1) != batch_size:
-            return self.rnn.init_zero_hidden(batch_size, self.device)
-        return hidden_state
-
-    def forward(self, images, captions=None, hidden_state=None):
-        B = images.size(0)
-        features = self.encoder(images)
-        captions = self._normalize_captions(captions)
-        hidden_state = self._ensure_hidden(hidden_state, B)
-        if captions is not None:
-            inputs = captions[:, :-1]
-            logits, _ = self.rnn(inputs, hidden_state, features)
-            return logits
-        tokens, _ = self.rnn.generate(features, hidden_state, max_len=50)
-        return tokens
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        lr = float(prm.get('lr', 1e-3)) if isinstance(prm, dict) else 1e-3
-        momentum = float(prm.get('momentum', 0.9)) if isinstance(prm, dict) else 0.9
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=lr, momentum=momentum)
-        self.criterion = self.criterion.to(self.device)
-
-    def learn(self, train_data):
-        self.train()
-        for images, captions in train_data:
-            images = images.to(self.device)
-            captions = captions.to(self.device)
-            caps_for_loss = self._normalize_captions(captions)
-            self.optimizer.zero_grad()
-            logits = self(images, captions, None)
-            T_eff = caps_for_loss.size(1) - 1
-            if logits.size(1) != T_eff:
-                T_match = min(logits.size(1), T_eff)
-                logits = logits[:, :T_match, :]
-                caps_for_loss = caps_for_loss[:, :T_match + 1]
-            loss = self.criterion(
-                logits.contiguous().view(-1, self.vocab_size),
-                caps_for_loss[:, 1:].contiguous().view(-1).long()
-            )
-            loss.backward()
-            torch.nn.utils.clip_grad_norm_(self.parameters(), 3.0)
-            self.optimizer.step()

test/nn/C5C-ResNetTransformer-83fb6b6bb7c76b742ad0713d29463514.py

@@ -1,181 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class SEBlock(nn.Module):
-    def __init__(self, channels: int, reduction: int = 4):
-        super().__init__()
-        hidden = max(1, channels // reduction)
-        self.avg = nn.AdaptiveAvgPool2d(1)
-        self.fc1 = nn.Conv2d(channels, hidden, kernel_size=1, bias=True)
-        self.fc2 = nn.Conv2d(hidden, channels, kernel_size=1, bias=True)
-
-    def forward(self, x):
-        s = self.avg(x)
-        s = F.relu(self.fc1(s), inplace=True)
-        s = torch.sigmoid(self.fc2(s))
-        return x * s
-
-
-class InvertedResidual(nn.Module):
-    def __init__(self, in_ch: int, out_ch: int, stride: int = 1, expand: int = 3, se_ratio: float = 0.5):
-        super().__init__()
-        hidden = in_ch * expand
-        self.use_res = (stride == 1 and in_ch == out_ch)
-        layers = []
-        if expand != 1:
-            layers += [nn.Conv2d(in_ch, hidden, 1, bias=False), nn.BatchNorm2d(hidden), nn.SiLU(inplace=True)]
-        else:
-            hidden = in_ch
-        layers += [
-            nn.Conv2d(hidden, hidden, 3, stride, 1, groups=hidden, bias=False),
-            nn.BatchNorm2d(hidden),
-            nn.SiLU(inplace=True),
-        ]
-        layers += [nn.Conv2d(hidden, out_ch, 1, bias=False), nn.BatchNorm2d(out_ch)]
-        self.block = nn.Sequential(*layers)
-        red = max(1, int(round(1.0 / se_ratio))) if se_ratio > 0 else 4
-        self.se = SEBlock(out_ch, reduction=red) if se_ratio > 0 else nn.Identity()
-
-    def forward(self, x):
-        out = self.block(x)
-        out = self.se(out)
-        if self.use_res:
-            out = out + x
-        return out
-
-
-class Encoder(nn.Module):
-    def __init__(self, in_channels: int, hidden_dim: int = 512, se_ratio: float = 0.5):
-        super().__init__()
-        c1, c2, c3 = 64, 128, hidden_dim
-        self.stem = nn.Sequential(
-            nn.Conv2d(in_channels, c1, 3, 2, 1, bias=False),
-            nn.BatchNorm2d(c1),
-            nn.SiLU(inplace=True),
-        )
-        self.stage1 = InvertedResidual(c1, c1, stride=1, expand=3, se_ratio=se_ratio)
-        self.stage2 = InvertedResidual(c1, c2, stride=2, expand=3, se_ratio=se_ratio)
-        self.stage3 = InvertedResidual(c2, c3, stride=2, expand=3, se_ratio=se_ratio)
-        self.pool = nn.AdaptiveAvgPool2d(1)
-
-    def forward(self, x):
-        x = self.stem(x)
-        x = self.stage1(x)
-        x = self.stage2(x)
-        x = self.stage3(x)
-        x = self.pool(x).flatten(1)
-        return x.unsqueeze(1)
-
-
-class PositionalEncoding(nn.Module):
-    def __init__(self, d_model: int, max_len: int = 5000):
-        super().__init__()
-        pe = torch.zeros(max_len, d_model)
-        pos = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
-        div = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float) * (-math.log(10000.0) / d_model))
-        pe[:, 0::2] = torch.sin(pos * div)
-        pe[:, 1::2] = torch.cos(pos * div)
-        pe = pe.unsqueeze(0)
-        self.register_buffer("pe", pe, persistent=False)
-
-    def forward(self, x):
-        T = x.size(1)
-        return x + self.pe[:, :T, :]
-
-
-class TransformerShim(nn.Module):
-    def __init__(self, vocab_size: int, d_model: int = 512, nhead: int = 8, num_layers: int = 1, dim_ff: int = 2048):
-        super().__init__()
-        assert d_model % nhead == 0
-        self.d_model = d_model
-        self.embedding = nn.Embedding(vocab_size, d_model)
-        self.pos = PositionalEncoding(d_model)
-        layer = nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_ff, batch_first=True)
-        self.dec = nn.TransformerDecoder(layer, num_layers=num_layers)
-        self.fc = nn.Linear(d_model, vocab_size)
-        self.num_layers = num_layers
-
-    def init_zero_hidden(self, batch: int, device: torch.device):
-        h0 = torch.zeros(self.num_layers, batch, self.d_model, device=device)
-        c0 = torch.zeros(self.num_layers, batch, self.d_model, device=device)
-        return (h0, c0)
-
-    def forward(self, inputs: torch.Tensor, hidden_state, features: torch.Tensor):
-        x = self.embedding(inputs) * math.sqrt(self.d_model)
-        x = self.pos(x)
-        T = inputs.size(1)
-        mask = torch.triu(torch.full((T, T), float('-inf'), device=inputs.device), diagonal=1)
-        out = self.dec(tgt=x, memory=features, tgt_mask=mask)
-        logits = self.fc(out)
-        return logits, hidden_state
-
-    @torch.no_grad()
-    def greedy_decode(self, features: torch.Tensor, max_len: int, sos: int = 1, eos: int = 2):
-        B = features.size(0)
-        ys = torch.full((B, 1), sos, dtype=torch.long, device=features.device)
-        for _ in range(max_len):
-            x = self.embedding(ys) * math.sqrt(self.d_model)
-            x = self.pos(x)
-            T = x.size(1)
-            mask = torch.triu(torch.full((T, T), float('-inf'), device=ys.device), diagonal=1)
-            out = self.dec(tgt=x, memory=features, tgt_mask=mask)
-            next_logits = self.fc(out[:, -1, :])
-            next_ids = next_logits.argmax(dim=-1, keepdim=True)
-            ys = torch.cat([ys, next_ids], dim=1)
-            if (next_ids == eos).all():
-                break
-        return ys[:, 1:]
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape, out_shape, prm, device):
-        super().__init__()
-        self.device = device
-        in_channels = int(in_shape[1])
-        vocab_size = int(out_shape[0])
-        hidden_dim = int(prm.get('hidden_dim', 512))
-        nhead = 8 if hidden_dim % 8 == 0 else 4
-        self.encoder = Encoder(in_channels, hidden_dim=hidden_dim, se_ratio=0.5)
-        self.rnn = TransformerShim(vocab_size=vocab_size, d_model=hidden_dim, nhead=nhead, num_layers=1, dim_ff=2048)
-        self.vocab_size = vocab_size
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss(ignore_index=0).to(self.device),)
-        beta1 = float(prm.get('momentum', 0.9))
-        self.optimizer = torch.optim.AdamW(self.parameters(), lr=float(prm['lr']), betas=(beta1, 0.999), weight_decay=0.01)
-
-    def learn(self, train_data):
-        self.train()
-        for images, captions in train_data:
-            images = images.to(self.device)
-            captions = captions.to(self.device)
-            logits, _ = self(images, captions, None)
-            tgt = (captions[:, 0, :] if captions.ndim == 3 else captions)[:, 1:]
-            loss = self.criteria[0](logits.reshape(-1, logits.size(-1)), tgt.reshape(-1))
-            self.optimizer.zero_grad()
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3.0)
-            self.optimizer.step()
-
-    def forward(self, images, captions=None, hidden_state=None):
-        assert images.dim() == 4
-        features = self.encoder(images)
-        if captions is None:
-            return self.rnn.greedy_decode(features, max_len=50)
-        if captions.ndim == 3:
-            captions = captions[:, 0, :]
-        inputs = captions[:, :-1]
-        assert inputs.dtype == torch.long
-        if hidden_state is None:
-            hidden_state = self.rnn.init_zero_hidden(images.size(0), images.device)
-        logits, hidden_state = self.rnn(inputs, hidden_state, features)
-        assert logits.dim() == 3 and logits.shape[1] == inputs.shape[1]
-        return logits, hidden_state

test/nn/C8C-ResNetTransformer-7730b6eb6979d27e2e1bbc7d05255dff.py

@@ -1,239 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class ChannelAttention(nn.Module):
-    def __init__(self, channel, reduction=4):
-        super().__init__()
-        self.avg_pool = nn.AdaptiveAvgPool2d(1)
-        self.max_pool = nn.AdaptiveMaxPool2d(1)
-        self.shared_mlp = nn.Sequential(
-            nn.Conv2d(channel, channel // reduction, 1, bias=False),
-            nn.ReLU(),
-            nn.Conv2d(channel // reduction, channel, 1, bias=False)
-        )
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        avg_out = self.shared_mlp(self.avg_pool(x))
-        max_out = self.shared_mlp(self.max_pool(x))
-        return self.sigmoid(avg_out + max_out)
-
-
-class SpatialAttention(nn.Module):
-    def __init__(self, kernel_size=7):
-        super().__init__()
-        self.pool = nn.MaxPool2d(kernel_size, stride=1, padding=kernel_size//2)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        edge = self.pool(x)
-        return x * self.sigmoid(edge)
-
-
-class CABlock(nn.Module):
-    def __init__(self, channel, reduction=4, kernel_size=7):
-        super().__init__()
-        self.channel_att = ChannelAttention(channel, reduction)
-        self.spatial_att = SpatialAttention(kernel_size)
-        self.conv = nn.Conv2d(channel, channel, 1)
-
-    def forward(self, x):
-        out = x.clone()
-        out = self.conv(out)
-        out = self.channel_att(out) * out + out
-        out = self.spatial_att(out)
-        return out
-
-
-class CBAM(nn.Module):
-    def __init__(self, channel, reduction=4, kernel_size=7):
-        super().__init__()
-        self.channel = ChannelAttention(channel, reduction)
-        self.spatial = SpatialAttention(kernel_size)
-
-    def forward(self, x):
-        return self.channel(x) * x + self.spatial(x) * x
-
-
-class MBConvBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, expand=4.0, kernel_size=5, stride=1, se_ratio=4.0, drop_rate=0.1, index=0):
-        super().__init__()
-        self.has_se = (out_channels != in_channels)
-        self.depth_multiplier = expand
-        self.pointwise_conv1 = nn.Conv2d(in_channels, int(in_channels * self.depth_multiplier), 1, bias=False)
-        self.bn1 = nn.BatchNorm2d(int(in_channels * self.depth_multiplier))
-        self.act1 = nn.GELU()
-        self.depth_conv = nn.Conv2d(int(in_channels * self.depth_multiplier), int(in_channels * self.depth_multiplier), kernel_size, padding=kernel_size//2, groups=int(in_channels * self.depth_multiplier), stride=stride, bias=False)
-        self.bn2 = nn.BatchNorm2d(int(in_channels * self.depth_multiplier))
-        self.act2 = nn.GELU()
-        self.pointwise_conv2 = nn.Conv2d(int(in_channels * self.depth_multiplier), out_channels, 1, bias=False)
-        self.bn3 = nn.BatchNorm2d(out_channels) if self.has_se else None
-        mid_channels = max(1, int(out_channels // (int(se_ratio) if isinstance(se_ratio, (int, float)) and se_ratio >= 1 else 1)))
-        self.se = nn.Sequential(
-            nn.AdaptiveAvgPool2d(1),
-            nn.Flatten(1),
-            nn.Linear(int(in_channels * self.depth_multiplier), mid_channels, bias=True),
-            nn.ReLU(inplace=True),
-            nn.Linear(mid_channels, out_channels, bias=True),
-            nn.Sigmoid(),
-            nn.Unflatten(1, (out_channels, 1, 1))
-        )
-        
-    def forward(self, x):
-        x = self.pointwise_conv1(x)
-        x = self.bn1(x)
-        x = self.act1(x)
-        if self.depth_conv.kernel_size == (1, 1):
-            shortcut = x
-        else:
-            x = self.depth_conv(x)
-            x = self.bn2(x)
-            x = self.act2(x)
-            shortcut = None
-        x = self.pointwise_conv2(x)
-        if self.has_se and shortcut is not None and x.shape[1] == shortcut.shape[1]:
-            x = self.se(x + shortcut)
-        return x
-
-
-class ScConv(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size=7, stride=1, groups=64, reduction=4, deploy=False):
-        super().__init__()
-        self.identity_connection = in_channels == out_channels and stride == 1
-        self.padding = kernel_size // 2
-        self.empty = False if not deploy else False
-        self.pointwise1 = nn.Conv2d(in_channels, out_channels, 1)
-        self.depth_conv = nn.Conv2d(in_channels, in_channels, kernel_size, stride, kernel_size, bias=False)
-        self.bn2 = nn.BatchNorm2d(in_channels)
-        self.act = nn.GELU()
-        self.pointwise2 = nn.Conv2d(in_channels, out_channels, 1)
-        self.bn3 = nn.BatchNorm2d(out_channels) if self.identity_connection else None
-        self.se = nn.Sequential(
-            nn.AdaptiveAvgPool2d(1),
-            nn.Linear(in_features=in_channels, out_features=in_channels//16)
-        ) if not self.empty else None
-
-    def forward(self, x):
-        identity = x
-        y = self.pointwise1(x)
-        if not self.empty:
-            y = self.depth_conv(y)
-            y = self.bn2(y)
-            y = self.act(y)
-            y = self.pointwise2(y)
-        if self.bn3 is not None:
-            y = self.bn3(y)
-        if self.identity_connection and y.shape == identity.shape:
-            y = identity + y
-        return y
-
-
-class Decoder(nn.Module):
-    def __init__(self, vocab_size, d_model=768, hidden_size=512):
-        super().__init__()
-        self.embedding = nn.Embedding(vocab_size, d_model, padding_idx=0)
-        self.gru = nn.GRU(d_model, hidden_size, batch_first=True)
-        self.fc = nn.Linear(hidden_size, vocab_size)
-        self.init_from_feat = nn.Linear(d_model, hidden_size)
-
-    def init_zero_hidden(self, batch, device):
-        h0 = torch.zeros(1, batch, self.gru.hidden_size, device=device)
-        c0 = torch.zeros_like(h0)
-        return (h0, c0)
-
-    def forward(self, inputs, hidden_state=None, features=None):
-        emb = self.embedding(inputs)
-        if hidden_state is None:
-            if features is not None:
-                h = self.init_from_feat(features).unsqueeze(0)
-            else:
-                h = torch.zeros(1, inputs.size(0), self.gru.hidden_size, device=inputs.device)
-        else:
-            h = hidden_state[0] if isinstance(hidden_state, tuple) else hidden_state
-        out, h = self.gru(emb, h)
-        logits = self.fc(out)
-        return logits, (h, torch.zeros_like(h))
-
-    def greedy_decode(self, features, max_len=20, start_id=1, end_id=2):
-        B = features.size(0)
-        device = features.device
-        h = self.init_from_feat(features).unsqueeze(0)
-        seq = torch.full((B, 1), start_id, dtype=torch.long, device=device)
-        tokens = []
-        for _ in range(max_len):
-            emb = self.embedding(seq[:, -1:])
-            out, h = self.gru(emb, h)
-            next_logits = self.fc(out[:, -1, :])
-            next_ids = next_logits.argmax(-1, keepdim=True)
-            tokens.append(next_ids)
-            seq = torch.cat([seq, next_ids], dim=1)
-            if (next_ids == end_id).all():
-                break
-        if len(tokens) == 0:
-            return torch.zeros((B, 0), dtype=torch.long, device=device)
-        return torch.cat(tokens, dim=1)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape, out_shape, prm, device):
-        super().__init__()
-        self.device = device
-        vocab_size = int(out_shape[0])
-        self.embed_dim = 768
-        self.num_heads = 8
-        self.num_layers = 6
-        self.dropout_rate = 0.1
-        self.prj = prm.get('prj', {})
-        self.dropout = getattr(prm, 'dropout', 0.1)
-        self.attention_dropout = getattr(prm, 'attention_dropout', 0.1)
-        self.use_checkpointing = getattr(prm, 'use_checkpointing', False)
-        self.use_mem_efficient = getattr(prm, 'use_mem_efficient', True)
-        self.projection = nn.Conv2d(3, self.embed_dim, 3, bias=False)
-        self.tokenization = nn.AdaptiveAvgPool2d(1)
-        self.cls_token = nn.Parameter(torch.randn(1, 1, self.embed_dim))
-        self.hybrid_encoder = nn.Sequential(
-            CBAM(64),
-            CBAM(64),
-            ScConv(64, 64),
-            MBConvBlock(64, 64)
-        )
-        self.transformer = nn.TransformerEncoderLayer(d_model=self.embed_dim, nhead=self.num_heads, dropout=self.dropout_rate, batch_first=True)
-        self.fc = nn.Linear(self.embed_dim, vocab_size)
-        self.rnn = Decoder(vocab_size=vocab_size, d_model=self.embed_dim, hidden_size=640)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss(ignore_index=0).to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def forward(self, images, captions=None, hidden_state=None):
-        assert images.dim() == 4
-        feats = self.tokenization(self.projection(images)).flatten(1)
-        if captions is not None:
-            if captions.ndim == 3:
-                captions = captions[:, 0, :]
-            inputs = captions[:, :-1]
-            logits, hidden_state = self.rnn(inputs, hidden_state, features=feats)
-            assert logits.shape[1] == inputs.shape[1]
-            return logits, hidden_state
-        preds = self.rnn.greedy_decode(feats, max_len=20)
-        return preds
-
-    def learn(self, train_data):
-        self.train()
-        for images, captions in train_data:
-            images = images.to(self.device)
-            captions = captions.to(self.device)
-            logits, _ = self.forward(images, captions, None)
-            tgt = (captions[:, 0, :] if captions.ndim == 3 else captions)[:, 1:]
-            loss = self.criteria[0](logits.reshape(-1, logits.size(-1)), tgt.reshape(-1))
-            self.optimizer.zero_grad()
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/ComplexNet.py

@@ -1,295 +0,0 @@
-from collections import OrderedDict
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch._C import _disabled_torch_function_impl
-from torch.nn import init, Module, Conv2d, Linear
-from torch.nn.functional import relu, max_pool2d
-
-
-def _retrieve_elements_from_indices(tensor, indices):
-    flattened_tensor = tensor.flatten(start_dim=-2)
-    output = flattened_tensor.gather(dim=-1, index=indices.flatten(start_dim=-2)).view_as(indices)
-    return output
-
-
-def apply_complex(fr, fi, input, dtype=torch.complex64):
-    return (fr(input.real) - fi(input.imag)).type(dtype) \
-        + 1j * (fr(input.imag) + fi(input.real)).type(dtype)
-
-
-def complex_relu(input):
-    return relu(input.real).type(torch.complex64) + 1j * relu(input.imag).type(torch.complex64)
-
-
-def complex_max_pool2d(input, kernel_size, stride=None, padding=0,
-                       dilation=1, ceil_mode=False, return_indices=False):
-    absolute_value, indices = max_pool2d(
-        input.abs(),
-        kernel_size=kernel_size,
-        stride=stride,
-        padding=padding,
-        dilation=dilation,
-        ceil_mode=ceil_mode,
-        return_indices=True
-    )
-    absolute_value = absolute_value.type(torch.complex64)
-    angle = torch.atan2(input.imag, input.real)
-    angle = _retrieve_elements_from_indices(angle, indices)
-    return absolute_value \
-        * (torch.cos(angle).type(torch.complex64) + 1j * torch.sin(angle).type(torch.complex64))
-
-
-class _ParameterMeta(torch._C._TensorMeta):
-    def __instancecheck__(self, instance):
-        if self is Parameter:
-            if isinstance(instance, torch.Tensor) and getattr(
-                    instance, "_is_param", False
-            ):
-                return True
-        return super().__instancecheck__(instance)
-
-
-class Parameter(torch.Tensor, metaclass=_ParameterMeta):
-    def __new__(cls, data=None, requires_grad=True):
-        if data is None:
-            data = torch.empty(0)
-        if type(data) is torch.Tensor or type(data) is Parameter:
-            return torch.Tensor._make_subclass(cls, data, requires_grad)
-
-        t = data.detach().requires_grad_(requires_grad)
-        if type(t) is not type(data):
-            raise RuntimeError(
-                f"Creating a Parameter from an instance of type {type(data).__name__} "
-                "requires that detach() returns an instance of the same type, but return "
-                f"type {type(t).__name__} was found instead. To use the type as a "
-                "Parameter, please correct the detach() semantics defined by "
-                "its __torch_dispatch__() implementation."
-            )
-        t._is_param = True
-        return t
-
-    def __deepcopy__(self, memo):
-        if id(self) in memo:
-            return memo[id(self)]
-        else:
-            result = type(self)(
-                self.data.clone(memory_format=torch.preserve_format), self.requires_grad
-            )
-            memo[id(self)] = result
-            return result
-
-    def __repr__(self):
-        return "Parameter containing:\n" + super().__repr__()
-
-    def __reduce_ex__(self, proto):
-        state = torch._utils._get_obj_state(self)
-
-        hooks = OrderedDict()
-        if not state:
-            return (
-                torch._utils._rebuild_parameter,
-                (self.data, self.requires_grad, hooks),
-            )
-
-        return (
-            torch._utils._rebuild_parameter_with_state,
-            (self.data, self.requires_grad, hooks, state),
-        )
-
-    __torch_function__ = _disabled_torch_function_impl
-
-
-class _ComplexBatchNorm(Module):
-
-    def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True,
-                 track_running_stats=True):
-        super(_ComplexBatchNorm, self).__init__()
-        self.num_features = num_features
-        self.eps = eps
-        self.momentum = momentum
-        self.affine = affine
-        self.track_running_stats = track_running_stats
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        if self.affine:
-            self.weight = Parameter(torch.Tensor(num_features, 3)).to(self.device)
-            self.bias = Parameter(torch.Tensor(num_features, 2)).to(self.device)
-        else:
-            self.register_parameter('weight', None)
-            self.register_parameter('bias', None)
-        if self.track_running_stats:
-            self.register_buffer('running_mean', torch.zeros(num_features, dtype=torch.complex64))
-            self.register_buffer('running_covar', torch.zeros(num_features, 3))
-            self.running_covar[:, 0] = 1.4142135623730951
-            self.running_covar[:, 1] = 1.4142135623730951
-            self.register_buffer('num_batches_tracked', torch.tensor(0, dtype=torch.long))
-        else:
-            self.register_parameter('running_mean', None)
-            self.register_parameter('running_covar', None)
-            self.register_parameter('num_batches_tracked', None)
-        self.reset_parameters()
-
-    def reset_running_stats(self):
-        if self.track_running_stats:
-            self.running_mean.zero_()
-            self.running_covar.zero_()
-            self.running_covar[:, 0] = 1.4142135623730951
-            self.running_covar[:, 1] = 1.4142135623730951
-            self.num_batches_tracked.zero_()
-
-    def reset_parameters(self):
-        self.reset_running_stats()
-        if self.affine:
-            init.constant_(self.weight[:, :2], 1.4142135623730951)
-            init.zeros_(self.weight[:, 2])
-            init.zeros_(self.bias)
-
-
-class ComplexBatchNorm2d(_ComplexBatchNorm):
-
-    def forward(self, input):
-        exponential_average_factor = 0.0
-
-        if self.training and self.track_running_stats:
-            if self.num_batches_tracked is not None:
-                self.num_batches_tracked += 1
-                if self.momentum is None:
-                    exponential_average_factor = 1.0 / float(self.num_batches_tracked)
-                else:
-                    exponential_average_factor = self.momentum
-
-        if self.training or (not self.training and not self.track_running_stats):
-            mean_r = input.real.mean([0, 2, 3]).type(torch.complex64)
-            mean_i = input.imag.mean([0, 2, 3]).type(torch.complex64)
-            mean = mean_r + 1j * mean_i
-        else:
-            mean = self.running_mean
-
-        if self.training and self.track_running_stats:
-            with torch.no_grad():
-                self.running_mean = exponential_average_factor * mean \
-                                    + (1 - exponential_average_factor) * self.running_mean
-
-        input = input - mean[None, :, None, None]
-
-        if self.training or (not self.training and not self.track_running_stats):
-            n = input.numel() / input.size(1)
-            Crr = 1. / n * input.real.pow(2).sum(dim=[0, 2, 3]) + self.eps
-            Cii = 1. / n * input.imag.pow(2).sum(dim=[0, 2, 3]) + self.eps
-            Cri = (input.real.mul(input.imag)).mean(dim=[0, 2, 3])
-        else:
-            Crr = self.running_covar[:, 0] + self.eps
-            Cii = self.running_covar[:, 1] + self.eps
-            Cri = self.running_covar[:, 2]
-
-        if self.training and self.track_running_stats:
-            with torch.no_grad():
-                self.running_covar[:, 0] = exponential_average_factor * Crr * n / (n - 1) \
-                                           + (1 - exponential_average_factor) * self.running_covar[:, 0]
-
-                self.running_covar[:, 1] = exponential_average_factor * Cii * n / (n - 1) \
-                                           + (1 - exponential_average_factor) * self.running_covar[:, 1]
-
-                self.running_covar[:, 2] = exponential_average_factor * Cri * n / (n - 1) \
-                                           + (1 - exponential_average_factor) * self.running_covar[:, 2]
-
-        det = Crr * Cii - Cri.pow(2)
-        s = torch.sqrt(det)
-        t = torch.sqrt(Cii + Crr + 2 * s)
-        inverse_st = 1.0 / (s * t)
-        Rrr = (Cii + s) * inverse_st
-        Rii = (Crr + s) * inverse_st
-        Rri = -Cri * inverse_st
-
-        input = (Rrr[None, :, None, None] * input.real + Rri[None, :, None, None] * input.imag).type(torch.complex64) \
-                + 1j * (Rii[None, :, None, None] * input.imag + Rri[None, :, None, None] * input.real).type(torch.complex64)
-
-        if self.affine:
-            input = (self.weight[None, :, 0, None, None] * input.real + self.weight[None, :, 2, None, None] * input.imag + \
-                     self.bias[None, :, 0, None, None]).type(torch.complex64) \
-                    + 1j * (self.weight[None, :, 2, None, None] * input.real + self.weight[None, :, 1, None, None] * input.imag + \
-                            self.bias[None, :, 1, None, None]).type(torch.complex64)
-
-        return input
-
-
-class ComplexConv2d(Module):
-
-    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=0,
-                 dilation=1, groups=1, bias=True):
-        super(ComplexConv2d, self).__init__()
-        self.conv_r = Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
-        self.conv_i = Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
-
-    def forward(self, input):
-        return apply_complex(self.conv_r, self.conv_i, input)
-
-
-class ComplexLinear(Module):
-
-    def __init__(self, in_features, out_features):
-        super(ComplexLinear, self).__init__()
-        self.fc_r = Linear(in_features, out_features)
-        self.fc_i = Linear(in_features, out_features)
-
-    def forward(self, input):
-        return apply_complex(self.fc_r, self.fc_i, input)
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        self.in_channels = in_shape[1]
-        self.in_height = in_shape[2]
-        self.in_width = in_shape[3]
-        self.conv1 = ComplexConv2d(self.in_channels, 10, 5, 1)
-        self.bn = ComplexBatchNorm2d(10)
-        self.conv2 = ComplexConv2d(10, 20, 5, 1)
-        self.to(self.device)
-        tmp_input = torch.full(in_shape, fill_value=0.1).type(torch.complex64).to(self.device)
-        x = self.forward1(tmp_input)
-        self.interim_size = int(x.view(-1).size()[0] / in_shape[0])
-        self.fc1 = ComplexLinear(self.interim_size, 500)
-        self.fc2 = ComplexLinear(500, out_shape[0])
-
-    def forward1(self, x):
-        x = x.view(-1, self.in_channels, self.in_height, self.in_width)
-        x = self.conv1(x)
-        x = complex_relu(x)
-        x = complex_max_pool2d(x, 2, 2)
-        x = self.bn(x)
-        x = complex_relu(self.conv2(x))
-        x = complex_max_pool2d(x, 2, 2)
-        return x
-
-    def forward(self, x):
-        x = self.forward1(x)
-        x = x.view(-1, self.interim_size)
-        x = self.fc1(x)
-        x = complex_relu(x)
-        x = self.fc2(x)
-        x = x.abs()
-        x = F.log_softmax(x, dim=1)
-        return x

test/nn/ConditionalDiffusion.py

@@ -1,230 +0,0 @@
-
-import torch
-import torch.nn as nn
-import numpy as np
-import os
-import glob
-from PIL import Image
-import itertools
-
-from diffusers import AutoencoderKL, UNet2DConditionModel, DDPMScheduler
-from transformers import AutoTokenizer, AutoModel
-
-# Optional import for 8-bit optimizer
-try:
-    import bitsandbytes as bnb
-
-    BITSANDBYTES_AVAILABLE = True
-except ImportError:
-    BITSANDBYTES_AVAILABLE = False
-
-
-def supported_hyperparameters():
-    """Returns the hyperparameters supported by this model."""
-    return {'lr', 'beta1', 'beta2', 'steps_per_epoch'}
-
-
-class Net(nn.Module):
-    """
-    The main Net class that holds the Diffusion components and implements the
-    framework's training and evaluation logic.
-    """
-
-    class TextEncoder(nn.Module):
-        def __init__(self, out_size=768):
-            super().__init__()
-            model_name = "distilbert-base-uncased"
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-            self.text_model = AutoModel.from_pretrained(model_name)
-            self.text_linear = nn.Linear(768, out_size)
-            for param in self.text_model.parameters():
-                param.requires_grad = False
-
-        def forward(self, text):
-            device = self.text_linear.weight.device
-            inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True)
-            outputs = self.text_model(
-                input_ids=inputs.input_ids.to(device),
-                attention_mask=inputs.attention_mask.to(device)
-            )
-            return self.text_linear(outputs.last_hidden_state)
-
-    def __init__(self, in_shape, out_shape, prm, device):
-        super().__init__()
-        self.device = device
-        self.prm = prm or {}
-        self.epoch_counter = 0
-        self.model_name = "CLDiffusion"
-
-        self.vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse").to(device)
-        self.vae.requires_grad_(False)
-
-        self.text_encoder = self.TextEncoder(out_size=prm.get('cross_attention_dim', 768)).to(device)
-
-        latent_size = in_shape[2] // 8
-
-        self.unet = UNet2DConditionModel(
-            sample_size=latent_size,
-            in_channels=4,
-            out_channels=4,
-            down_block_types=("DownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D"),
-            up_block_types=("UpBlock2D", "CrossAttnUpBlock2D", "UpBlock2D"),
-            block_out_channels=(128, 256, 512),
-            cross_attention_dim=prm.get('cross_attention_dim', 768)
-        ).to(device)
-
-        #  Enable Memory-Efficient Attention (xFormers) if available
-        try:
-            self.unet.enable_xformers_memory_efficient_attention()
-            print("xFormers memory-efficient attention enabled.")
-        except Exception:
-            print("xFormers not available. Using standard attention.")
-
-        # Gradient checkpointing is already enabled, which is great for memory saving.
-        self.unet.enable_gradient_checkpointing()
-        self.noise_scheduler = DDPMScheduler(num_train_timesteps=1000, beta_schedule="squaredcos_cap_v2")
-
-        #  Setup for Mixed-Precision Training
-        self.scaler = torch.cuda.amp.GradScaler()
-
-        # self.checkpoint_dir = os.path.join("checkpoints", self.model_name)
-        # if not os.path.exists(self.checkpoint_dir):
-        #     os.makedirs(self.checkpoint_dir)
-        # self.load_checkpoint()
-
-    # def load_checkpoint(self):
-    #     # (omitted for brevity - no changes from previous version)
-    #     unet_files = glob.glob(os.path.join(self.checkpoint_dir, f'{self.model_name}_unet_epoch_*.pth'))
-    #     text_encoder_files = glob.glob(os.path.join(self.checkpoint_dir, f'{self.model_name}_text_encoder_epoch_*.pth'))
-    #
-    #     if unet_files and text_encoder_files:
-    #         latest_unet = max(unet_files, key=os.path.getctime)
-    #         latest_text_encoder = max(text_encoder_files, key=os.path.getctime)
-    #         print(f"Loading UNet checkpoint: {latest_unet}")
-    #         print(f"Loading Text Encoder checkpoint: {latest_text_encoder}")
-    #         self.unet.load_state_dict(torch.load(latest_unet, map_location=self.device))
-    #         self.text_encoder.load_state_dict(torch.load(latest_text_encoder, map_location=self.device))
-    #         try:
-    #             self.epoch_counter = int(os.path.basename(latest_unet).split('_')[-1].split('.')[0])
-    #         except (ValueError, IndexError):
-    #             self.epoch_counter = 0
-    #     else:
-    #         print("No checkpoint found, starting from scratch.")
-
-    def train_setup(self, prm):
-        trainable_params = list(self.unet.parameters()) + list(self.text_encoder.text_linear.parameters())
-        lr = prm['lr']
-        beta1 = prm['beta1']
-        beta2 = prm['beta2']
-
-        #  Optional 8-bit Optimizer
-        # To use, ensure 'bitsandbytes' is installed and uncomment the following lines.
-        # if BITSANDBYTES_AVAILABLE:
-        #     print("Using 8-bit AdamW optimizer.")
-        #     self.optimizer = bnb.optim.AdamW8bit(trainable_params, lr=lr, betas=(beta1, 0.999))
-        # else:
-        #     print("Using standard AdamW optimizer.")
-        self.optimizer = torch.optim.AdamW(trainable_params, lr=lr, betas=(beta1, beta2))
-
-        self.criterion = nn.MSELoss()
-        # self.scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, 'max', patience=50, factor=0.5)
-
-    def learn(self, train_data):
-        self.train()
-        total_loss = 0.0
-
-        if not hasattr(self, 'infinite_data_loader'):
-            self.infinite_data_loader = itertools.cycle(train_data)
-
-        num_steps = int(self.prm['steps_per_epoch'] * 400)
-
-        if num_steps == 0:
-            print("Warning: 'steps_per_epoch' is zero. Skipping training for this epoch.")
-            return 0.0
-
-        for i in range(num_steps):
-            batch = next(self.infinite_data_loader)
-            images, text_prompts = batch
-            self.optimizer.zero_grad()
-
-            with torch.no_grad():
-                latents = self.vae.encode(images.to(self.device)).latent_dist.sample() * 0.18215
-
-            noise = torch.randn_like(latents)
-            timesteps = torch.randint(0, self.noise_scheduler.config.num_train_timesteps, (latents.shape[0],),
-                                      device=self.device)
-            noisy_latents = self.noise_scheduler.add_noise(latents, noise, timesteps)
-
-            text_embeddings = self.text_encoder(text_prompts)
-
-            # --- NEW: Mixed-Precision Training Context ---
-            with torch.cuda.amp.autocast():
-                noise_pred = self.unet(sample=noisy_latents, timestep=timesteps,
-                                       encoder_hidden_states=text_embeddings).sample
-                loss = self.criterion(noise_pred, noise)
-
-            #  Scale loss and update weights ---
-            self.scaler.scale(loss).backward()
-            self.scaler.step(self.optimizer)
-            self.scaler.update()
-
-            total_loss += loss.item()
-
-        self.epoch_counter += 1
-
-        # unet_path = os.path.join(self.checkpoint_dir, f"{self.model_name}_unet_epoch_{self.epoch_counter}.pth")
-        # text_encoder_path = os.path.join(self.checkpoint_dir,
-        #                                  f"{self.model_name}_text_encoder_epoch_{self.epoch_counter}.pth")
-        # torch.save(self.unet.state_dict(), unet_path)
-        # torch.save(self.text_encoder.state_dict(), text_encoder_path)
-        # print(f"\nCompleted epoch {self.epoch_counter}. Saved checkpoint to {unet_path} and {text_encoder_path}")
-
-        return total_loss / num_steps
-
-    @torch.no_grad()
-    def generate(self, text_prompts, num_inference_steps=50):
-        # (omitted for brevity)
-        self.eval()
-        text_embeddings = self.text_encoder(text_prompts)
-        latents = torch.randn((len(text_prompts), self.unet.config.in_channels, self.unet.config.sample_size,
-                               self.unet.config.sample_size), device=self.device)
-        self.noise_scheduler.set_timesteps(num_inference_steps)
-        for t in self.noise_scheduler.timesteps:
-            noise_pred = self.unet(sample=latents, timestep=t, encoder_hidden_states=text_embeddings).sample
-            latents = self.noise_scheduler.step(noise_pred, t, latents).prev_sample
-
-        latents = 1 / 0.18215 * latents
-        images = self.vae.decode(latents).sample
-        images = (images / 2 + 0.5).clamp(0, 1)
-        images = images.cpu().permute(0, 2, 3, 1).numpy()
-        return [Image.fromarray((img * 255).astype(np.uint8)) for img in images]
-
-    @torch.no_grad()
-    def forward(self, images, **kwargs):
-        # (omitted for brevity - no changes from previous version)
-        batch_size = images.size(0)
-        fixed_prompts_for_eval = [
-            "a photo of a dog", "a painting of a car", "a smiling person"
-        ]
-        prompts_to_use = [fixed_prompts_for_eval[i % len(fixed_prompts_for_eval)] for i in range(batch_size)]
-
-        output_dir = os.path.join("output_images", self.model_name)
-        if not os.path.exists(output_dir):
-            os.makedirs(output_dir)
-
-        # custom_prompts_to_generate = [
-        #     "a smiling woman with blond hair",
-        #     "a man wearing eyeglasses"
-        # ]
-        # if custom_prompts_to_generate:
-        #     print(f"\n[Inference] Generating {len(custom_prompts_to_generate)} custom image(s)...")
-        #     custom_images = self.generate(custom_prompts_to_generate)
-        #     for i, img in enumerate(custom_images):
-        #         save_path = os.path.join(output_dir,
-        #                                  f"{self.model_name}_output_epoch_{self.epoch_counter}_image_{i + 1}.png")
-        #         img.save(save_path)
-        #         print(f"[Inference] Saved custom image to {save_path}")
-
-        eval_images = self.generate(prompts_to_use)
-
-        return eval_images, prompts_to_use

test/nn/ConditionalGAN.py

@@ -1,278 +0,0 @@
-import torch
-import torch.nn as nn
-import os
-import torchvision.utils as vutils
-from torch.optim.lr_scheduler import LambdaLR
-# --- MODIFICATION: Added for the new 'generate' method ---
-from torchvision.transforms.functional import to_pil_image
-from torch.nn.utils import spectral_norm
-
-try:
-    from transformers import CLIPTokenizer
-except ImportError:
-    raise ImportError("Please install transformers: pip install transformers")
-
-
-def supported_hyperparameters():
-    """Returns the set of hyperparameters supported by this model."""
-    return {'lr', 'beta1'}
-
-
-class Self_Attn(nn.Module):
-    """ Self attention Layer"""
-
-    def __init__(self, in_dim):
-        super(Self_Attn, self).__init__()
-        self.chanel_in = in_dim
-        self.query_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim // 8, kernel_size=1)
-        self.key_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim // 8, kernel_size=1)
-        self.value_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)
-        self.gamma = nn.Parameter(torch.zeros(1))
-        self.softmax = nn.Softmax(dim=-1)
-
-    def forward(self, x):
-        m_batchsize, C, width, height = x.size()
-        proj_query = self.query_conv(x).view(m_batchsize, -1, width * height).permute(0, 2, 1)
-        proj_key = self.key_conv(x).view(m_batchsize, -1, width * height)
-        energy = torch.bmm(proj_query, proj_key)
-        attention = self.softmax(energy)
-        proj_value = self.value_conv(x).view(m_batchsize, -1, width * height)
-        out = torch.bmm(proj_value, attention.permute(0, 2, 1))
-        out = out.view(m_batchsize, C, width, height)
-        out = self.gamma * out + x
-        return out
-
-
-class Net(nn.Module):
-    class Generator(nn.Module):
-        # --- No changes needed in Generator subclass ---
-        def __init__(self, noise_dim, embed_dim, hidden_dim, vocab_size, img_channels, feature_maps):
-            super().__init__()
-            self.embedding = nn.Embedding(vocab_size, embed_dim)
-            self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
-            input_dim = noise_dim + hidden_dim
-            self.l1 = nn.Sequential(
-                spectral_norm(nn.ConvTranspose2d(input_dim, feature_maps * 16, 4, 1, 0, bias=False)),
-                nn.BatchNorm2d(feature_maps * 16), nn.ReLU(True))
-            self.l2 = nn.Sequential(
-                spectral_norm(nn.ConvTranspose2d(feature_maps * 16, feature_maps * 8, 4, 2, 1, bias=False)),
-                nn.BatchNorm2d(feature_maps * 8), nn.ReLU(True))
-            self.l3 = nn.Sequential(
-                spectral_norm(nn.ConvTranspose2d(feature_maps * 8, feature_maps * 4, 4, 2, 1, bias=False)),
-                nn.BatchNorm2d(feature_maps * 4), nn.ReLU(True))
-            self.attn1 = Self_Attn(feature_maps * 4)
-            self.l4 = nn.Sequential(
-                spectral_norm(nn.ConvTranspose2d(feature_maps * 4, feature_maps * 2, 4, 2, 1, bias=False)),
-                nn.BatchNorm2d(feature_maps * 2), nn.ReLU(True))
-            self.l5 = nn.Sequential(
-                spectral_norm(nn.ConvTranspose2d(feature_maps * 2, feature_maps, 4, 2, 1, bias=False)),
-                nn.BatchNorm2d(feature_maps), nn.ReLU(True))
-            self.attn2 = Self_Attn(feature_maps)
-            self.l6 = nn.Sequential(
-                spectral_norm(nn.ConvTranspose2d(feature_maps, img_channels, 4, 2, 1, bias=False)),
-                nn.Tanh())
-
-        def forward(self, noise, text_tokens):
-            embeddings = self.embedding(text_tokens)
-            _, (hidden, _) = self.lstm(embeddings)
-            text_conditioning = hidden.squeeze(0)
-            x = torch.cat([noise, text_conditioning], dim=1)
-            x = self.l1(x.unsqueeze(2).unsqueeze(3))
-            x = self.l2(x)
-            x = self.l3(x)
-            x = self.attn1(x)
-            x = self.l4(x)
-            x = self.l5(x)
-            x = self.attn2(x)
-            x = self.l6(x)
-            return x
-
-    class Discriminator(nn.Module):
-        # --- No changes needed in Discriminator subclass ---
-        def __init__(self, embed_dim, hidden_dim, vocab_size, img_channels, feature_maps):
-            super().__init__()
-            self.embedding = spectral_norm(nn.Embedding(vocab_size, embed_dim))
-            self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
-            self.image_path = nn.Sequential(
-                spectral_norm(nn.Conv2d(img_channels, feature_maps, 4, 2, 1, bias=False)),
-                nn.LeakyReLU(0.2, inplace=True),
-                spectral_norm(nn.Conv2d(feature_maps, feature_maps * 2, 4, 2, 1, bias=False)),
-                nn.LeakyReLU(0.2, inplace=True))
-            self.text_path = nn.Sequential(
-                spectral_norm(nn.Linear(hidden_dim, feature_maps * 2)), nn.ReLU())
-            self.combined_path1 = nn.Sequential(
-                spectral_norm(nn.Conv2d(feature_maps * 4, feature_maps * 8, 4, 2, 1, bias=False)),
-                nn.LeakyReLU(0.2, inplace=True))
-            self.attn = Self_Attn(feature_maps * 8)
-            self.combined_path2 = nn.Sequential(
-                spectral_norm(nn.Conv2d(feature_maps * 8, feature_maps * 16, 4, 2, 1, bias=False)),
-                nn.LeakyReLU(0.2, inplace=True),
-                spectral_norm(nn.Conv2d(feature_maps * 16, 1, kernel_size=8, stride=1, padding=0, bias=False)))
-
-        def forward(self, image, text_tokens):
-            image_features = self.image_path(image)
-            embeddings = self.embedding(text_tokens)
-            _, (hidden, _) = self.lstm(embeddings)
-            text_conditioning = hidden.squeeze(0)
-            text_features = self.text_path(text_conditioning)
-            _, _, H, W = image_features.shape
-            text_features_replicated = text_features.unsqueeze(2).unsqueeze(3).expand(-1, -1, H, W)
-            combined_features = torch.cat([image_features, text_features_replicated], dim=1)
-            x = self.combined_path1(combined_features)
-            x = self.attn(x)
-            x = self.combined_path2(x)
-            return x.view(-1)
-
-    def __init__(self, shape_a, shape_b, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        self.prm = prm
-        self.vocab_size = 49408
-        img_channels = 3
-        self.noise_dim = 100
-        embed_dim, hidden_dim, feature_maps = 64, 128, 48
-        self.tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32")
-        self.max_length = 16
-        self.generator = self.Generator(
-            self.noise_dim, embed_dim, hidden_dim, self.vocab_size, img_channels, feature_maps
-        ).to(device)
-        self.discriminator = self.Discriminator(
-            embed_dim, hidden_dim, self.vocab_size, img_channels, feature_maps
-        ).to(device)
-        self.r1_penalty_weight = 10.0
-
-        # --- MODIFICATION: New checkpointing logic ---
-        # The model name is derived from the config in Train.py and used to create a unique directory
-        model_name = self.__class__.__module__.split('.')[-1]
-        self.checkpoint_dir = os.path.join('out', 'checkpoints', model_name)
-        os.makedirs(self.checkpoint_dir, exist_ok=True)
-        self.best_model_path = os.path.join(self.checkpoint_dir, 'best_model.pth')
-        self.best_accuracy = -1.0  # Initialize with a very low value
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        lr = float(prm.get('lr', 0.0002))
-        beta1 = float(prm.get('beta1', 0.5))
-        lr_g, lr_d = lr / 4.0, lr
-        self.optimizer_G = torch.optim.Adam(self.generator.parameters(), lr=lr_g, betas=(beta1, 0.999))
-        self.optimizer_D = torch.optim.Adam(self.discriminator.parameters(), lr=lr_d, betas=(beta1, 0.999))
-        total_epochs = 150
-
-        def lr_lambda(epoch):
-            if epoch < total_epochs / 2:
-                return 1.0
-            else:
-                return 1.0 - (epoch - total_epochs / 2) / (total_epochs / 2)
-
-        self.scheduler_G = LambdaLR(self.optimizer_G, lr_lambda=lr_lambda)
-        self.scheduler_D = LambdaLR(self.optimizer_D, lr_lambda=lr_lambda)
-        self.criterion = nn.BCEWithLogitsLoss().to(self.device)
-        torch.backends.cudnn.benchmark = True
-
-        # --- MODIFICATION: Resume from the single best checkpoint if it exists ---
-        if os.path.exists(self.best_model_path):
-            try:
-                print(f"--- Found best model checkpoint at {self.best_model_path}. Resuming training. ---")
-                # Loads the state dict for the entire Net module (includes G and D)
-                self.load_state_dict(torch.load(self.best_model_path, map_location=self.device))
-            except Exception as e:
-                print(f"Could not load best model checkpoint, starting from scratch. Error: {e}")
-
-    def learn(self, train_data, current_epoch=0):
-        # --- The main training logic for one epoch remains largely the same ---
-        for i, data_batch in enumerate(train_data):
-            self.generator.train()
-            self.discriminator.train()
-            real_images, raw_text_prompts = data_batch
-            tokenized_prompts = self.tokenizer(
-                list(raw_text_prompts), padding='max_length', truncation=True,
-                max_length=self.max_length, return_tensors="pt")
-            text_tokens = tokenized_prompts['input_ids'].to(self.device)
-            real_images = real_images.to(self.device)
-            b_size = real_images.size(0)
-            real_target = torch.full((b_size,), 0.9, device=self.device)
-            fake_target = torch.full((b_size,), 0.1, device=self.device)
-
-            for _ in range(2):  # Update D twice
-                self.optimizer_D.zero_grad()
-                real_images.requires_grad = True
-                output_real = self.discriminator(real_images, text_tokens)
-                loss_d_real = self.criterion(output_real, real_target)
-                grad_real = torch.autograd.grad(outputs=output_real.sum(), inputs=real_images, create_graph=True)[0]
-                grad_penalty = (grad_real.view(grad_real.size(0), -1).norm(2, dim=1) ** 2).mean()
-                r1_penalty = self.r1_penalty_weight / 2 * grad_penalty
-                with torch.no_grad():
-                    noise = torch.randn(b_size, self.noise_dim, device=self.device)
-                    fake_images = self.generator(noise, text_tokens).detach()
-                output_fake = self.discriminator(fake_images, text_tokens)
-                loss_d_fake = self.criterion(output_fake, fake_target)
-                loss_d = loss_d_real + loss_d_fake + r1_penalty
-                loss_d.backward()
-                self.optimizer_D.step()
-                real_images.requires_grad = False
-
-            self.optimizer_G.zero_grad()  # Update G once
-            generator_real_target = torch.full((b_size,), 1.0, device=self.device)
-            noise_g = torch.randn(b_size, self.noise_dim, device=self.device)
-            fake_images_for_g = self.generator(noise_g, text_tokens)
-            output_g = self.discriminator(fake_images_for_g, text_tokens)
-            loss_g = self.criterion(output_g, generator_real_target)
-            loss_g.backward()
-            self.optimizer_G.step()
-
-            if i % 100 == 0:
-                print(
-                    f'[{current_epoch}][{i}/{len(train_data)}] Loss_D: {loss_d.item():.4f} Loss_G: {loss_g.item():.4f}')
-        self.scheduler_G.step()
-        self.scheduler_D.step()
-
-        # --- MODIFICATION: Removed the old periodic checkpointing logic from here ---
-        return loss_g.item()
-
-    # --- NEW METHOD: This is called by Train.py after each evaluation ---
-    def save_if_best(self, current_accuracy):
-        """
-        Saves the model's state_dict only if the current accuracy is the best seen so far.
-        """
-        if current_accuracy > self.best_accuracy:
-            self.best_accuracy = current_accuracy
-            print(f"--- New best accuracy: {current_accuracy:.4f}. Saving model to {self.best_model_path} ---")
-            # Save the entire state dict of the Net module
-            torch.save(self.state_dict(), self.best_model_path)
-
-    # --- MODIFICATION: Hijacked forward pass for evaluation (remains the same) ---
-    def forward(self, input_tensor: torch.Tensor, text_prompts: list = None):
-        self.generator.eval()
-        prompts_to_use = ["a red car on the street"]  # Fallback prompt
-        if text_prompts is not None:
-            valid_prompts = [p for p in text_prompts if isinstance(p, str) and p.strip()]
-            if valid_prompts:
-                prompts_to_use = valid_prompts
-        tokenized_prompts = self.tokenizer(
-            prompts_to_use, padding='max_length', truncation=True,
-            max_length=self.max_length, return_tensors="pt")['input_ids'].to(self.device)
-        noise = torch.randn(len(prompts_to_use), self.noise_dim, device=self.device)
-        with torch.no_grad():
-            generated_tensors = self.generator(noise, tokenized_prompts)
-            generated_tensors = generated_tensors * 0.5 + 0.5
-            return (generated_tensors, prompts_to_use)
-
-    # --- NEW METHOD: This is called by save_results.py for final image generation ---
-    def generate(self, text_prompts: list):
-        """
-        Generates images from a list of text prompts and returns them as PIL Images.
-        """
-        self.generator.eval()
-        if not text_prompts:
-            return []
-        tokenized_prompts = self.tokenizer(
-            text_prompts, padding='max_length', truncation=True,
-            max_length=self.max_length, return_tensors="pt")['input_ids'].to(self.device)
-        noise = torch.randn(len(text_prompts), self.noise_dim, device=self.device)
-        with torch.no_grad():
-            generated_tensors = self.generator(noise, tokenized_prompts)
-            generated_tensors = (generated_tensors * 0.5 + 0.5).clamp(0, 1)  # Denormalize
-
-        # Convert tensors to a list of the PIL
-        pil_images = [to_pil_image(tensor) for tensor in generated_tensors]
-        return pil_images

test/nn/ConditionalVAE3.py

@@ -1,213 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torchvision.models as models
-import torchvision.transforms as T
-import math
-import os
-# Import the required function for saving weights from the framework's utility file.
-from ab.nn.util.Util import export_torch_weights
-from transformers import CLIPTextModel, CLIPTokenizer
-
-
-def supported_hyperparameters():
-    """Returns the hyperparameters supported by this model."""
-    # 'save_weights' flag to make checkpointing controllable.
-    return {'lr', 'momentum', 'version', 'save_weights'}
-
-
-class PerceptualLoss(nn.Module):
-    def __init__(self):
-        super(PerceptualLoss, self).__init__()
-        vgg = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1).features[:23].eval()
-        self.vgg = nn.Sequential(*vgg)
-        for param in self.vgg.parameters():
-            param.requires_grad = False
-        self.l1 = nn.L1Loss()
-        self.normalize = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-
-    def forward(self, y_hat, y):
-        y_hat_norm = self.normalize(y_hat)
-        y_norm = self.normalize(y)
-        vgg_y_hat = self.vgg(y_hat_norm)
-        vgg_y = self.vgg(y_norm)
-        return self.l1(vgg_y_hat, vgg_y)
-
-
-class SelfAttention(nn.Module):
-    def __init__(self, in_channels):
-        super().__init__()
-        self.query = nn.Conv2d(in_channels, in_channels // 8, 1)
-        self.key = nn.Conv2d(in_channels, in_channels // 8, 1)
-        self.value = nn.Conv2d(in_channels, in_channels, 1)
-        self.gamma = nn.Parameter(torch.tensor(0.0))
-
-    def forward(self, x):
-        batch_size, C, width, height = x.size()
-        query = self.query(x).view(batch_size, -1, width * height).permute(0, 2, 1)
-        key = self.key(x).view(batch_size, -1, width * height)
-        attention = torch.bmm(query, key).softmax(dim=-1)
-        value = self.value(x).view(batch_size, -1, width * height)
-        out = torch.bmm(value, attention.permute(0, 2, 1))
-        out = out.view(batch_size, C, width, height)
-        return self.gamma * out + x
-
-
-class Net(nn.Module):
-    class TextEncoder(nn.Module):
-        def __init__(self, out_size=128):
-            super().__init__()
-            model_name = "openai/clip-vit-base-patch32"
-            self.tokenizer = CLIPTokenizer.from_pretrained(model_name)
-            self.text_model = CLIPTextModel.from_pretrained(model_name)
-            self.text_linear = nn.Linear(512, out_size)
-            for param in self.text_model.parameters():
-                param.requires_grad = False
-
-        def forward(self, text):
-            device = self.text_linear.weight.device
-            inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True)
-            outputs = self.text_model(
-                input_ids=inputs.input_ids.to(device),
-                attention_mask=inputs.attention_mask.to(device)
-            )
-            return self.text_linear(outputs.pooler_output)
-
-    class CVAE(nn.Module):
-        class UpsampleBlock(nn.Module):
-            def __init__(self, in_channels, out_channels):
-                super().__init__()
-                self.conv = nn.Conv2d(in_channels, out_channels * 4, kernel_size=3, padding=1)
-                self.pixel_shuffle = nn.PixelShuffle(2)
-                self.lrelu = nn.LeakyReLU(0.2, inplace=True)
-
-            def forward(self, x):
-                x = self.conv(x)
-                x = self.pixel_shuffle(x)
-                x = self.lrelu(x)
-                return x
-
-        def __init__(self, latent_dim=512, text_embedding_dim=128, image_channels=3, image_size=256):
-            super().__init__()
-            self.latent_dim = latent_dim
-            self.encoder_conv = nn.Sequential(
-                nn.Conv2d(image_channels, 32, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(32, 64, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(64, 128, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(128, 256, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(256, 512, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(512, 512, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True)
-            )
-
-            with torch.no_grad():
-                dummy_input = torch.zeros(1, image_channels, image_size, image_size)
-                dummy_output = self.encoder_conv(dummy_input)
-                self.final_feature_dim = dummy_output.view(-1).shape[0]
-                self.final_conv_shape = dummy_output.shape
-
-            combined_dim = self.final_feature_dim + text_embedding_dim
-            self.fc_mu = nn.Linear(combined_dim, latent_dim)
-            self.fc_log_var = nn.Linear(combined_dim, latent_dim)
-            self.decoder_input = nn.Linear(latent_dim + text_embedding_dim, self.final_feature_dim)
-
-            self.decoder_conv = nn.Sequential(
-                self.UpsampleBlock(512, 512),
-                self.UpsampleBlock(512, 256),
-                self.UpsampleBlock(256, 128),
-                SelfAttention(128),
-                self.UpsampleBlock(128, 64),
-                self.UpsampleBlock(64, 32),
-                self.UpsampleBlock(32, 16),
-                nn.Conv2d(16, image_channels, kernel_size=3, padding=1),
-                nn.Tanh()
-            )
-
-        def encode(self, image, text_embedding):
-            x = self.encoder_conv(image)
-            x = torch.flatten(x, start_dim=1)
-            combined = torch.cat([x, text_embedding], dim=1)
-            return self.fc_mu(combined), self.fc_log_var(combined)
-
-        def reparameterize(self, mu, log_var):
-            std = torch.exp(0.5 * log_var)
-            eps = torch.randn_like(std)
-            return mu + eps * std
-
-        def decode(self, z, text_embedding):
-            combined = torch.cat([z, text_embedding], dim=1)
-            x = self.decoder_input(combined)
-            x = x.view(-1, *self.final_conv_shape[1:])
-            return self.decoder_conv(x)
-
-    def __init__(self, in_shape, out_shape, prm, device):
-        super().__init__()
-        self.device = device
-        self.prm = prm or {}
-        self.text_embedding_dim = 128
-        self.latent_dim = 512
-        self.model_name = "ConditionalVAE3"
-        self.register_buffer('epoch_counter', torch.tensor(0))
-        image_channels, image_size = in_shape[1], in_shape[2]
-        self.text_encoder = self.TextEncoder(out_size=self.text_embedding_dim).to(device)
-        self.cvae = self.CVAE(self.latent_dim, self.text_embedding_dim, image_channels, image_size).to(device)
-
-        lr = self.prm.get('lr', 1e-4)
-        beta1 = self.prm.get('momentum', 0.9)
-        self.optimizer = torch.optim.Adam(self.cvae.parameters(), lr=lr, betas=(beta1, 0.999))
-        self.reconstruction_loss = nn.L1Loss()
-        self.perceptual_loss = PerceptualLoss().to(device)
-
-
-    def train_setup(self, prm):
-        pass
-
-    def learn(self, train_data, current_epoch=0):
-        self.train()
-        self.epoch_counter = torch.tensor(current_epoch)
-        total_loss = 0.0
-        kld_warmup_epochs = 25
-        max_kld_weight = 0.0000025
-
-        if current_epoch < kld_warmup_epochs:
-            kld_weight = max_kld_weight * ((current_epoch + 1) / kld_warmup_epochs)
-        else:
-            kld_weight = max_kld_weight
-
-        for batch in train_data:
-            real_images, text_prompts = batch
-            real_images = real_images.to(self.device)
-            self.optimizer.zero_grad()
-            text_embeddings = self.text_encoder(text_prompts)
-            mu, log_var = self.cvae.encode(real_images, text_embeddings)
-            z = self.cvae.reparameterize(mu, log_var)
-            reconstructed_images = self.cvae.decode(z, text_embeddings)
-            recon_loss = self.reconstruction_loss(reconstructed_images, real_images)
-            perc_loss = self.perceptual_loss(reconstructed_images, real_images)
-            kld_loss = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())
-            loss = recon_loss + 0.8 * perc_loss + (kld_weight * kld_loss)
-            loss.backward()
-            torch.nn.utils.clip_grad_norm_(self.cvae.parameters(), 1.0)
-            self.optimizer.step()
-            total_loss += loss.item()
-        return total_loss / len(train_data) if train_data else 0.0
-
-    @torch.no_grad()
-    def generate(self, text_prompts):
-        self.eval()
-        num_images = len(text_prompts)
-        z = torch.randn(num_images, self.latent_dim, device=self.device)
-        text_embeddings = self.text_encoder(text_prompts)
-        generated_images = self.cvae.decode(z, text_embeddings)
-        generated_images = (generated_images + 1) / 2
-        return [T.ToPILImage()(img.cpu()) for img in generated_images]
-
-    @torch.no_grad()
-    def forward(self, images, **kwargs):
-        prompts_to_use = kwargs.get('prompts')
-        if not prompts_to_use:
-            batch_size = images.size(0)
-            default_prompts = ["a photo of a car"]
-            prompts_to_use = [default_prompts[i % len(default_prompts)] for i in range(batch_size)]
-
-        generated_images = self.generate(prompts_to_use)
-        return generated_images, prompts_to_use

test/nn/ConditionalVAE4.py

@@ -1,268 +0,0 @@
-# File: ConditionalVAE4.py
-import torch
-import torch.nn as nn
-import torchvision.models as models
-import torchvision.transforms as T
-import math
-import os
-
-from ab.nn.util.Util import export_torch_weights
-from transformers import CLIPTextModel, CLIPTokenizer
-
-
-def supported_hyperparameters():
-    """Returns the hyperparameters supported by this model."""
-    #'save_weights' flag to make checkpointing controllable.
-    return {'lr', 'momentum', 'version', 'lr_g', 'lr_d', 'save_weights'}
-
-
-class PerceptualLoss(nn.Module):
-    def __init__(self):
-        super(PerceptualLoss, self).__init__()
-        vgg = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1).features[:23].eval()
-        self.vgg = nn.Sequential(*vgg)
-        for param in self.vgg.parameters():
-            param.requires_grad = False
-        self.l1 = nn.L1Loss()
-        self.normalize = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-
-    def forward(self, y_hat, y):
-        y_hat_norm = self.normalize(y_hat)
-        y_norm = self.normalize(y)
-        vgg_y_hat = self.vgg(y_hat_norm)
-        vgg_y = self.vgg(y_norm)
-        return self.l1(vgg_y_hat, vgg_y)
-
-
-class SelfAttention(nn.Module):
-    def __init__(self, in_channels):
-        super().__init__()
-        self.query = nn.Conv2d(in_channels, in_channels // 8, 1)
-        self.key = nn.Conv2d(in_channels, in_channels // 8, 1)
-        self.value = nn.Conv2d(in_channels, in_channels, 1)
-        self.gamma = nn.Parameter(torch.tensor(0.0))
-
-    def forward(self, x):
-        batch_size, C, width, height = x.size()
-        query = self.query(x).view(batch_size, -1, width * height).permute(0, 2, 1)
-        key = self.key(x).view(batch_size, -1, width * height)
-        attention = torch.bmm(query, key).softmax(dim=-1)
-        value = self.value(x).view(batch_size, -1, width * height)
-        out = torch.bmm(value, attention.permute(0, 2, 1))
-        out = out.view(batch_size, C, width, height)
-        return self.gamma * out + x
-
-
-class Net(nn.Module):
-    class TextEncoder(nn.Module):
-        def __init__(self, out_size=128):
-            super().__init__()
-            model_name = "openai/clip-vit-base-patch32"
-            self.tokenizer = CLIPTokenizer.from_pretrained(model_name)
-            self.text_model = CLIPTextModel.from_pretrained(model_name)
-            self.text_linear = nn.Linear(512, out_size)
-            for param in self.text_model.parameters():
-                param.requires_grad = False
-
-        def forward(self, text):
-            device = self.text_linear.weight.device
-            inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True)
-            outputs = self.text_model(
-                input_ids=inputs.input_ids.to(device),
-                attention_mask=inputs.attention_mask.to(device)
-            )
-            return self.text_linear(outputs.pooler_output)
-
-    class CVAE(nn.Module):
-        class UpsampleBlock(nn.Module):
-            def __init__(self, in_channels, out_channels):
-                super().__init__()
-                self.conv = nn.Conv2d(in_channels, out_channels * 4, kernel_size=3, padding=1)
-                self.pixel_shuffle = nn.PixelShuffle(2)
-                self.lrelu = nn.LeakyReLU(0.2, inplace=True)
-
-            def forward(self, x):
-                x = self.conv(x)
-                x = self.pixel_shuffle(x)
-                x = self.lrelu(x)
-                return x
-
-        def __init__(self, latent_dim=512, text_embedding_dim=128, image_channels=3, image_size=256):
-            super().__init__()
-            self.latent_dim = latent_dim
-            self.encoder_conv = nn.Sequential(
-                nn.Conv2d(image_channels, 32, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(32, 64, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(64, 128, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(128, 256, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(256, 512, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(512, 512, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True)
-            )
-
-            with torch.no_grad():
-                dummy_input = torch.zeros(1, image_channels, image_size, image_size)
-                dummy_output = self.encoder_conv(dummy_input)
-                self.final_feature_dim = dummy_output.view(-1).shape[0]
-                self.final_conv_shape = dummy_output.shape
-
-            combined_dim = self.final_feature_dim + text_embedding_dim
-            self.fc_mu = nn.Linear(combined_dim, latent_dim)
-            self.fc_log_var = nn.Linear(combined_dim, latent_dim)
-            self.decoder_input = nn.Linear(latent_dim + text_embedding_dim, self.final_feature_dim)
-
-            self.decoder_conv = nn.Sequential(
-                self.UpsampleBlock(512, 512),
-                self.UpsampleBlock(512, 256),
-                self.UpsampleBlock(256, 128),
-                SelfAttention(128),
-                self.UpsampleBlock(128, 64),
-                self.UpsampleBlock(64, 32),
-                self.UpsampleBlock(32, 16),
-                nn.Conv2d(16, image_channels, kernel_size=3, padding=1),
-                nn.Tanh()
-            )
-
-        def encode(self, image, text_embedding):
-            x = self.encoder_conv(image)
-            x = torch.flatten(x, start_dim=1)
-            combined = torch.cat([x, text_embedding], dim=1)
-            return self.fc_mu(combined), self.fc_log_var(combined)
-
-        def reparameterize(self, mu, log_var):
-            std = torch.exp(0.5 * log_var)
-            eps = torch.randn_like(std)
-            return mu + eps * std
-
-        def decode(self, z, text_embedding):
-            combined = torch.cat([z, text_embedding], dim=1)
-            x = self.decoder_input(combined)
-            x = x.view(-1, *self.final_conv_shape[1:])
-            return self.decoder_conv(x)
-
-    class Discriminator(nn.Module):
-        def __init__(self, image_channels=3):
-            super().__init__()
-            self.model = nn.Sequential(
-                nn.Conv2d(image_channels, 64, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(64, 128, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(128, 256, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
-                nn.Conv2d(256, 1, 4, 1, 0)
-            )
-
-        def forward(self, x):
-            return self.model(x)
-
-    def __init__(self, in_shape, out_shape, prm, device):
-        super().__init__()
-        self.device = device
-        self.prm = prm or {}
-        self.text_embedding_dim = 128
-        self.latent_dim = 512
-        self.model_name = "ConditionalVAE4"
-
-        self.register_buffer('epoch_counter', torch.tensor(0))
-
-        image_channels, image_size = in_shape[1], in_shape[2]
-        self.text_encoder = self.TextEncoder(out_size=self.text_embedding_dim).to(device)
-        self.cvae = self.CVAE(self.latent_dim, self.text_embedding_dim, image_channels, image_size).to(device)
-        self.discriminator = self.Discriminator(image_channels).to(device)
-
-        lr_g = self.prm.get('lr_g', 2e-6)
-        lr_d = self.prm.get('lr_d', 2e-7)
-        beta1 = self.prm.get('momentum', 0.5)
-
-        self.optimizer_g = torch.optim.Adam(self.cvae.parameters(), lr=lr_g, betas=(beta1, 0.999))
-        self.optimizer_d = torch.optim.Adam(self.discriminator.parameters(), lr=lr_d, betas=(beta1, 0.999))
-
-        self.reconstruction_loss = nn.L1Loss()
-        self.perceptual_loss = PerceptualLoss().to(device)
-        self.adversarial_loss = nn.BCEWithLogitsLoss()
-
-
-    def train_setup(self, prm):
-        pass
-
-    def learn(self, train_data, current_epoch=0):
-        self.train()
-        self.epoch_counter = torch.tensor(current_epoch)
-        total_g_loss = 0.0
-        total_d_loss = 0.0
-
-        recon_weight = 10.0
-        perc_weight = 1.0
-        kld_weight = 0.0000025
-        adversarial_weight = 0.0001
-
-        for batch in train_data:
-            real_images, text_prompts = batch
-            real_images = real_images.to(self.device)
-
-            #  Train the Discriminator
-            self.optimizer_d.zero_grad()
-
-            with torch.no_grad():
-                text_embeddings = self.text_encoder(text_prompts)
-                mu, log_var = self.cvae.encode(real_images, text_embeddings)
-                z = self.cvae.reparameterize(mu, log_var)
-                reconstructed_images = self.cvae.decode(z, text_embeddings)
-
-            real_output = self.discriminator(real_images)
-            real_labels = torch.ones_like(real_output, device=self.device)
-            fake_labels = torch.zeros_like(real_output, device=self.device)
-
-            d_loss_real = self.adversarial_loss(real_output, real_labels)
-            fake_output = self.discriminator(reconstructed_images.detach())
-            d_loss_fake = self.adversarial_loss(fake_output, fake_labels)
-
-            d_loss = (d_loss_real + d_loss_fake) / 2
-            d_loss.backward()
-            self.optimizer_d.step()
-            total_d_loss += d_loss.item()
-
-            #  Train the VAE (Generator)
-            self.optimizer_g.zero_grad()
-
-            text_embeddings = self.text_encoder(text_prompts)
-            mu, log_var = self.cvae.encode(real_images, text_embeddings)
-            z = self.cvae.reparameterize(mu, log_var)
-            reconstructed_images_for_g = self.cvae.decode(z, text_embeddings)
-
-            recon_loss = self.reconstruction_loss(reconstructed_images_for_g, real_images)
-            perc_loss = self.perceptual_loss(reconstructed_images_for_g, real_images)
-            kld_loss = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())
-
-            fake_output_for_g = self.discriminator(reconstructed_images_for_g)
-            g_loss_adv = self.adversarial_loss(fake_output_for_g, real_labels)
-
-            g_loss = (recon_weight * recon_loss) + (perc_weight * perc_loss) + (kld_weight * kld_loss) + (
-                        adversarial_weight * g_loss_adv)
-
-            g_loss.backward()
-            self.optimizer_g.step()
-            total_g_loss += g_loss.item()
-
-        avg_g_loss = total_g_loss / len(train_data) if train_data else 0.0
-        avg_d_loss = total_d_loss / len(train_data) if train_data else 0.0
-
-        print(f"Epoch {self.epoch_counter.item()} - G_Loss: {avg_g_loss:.4f}, D_Loss: {avg_d_loss:.4f}")
-        return avg_g_loss
-
-    @torch.no_grad()
-    def generate(self, text_prompts):
-        self.eval()
-        num_images = len(text_prompts)
-        z = torch.randn(num_images, self.latent_dim, device=self.device)
-        text_embeddings = self.text_encoder(text_prompts)
-        generated_images = self.cvae.decode(z, text_embeddings)
-        generated_images = (generated_images + 1) / 2
-        return [T.ToPILImage()(img.cpu()) for img in generated_images]
-
-    @torch.no_grad()
-    def forward(self, images, **kwargs):
-        prompts_to_use = kwargs.get('prompts')
-        if not prompts_to_use:
-            batch_size = images.size(0)
-            default_prompts = ["a photo of a car"]
-            prompts_to_use = [default_prompts[i % len(default_prompts)] for i in range(batch_size)]
-
-        return self.generate(prompts_to_use), prompts_to_use

test/nn/ConvNeXt-dda5bf19-9ac1-460b-9bfd-735eec2f4904.py

@@ -1,172 +0,0 @@
-
-from functools import partial
-from typing import Callable, List, Optional, Sequence
-
-import torch
-from torch import nn, Tensor
-from torch.nn import functional as F
-from torchvision.ops.misc import Conv2dNormActivation, Permute
-from torchvision.ops.stochastic_depth import StochasticDepth
-
-
-class LayerNorm2d(nn.LayerNorm):
-    def forward(self, x: Tensor) -> Tensor:
-        x = x.permute(0, 2, 3, 1)
-        x = F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
-        x = x.permute(0, 3, 1, 2)
-        return x
-
-
-class CNBlock(nn.Module):
-    def __init__(
-            self,
-            dim,
-            layer_scale: float,
-            stochastic_depth_prob: float,
-            norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> None:
-        super().__init__()
-        if norm_layer is None:
-            norm_layer = partial(nn.LayerNorm, eps=1e-6)
-
-        self.block = nn.Sequential(
-            nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim, bias=True),
-            Permute([0, 2, 3, 1]),
-            norm_layer(dim),
-            nn.Linear(in_features=dim, out_features=4 * dim, bias=True),
-            nn.GELU(),
-            nn.Linear(in_features=4 * dim, out_features=dim, bias=True),
-            Permute([0, 3, 1, 2]),
-        )
-        self.layer_scale = nn.Parameter(torch.ones(dim, 1, 1) * layer_scale)
-        self.stochastic_depth = StochasticDepth(stochastic_depth_prob, "row")
-
-    def forward(self, input: Tensor) -> Tensor:
-        result = self.layer_scale * self.block(input)
-        result = self.stochastic_depth(result)
-        result += input
-        return result
-
-
-class CNBlockConfig:
-    def __init__(
-            self,
-            input_channels: int,
-            out_channels: Optional[int],
-            num_layers: int,
-    ) -> None:
-        self.input_channels = input_channels
-        self.out_channels = out_channels
-        self.num_layers = num_layers
-
-    def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "input_channels={input_channels}"
-        s += ", out_channels={out_channels}"
-        s += ", num_layers={num_layers}"
-        s += ")"
-        return s.format(**self.__dict__)
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'stochastic_depth_prob', 'norm_eps', 'norm_std'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss().to(self.device),)
-        self.optimizer = torch.optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            self.optimizer.step()
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super().__init__()
-        self.device = device
-        num_classes: int = out_shape[0]
-        stochastic_depth_prob: float = prm['stochastic_depth_prob']
-        layer_scale: float = 1e-6
-        block_setting = None
-        block: Optional[Callable[..., nn.Module]] = None
-        norm_layer: Optional[Callable[..., nn.Module]] = None
-        if block_setting is None:
-            block_setting = [
-                CNBlockConfig(96, 192, 4),  # Changed num_layers from 3 to 4
-                CNBlockConfig(192, 384, 3),
-                CNBlockConfig(384, 768, 27),
-                CNBlockConfig(768, None, 3),
-            ]
-        if not block_setting:
-            raise ValueError("The block_setting should not be empty")
-        elif not (isinstance(block_setting, Sequence) and all([isinstance(s, CNBlockConfig) for s in block_setting])):
-            raise TypeError("The block_setting should be List[CNBlockConfig]")
-
-        if block is None:
-            block = CNBlock
-        if norm_layer is None:
-            norm_layer = partial(LayerNorm2d, eps=prm['norm_eps'])
-        layers: List[nn.Module] = []
-        firstconv_output_channels = block_setting[0].input_channels
-        layers.append(
-            Conv2dNormActivation(
-                in_shape[1],
-                firstconv_output_channels,
-                kernel_size=4,  # Changed kernel_size from 4 to 5
-                stride=4,
-                padding=0,
-                norm_layer=norm_layer,
-                activation_layer=None,
-                bias=True,
-            )
-        )
-
-        total_stage_blocks = sum(cnf.num_layers for cnf in block_setting)
-        stage_block_id = 0
-        for cnf in block_setting:
-            stage: List[nn.Module] = []
-            for _ in range(cnf.num_layers):
-                sd_prob = stochastic_depth_prob * stage_block_id / (total_stage_blocks - 1.0)
-                stage.append(block(cnf.input_channels, layer_scale, sd_prob))
-                stage_block_id += 1
-            layers.append(nn.Sequential(*stage))
-            if cnf.out_channels is not None:
-                layers.append(
-                    nn.Sequential(
-                        norm_layer(cnf.input_channels),
-                        nn.Conv2d(cnf.input_channels, cnf.out_channels, kernel_size=2, stride=2),
-                    )
-                )
-
-        self.features = nn.Sequential(*layers)
-        self.avgpool = nn.AdaptiveAvgPool2d(1)
-
-        lastblock = block_setting[-1]
-        lastconv_output_channels = (
-            lastblock.out_channels if lastblock.out_channels is not None else lastblock.input_channels
-        )
-        self.classifier = nn.Sequential(
-            norm_layer(lastconv_output_channels), nn.Flatten(1), nn.Linear(lastconv_output_channels, num_classes)
-        )
-
-        for m in self.modules():
-            if isinstance(m, (nn.Conv2d, nn.Linear)):
-                nn.init.trunc_normal_(m.weight, std=prm['norm_std'])
-                if m.bias is not None:
-                    nn.init.zeros_(m.bias)
-
-    def _forward_impl(self, x: Tensor) -> Tensor:
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = self.classifier(x)
-        return x
-
-    def forward(self, x: Tensor) -> Tensor:
-        return self._forward_impl(x)

test/nn/DPN107.py

@@ -1,92 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-# Define DPNBlock with Group Convolutions
-class DPNBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, stride=1):
-        super(DPNBlock, self).__init__()
-        self.conv1 = nn.Conv2d(
-            in_channels, out_channels, kernel_size=3, stride=stride, padding=1, groups=4, bias=False
-        )
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(
-            out_channels, out_channels, kernel_size=3, padding=1, groups=4, bias=False
-        )
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-    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 += residual  # Residual connection
-        return self.relu(out)
-
-
-# Memory-Optimized DPN107
-class DPN107(nn.Module):
-    def __init__(self, in_channels, num_classes, num_blocks, growth_rate):
-        super(DPN107, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(growth_rate)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.blocks = nn.Sequential(
-            *[DPNBlock(growth_rate, growth_rate) for _ in range(num_blocks)]
-        )
-
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(growth_rate, num_classes)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.blocks(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        model_class = DPN107
-        self.channel_number = in_shape[1]
-        self.image_size = in_shape[2]
-        self.class_number = out_shape[0]
-
-        self.model = model_class(self.channel_number, self.class_number, num_blocks=3, growth_rate=32)
-        self.learning_rate = prm['lr']
-        self.momentum = prm['momentum']
-
-    def forward(self, x):
-        return self.model(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = optim.SGD(self.parameters(), lr=self.learning_rate, momentum=self.momentum)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            inputs = inputs.float()
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/DPN131-8e6e495b-85cb-4a71-8b91-6d89372e0a0c.py

@@ -1,86 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class DPNBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, stride=1):
-        super(DPNBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-    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 += residual
-        return self.relu(out)
-
-
-class DPN131(nn.Module):
-    def __init__(self, in_channels=3, num_classes=10, num_blocks=4, growth_rate=35):
-        super(DPN131, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1)
-        self.bn1 = nn.BatchNorm2d(growth_rate)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.blocks = nn.ModuleList()
-        for _ in range(num_blocks):
-            self.blocks.append(DPNBlock(growth_rate, growth_rate))
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(growth_rate, num_classes)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        for block in self.blocks:
-            x = block(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        model_class = DPN131
-        self.channel_number = in_shape[1]
-        self.image_size = in_shape[2]
-        self.class_number = out_shape[0]
-        self.model = model_class(self.channel_number, self.class_number, num_blocks=3, growth_rate=32)
-
-        self.learning_rate = prm['lr']
-        self.momentum = prm['momentum']
-
-    def forward(self, x):
-        return self.model(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = optim.SGD(self.parameters(), lr=self.learning_rate, momentum=self.momentum)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/DPN131-c53a40b8-b874-4c8b-999b-0944a1173a46.py

@@ -1,86 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class DPNBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, stride=1):
-        super(DPNBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-    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 += residual
-        return self.relu(out)
-
-
-class DPN131(nn.Module):
-    def __init__(self, in_channels=3, num_classes=10, num_blocks=4, growth_rate=16):
-        super(DPN131, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1)
-        self.bn1 = nn.BatchNorm2d(growth_rate)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.blocks = nn.ModuleList()
-        for _ in range(num_blocks):
-            self.blocks.append(DPNBlock(growth_rate, growth_rate))
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(growth_rate, num_classes)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        for block in self.blocks:
-            x = block(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        model_class = DPN131
-        self.channel_number = in_shape[1]
-        self.image_size = in_shape[2]
-        self.class_number = out_shape[0]
-        self.model = model_class(self.channel_number, self.class_number, num_blocks=4, growth_rate=16)
-
-        self.learning_rate = prm['lr']
-        self.momentum = prm['momentum']
-
-    def forward(self, x):
-        return self.model(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = optim.SGD(self.parameters(), lr=self.learning_rate, momentum=self.momentum)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/DPN131-e8980802-6b89-4170-8608-327297706df0.py

@@ -1,86 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class DPNBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, stride=1):
-        super(DPNBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-    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 += residual
-        return self.relu(out)
-
-
-class DPN131(nn.Module):
-    def __init__(self, in_channels=3, num_classes=10, num_blocks=5, growth_rate=40):
-        super(DPN131, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1)
-        self.bn1 = nn.BatchNorm2d(growth_rate)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.blocks = nn.ModuleList()
-        for _ in range(num_blocks):
-            self.blocks.append(DPNBlock(growth_rate, growth_rate))
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(growth_rate, num_classes)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        for block in self.blocks:
-            x = block(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        model_class = DPN131
-        self.channel_number = in_shape[1]
-        self.image_size = in_shape[2]
-        self.class_number = out_shape[0]
-        self.model = model_class(self.channel_number, self.class_number, num_blocks=3, growth_rate=32)
-
-        self.learning_rate = prm['lr']
-        self.momentum = prm['momentum']
-
-    def forward(self, x):
-        return self.model(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = optim.SGD(self.parameters(), lr=self.learning_rate, momentum=self.momentum)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/DPN131.py

@@ -1,85 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class DPNBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, stride=1):
-        super(DPNBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-    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 += residual
-        return self.relu(out)
-
-
-class DPN131(nn.Module):
-    def __init__(self, in_channels=3, num_classes=10, num_blocks=3, growth_rate=32):
-        super(DPN131, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1)
-        self.bn1 = nn.BatchNorm2d(growth_rate)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.blocks = nn.ModuleList()
-        for _ in range(num_blocks):
-            self.blocks.append(DPNBlock(growth_rate, growth_rate))
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(growth_rate, num_classes)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        for block in self.blocks:
-            x = block(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        model_class = DPN131
-        self.channel_number = in_shape[1]
-        self.image_size = in_shape[2]
-        self.class_number = out_shape[0]
-        self.model = model_class(self.channel_number, self.class_number, num_blocks=3, growth_rate=32)
-
-        self.learning_rate = prm['lr']
-        self.momentum = prm['momentum']
-
-    def forward(self, x):
-        return self.model(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = optim.SGD(self.parameters(), lr=self.learning_rate, momentum=self.momentum)
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/DPN68-9693aa0b-80bf-4393-a9e0-dd985a5ab128.py

@@ -1,83 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class DPNBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(DPNBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=5, stride=1, padding=2)
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-    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 = out + residual
-        return self.relu(out)
-
-
-class DPN68(nn.Module):
-    def __init__(self, in_channels, num_classes, num_blocks, growth_rate):
-        super(DPN68, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, growth_rate, kernel_size=3, stride=1, padding=1)
-        self.bn1 = nn.BatchNorm2d(growth_rate)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.blocks = nn.Sequential(
-            *[DPNBlock(growth_rate, growth_rate) for _ in range(num_blocks)]
-        )
-
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(growth_rate, num_classes)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.blocks(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        model_class = DPN68
-        self.channel_number = in_shape[1]
-        self.image_size = in_shape[2]
-        self.class_number = out_shape[0]
-        self.model = model_class(self.channel_number, self.class_number, num_blocks=5, growth_rate=16)
-
-    def forward(self, x):
-        return self.model(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/DPN68-c9cdb196-7596-4368-974a-56edf8b10381.py

@@ -1,83 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class DPNBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(DPNBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=5, stride=1, padding=2)
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-    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 = out + residual
-        return self.relu(out)
-
-
-class DPN68(nn.Module):
-    def __init__(self, in_channels, num_classes, num_blocks, growth_rate):
-        super(DPN68, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, growth_rate, kernel_size=3, stride=1, padding=1)
-        self.bn1 = nn.BatchNorm2d(growth_rate)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.blocks = nn.Sequential(
-            *[DPNBlock(growth_rate, growth_rate) for _ in range(num_blocks)]
-        )
-
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(growth_rate, num_classes)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.blocks(x)
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-        return x
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        model_class = DPN68
-        self.channel_number = in_shape[1]
-        self.image_size = in_shape[2]
-        self.class_number = out_shape[0]
-        self.model = model_class(self.channel_number, self.class_number, num_blocks=3, growth_rate=32)
-
-    def forward(self, x):
-        return self.model(x)
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = nn.CrossEntropyLoss().to(self.device)
-        self.optimizer = optim.SGD(self.parameters(), lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        self.train()
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()

test/nn/DarkNet-11e8caec-5e73-461e-a101-3aa39dfec644.py

@@ -1,96 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class DarkNetUnit(nn.Module):
-    def __init__(self, in_channels: int, out_channels: int, pointwise: bool, alpha: float):
-        super(DarkNetUnit, self).__init__()
-        self.activation = nn.LeakyReLU(negative_slope=alpha, inplace=True)
-        if pointwise:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-        else:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return self.conv(x)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channels: list = [[32, 32, 32], [192, 192, 192], [128, 128, 128], [256, 256, 256]]
-        odd_pointwise: bool = True
-        alpha: float = 0.1
-        in_channels = in_shape[1]
-        image_size = in_shape[2]
-        num_classes = out_shape[0]
-
-        if channels is None:
-            channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-
-        self.features = nn.Sequential()
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                pointwise = (len(channels_per_stage) > 1) and not (((j + 1) % 2 == 1) ^ odd_pointwise)
-                stage.add_module(f"unit{j + 1}", DarkNetUnit(in_channels, out_channels, pointwise, alpha))
-                in_channels = out_channels
-            if i != len(channels) - 1:
-                stage.add_module(f"pool{i + 1}", nn.MaxPool2d(kernel_size=2, stride=2))
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        final_feature_map_size = image_size // (2 ** (len(channels) - 1))
-
-        self.output = nn.Sequential(
-            nn.Conv2d(in_channels=in_channels, out_channels=num_classes, kernel_size=1),
-            nn.LeakyReLU(negative_slope=alpha, inplace=True),
-            nn.AdaptiveAvgPool2d(output_size=(1, 1))
-        )
-
-        self._initialize_weights()
-
-    def _initialize_weights(self):
-        for module in self.modules():
-            if isinstance(module, nn.Conv2d):
-                nn.init.kaiming_uniform_(module.weight, mode='fan_in', nonlinearity='leaky_relu')
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.output(x)
-        x = x.view(x.size(0), -1)
-        return x
-
-    def train_setup(self, prm: dict):
-        self.to(self.device)
-        learning_rate = float(prm.get("lr", 0.01))
-        momentum = float(prm.get("momentum", 0.9))
-        self.criteria = nn.CrossEntropyLoss()
-        self.optimizer = optim.SGD(self.parameters(), lr=learning_rate, momentum=momentum)
-        self.to(self.device)
-
-    def learn(self, train_data: torch.utils.data.DataLoader):
-        self.train()
-        for inputs, targets in train_data:
-            inputs, targets = inputs.to(next(self.parameters()).device), targets.to(next(self.parameters()).device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, targets)
-            loss.backward()
-            self.optimizer.step()

test/nn/DarkNet-51277b91-c3a1-4669-9fb5-849ea97bd1b4.py

@@ -1,95 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class DarkNetUnit(nn.Module):
-    def __init__(self, in_channels: int, out_channels: int, pointwise: bool, alpha: float):
-        super(DarkNetUnit, self).__init__()
-        self.activation = nn.LeakyReLU(negative_slope=alpha, inplace=True)
-        if pointwise:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-        else:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return self.conv(x)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channels: list = None
-        odd_pointwise: bool = True
-        alpha: float = 0.2  # Changed from 0.1
-        in_channels = in_shape[1]
-        image_size = 200  # Changed from in_shape[2]
-        num_classes = 1000  # Changed from out_shape[0]
-        # Changed first element of channels list
-        channels = [[32, 32, 32], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-
-        self.features = nn.Sequential()
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                pointwise = (len(channels_per_stage) > 1) and not (((j + 1) % 2 == 1) ^ odd_pointwise)
-                stage.add_module(f"unit{j + 1}", DarkNetUnit(in_channels, out_channels, pointwise, alpha))
-                in_channels = out_channels
-            if i != len(channels) - 1:
-                stage.add_module(f"pool{i + 1}", nn.MaxPool2d(kernel_size=2, stride=2))
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        final_feature_map_size = image_size // (2 ** (len(channels) - 1))
-
-        self.output = nn.Sequential(
-            nn.Conv2d(in_channels=in_channels, out_channels=num_classes, kernel_size=1),
-            nn.LeakyReLU(negative_slope=alpha, inplace=True),
-            nn.AdaptiveAvgPool2d(output_size=(1, 1))
-        )
-
-        self._initialize_weights()
-
-    def _initialize_weights(self):
-        for module in self.modules():
-            if isinstance(module, nn.Conv2d):
-                nn.init.kaiming_uniform_(module.weight, mode='fan_in', nonlinearity='leaky_relu')
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.output(x)
-        x = x.view(x.size(0), -1)
-        return x
-
-    def train_setup(self, prm: dict):
-        self.to(self.device)
-        learning_rate = float(prm.get("lr", 0.01))
-        momentum = float(prm.get("momentum", 0.9))  # Changed from 0.9
-        self.criteria = nn.CrossEntropyLoss()
-        self.optimizer = optim.SGD(self.parameters(), lr=learning_rate, momentum=momentum)
-        self.to(self.device)
-
-    def learn(self, train_data: torch.utils.data.DataLoader):
-        self.train()
-        for inputs, targets in train_data:
-            inputs, targets = inputs.to(next(self.parameters()).device), targets.to(next(self.parameters()).device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, targets)
-            loss.backward()
-            self.optimizer.step()

test/nn/DarkNet-d434ba1c-25ea-4160-a41d-4c477dba7bc0.py

@@ -1,96 +0,0 @@
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class DarkNetUnit(nn.Module):
-    def __init__(self, in_channels: int, out_channels: int, pointwise: bool, alpha: float):
-        super(DarkNetUnit, self).__init__()
-        self.activation = nn.LeakyReLU(negative_slope=alpha, inplace=True)
-        if pointwise:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-        else:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return self.conv(x)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channels: list = None
-        odd_pointwise: bool = True
-        alpha: float = 0.1
-        in_channels = in_shape[1]
-        image_size = in_shape[2]
-        num_classes = out_shape[0]
-
-        if channels is None:
-            channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256]]  # Changed from 4 to 3 sublists
-
-        self.features = nn.Sequential()
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                pointwise = (len(channels_per_stage) > 1) and not (((j + 1) % 2 == 1) ^ odd_pointwise)
-                stage.add_module(f"unit{j + 1}", DarkNetUnit(in_channels, out_channels, pointwise, alpha))
-                in_channels = out_channels
-            if i != len(channels) - 1:
-                stage.add_module(f"pool{i + 1}", nn.MaxPool2d(kernel_size=2, stride=2))  # Changed kernel size from 2 to 3
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        final_feature_map_size = image_size // (2 ** (len(channels) - 1))
-
-        self.output = nn.Sequential(
-            nn.Conv2d(in_channels=in_channels, out_channels=num_classes, kernel_size=1),
-            nn.LeakyReLU(negative_slope=alpha, inplace=True),
-            nn.AdaptiveAvgPool2d(output_size=(1, 1))
-        )
-
-        self._initialize_weights()
-
-    def _initialize_weights(self):
-        for module in self.modules():
-            if isinstance(module, nn.Conv2d):
-                nn.init.kaiming_uniform_(module.weight, mode='fan_in', nonlinearity='leaky_relu')
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.output(x)
-        x = x.view(x.size(0), -1)
-        return x
-
-    def train_setup(self, prm: dict):
-        self.to(self.device)
-        learning_rate = float(prm.get("lr", 0.01))
-        momentum = float(prm.get("momentum", 0.9))
-        self.criteria = nn.CrossEntropyLoss()
-        self.optimizer = optim.SGD(self.parameters(), lr=learning_rate, momentum=momentum)
-        self.to(self.device)
-
-    def learn(self, train_data: torch.utils.data.DataLoader):
-        self.train()
-        for inputs, targets in train_data:
-            inputs, targets = inputs.to(next(self.parameters()).device), targets.to(next(self.parameters()).device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, targets)
-            loss.backward()
-            self.optimizer.step()

test/nn/DarkNet.py

@@ -1,95 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum', 'dropout'}
-
-
-class DarkNetUnit(nn.Module):
-    def __init__(self, in_channels: int, out_channels: int, pointwise: bool, alpha: float):
-        super(DarkNetUnit, self).__init__()
-        self.activation = nn.LeakyReLU(negative_slope=alpha, inplace=True)
-        if pointwise:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-        else:
-            self.conv = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),
-                nn.BatchNorm2d(out_channels),
-                self.activation
-            )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return self.conv(x)
-
-
-class Net(nn.Module):
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        channels: list = None
-        odd_pointwise: bool = True
-        alpha: float = 0.1
-        in_channels = in_shape[1]
-        image_size = in_shape[2]
-        num_classes = out_shape[0]
-
-        if channels is None:
-            channels = [[64, 64, 64], [128, 128, 128], [256, 256, 256], [512, 512, 512]]
-
-        self.features = nn.Sequential()
-        for i, channels_per_stage in enumerate(channels):
-            stage = nn.Sequential()
-            for j, out_channels in enumerate(channels_per_stage):
-                pointwise = (len(channels_per_stage) > 1) and not (((j + 1) % 2 == 1) ^ odd_pointwise)
-                stage.add_module(f"unit{j + 1}", DarkNetUnit(in_channels, out_channels, pointwise, alpha))
-                in_channels = out_channels
-            if i != len(channels) - 1:
-                stage.add_module(f"pool{i + 1}", nn.MaxPool2d(kernel_size=2, stride=2))
-            self.features.add_module(f"stage{i + 1}", stage)
-
-        final_feature_map_size = image_size // (2 ** (len(channels) - 1))
-
-        self.output = nn.Sequential(
-            nn.Conv2d(in_channels=in_channels, out_channels=num_classes, kernel_size=1),
-            nn.LeakyReLU(negative_slope=alpha, inplace=True),
-            nn.AdaptiveAvgPool2d(output_size=(1, 1))
-        )
-
-        self._initialize_weights()
-
-    def _initialize_weights(self):
-        for module in self.modules():
-            if isinstance(module, nn.Conv2d):
-                nn.init.kaiming_uniform_(module.weight, mode='fan_in', nonlinearity='leaky_relu')
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.features(x)
-        x = self.output(x)
-        x = x.view(x.size(0), -1)
-        return x
-
-    def train_setup(self, prm: dict):
-        self.to(self.device)
-        learning_rate = float(prm.get("lr", 0.01))
-        momentum = float(prm.get("momentum", 0.9))
-        self.criteria = nn.CrossEntropyLoss()
-        self.optimizer = optim.SGD(self.parameters(), lr=learning_rate, momentum=momentum)
-        self.to(self.device)
-
-    def learn(self, train_data: torch.utils.data.DataLoader):
-        self.train()
-        for inputs, targets in train_data:
-            inputs, targets = inputs.to(next(self.parameters()).device), targets.to(next(self.parameters()).device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria(outputs, targets)
-            loss.backward()
-            self.optimizer.step()

test/nn/DeepLabV3-1.py

@@ -1,382 +0,0 @@
-from collections import OrderedDict
-from typing import Callable, Dict, List, Optional, Sequence, Type, Union
-
-import torch
-import torch.nn.functional as F
-from torch import nn, Tensor
-
-
-class DeepLabHead(nn.Sequential):
-    def __init__(self, in_channels: int, num_classes: int = 100, atrous_rates: Sequence[int] = (12, 24, 36)) -> None:
-        super(DeepLabHead, self).__init__(
-            ASPP(in_channels, atrous_rates),
-            nn.Conv2d(256, 256, 3, padding=1, bias=False),
-            nn.BatchNorm2d(256),
-            nn.ReLU(True),
-            nn.Conv2d(256, num_classes, 1),
-        )
-
-
-class ASPPConv(nn.Sequential):
-    def __init__(self, in_channels: int, out_channels: int, dilation: int) -> None:
-        modules = [
-            nn.Conv2d(in_channels, out_channels, 3, padding=dilation, dilation=dilation, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(True),
-        ]
-        super(ASPPConv, self).__init__(*modules)
-
-
-class ASPPPooling(nn.Sequential):
-    def __init__(self, in_channels: int, out_channels: int) -> None:
-        super(ASPPPooling, self).__init__(
-            nn.AdaptiveAvgPool2d(1),
-            nn.Conv2d(in_channels, out_channels, 1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        size = x.shape[-2:]
-        for mod in self:
-            x = mod(x)
-        return F.interpolate(x, size=size, mode="bilinear", align_corners=False)
-
-
-class ASPP(nn.Module):
-    def __init__(self, in_channels: int, atrous_rates: Sequence[int], out_channels: int = 256) -> None:
-        super(ASPP, self).__init__()
-        modules = []
-        modules.append(
-            nn.Sequential(nn.Conv2d(in_channels, out_channels, 1, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU())
-        )
-
-        rates = tuple(atrous_rates)
-        for rate in rates:
-            modules.append(ASPPConv(in_channels, out_channels, rate))
-
-        modules.append(ASPPPooling(in_channels, out_channels))
-
-        self.convs = nn.ModuleList(modules)
-
-        self.project = nn.Sequential(
-            nn.Conv2d(len(self.convs) * out_channels, out_channels, 1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(),
-            nn.Dropout(0.5),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        _res = []
-        for conv in self.convs:
-            _res.append(conv(x))
-        res = torch.cat(_res, dim=1)
-        return self.project(res)
-
-
-class FCNHead(nn.Sequential):
-    def __init__(self, in_channels: int, channels: int) -> None:
-        inter_channels = in_channels // 4
-        layers = [
-            nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
-            nn.BatchNorm2d(inter_channels),
-            nn.ReLU(),
-            nn.Dropout(0.1),
-            nn.Conv2d(inter_channels, channels, 1),
-        ]
-
-        super(FCNHead, self).__init__(*layers)
-
-
-def conv3x3(in_planes: int, out_planes: int, stride: int = 1, groups: int = 1, dilation: int = 1) -> nn.Conv2d:
-    return nn.Conv2d(
-        in_planes,
-        out_planes,
-        kernel_size=3,
-        stride=stride,
-        padding=dilation,
-        groups=groups,
-        bias=False,
-        dilation=dilation,
-    )
-
-
-def conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:
-    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
-
-
-class BasicBlock(nn.Module):
-    expansion: int = 1
-
-    def __init__(
-            self,
-            inplanes: int,
-            planes: int,
-            stride: int = 1,
-            downsample: Optional[nn.Module] = None,
-            groups: int = 1,
-            base_width: int = 64,
-            dilation: int = 1,
-            norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> None:
-        super().__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")
-        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: Tensor) -> Tensor:
-        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: int = 4
-
-    def __init__(
-            self,
-            inplanes: int,
-            planes: int,
-            stride: int = 1,
-            downsample: Optional[nn.Module] = None,
-            groups: int = 1,
-            base_width: int = 64,
-            dilation: int = 1,
-            norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> None:
-        super().__init__()
-        if norm_layer is None:
-            norm_layer = nn.BatchNorm2d
-        width = int(planes * (base_width / 64.0)) * groups
-        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: Tensor) -> Tensor:
-        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,
-            channels: int,
-            block: Type[Union[BasicBlock, Bottleneck]],
-            layers: List[int],
-            num_classes: int = 1000,
-            zero_init_residual: bool = False,
-            groups: int = 1,
-            width_per_group: int = 64,
-            replace_stride_with_dilation: Optional[List[bool]] = None,
-            norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> 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:
-            replace_stride_with_dilation = [False, False, False]
-        if len(replace_stride_with_dilation) != 3:
-            raise ValueError(
-                "replace_stride_with_dilation should be None "
-                f"or a 3-element tuple, got {replace_stride_with_dilation}"
-            )
-        self.groups = groups
-        self.base_width = width_per_group
-        self.conv1 = nn.Conv2d(channels, self.inplanes, kernel_size=7, stride=2, padding=3, 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)
-        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.fc = nn.Linear(512 * block.expansion, num_classes)
-
-        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)
-
-        if zero_init_residual:
-            for m in self.modules():
-                if isinstance(m, Bottleneck) and m.bn3.weight is not None:
-                    nn.init.constant_(m.bn3.weight, 0)
-                elif isinstance(m, BasicBlock) and m.bn2.weight is not None:
-                    nn.init.constant_(m.bn2.weight, 0)
-
-    def _make_layer(
-            self,
-            block: Type[Union[BasicBlock, Bottleneck]],
-            planes: int,
-            blocks: int,
-            stride: int = 1,
-            dilate: bool = False,
-    ) -> nn.Sequential:
-        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: Tensor) -> Tensor:
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.maxpool(x)
-
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-
-        return x
-
-    def forward(self, x: Tensor) -> Tensor:
-        return self._forward_impl(x)
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss(ignore_index=-1).to(self.device),)
-        params_list = [{'params': self.backbone.parameters(), 'lr': prm['lr']}]
-        for module in self.exclusive:
-            params_list.append({'params': getattr(self, module).parameters(), 'lr': prm['lr'] * 10})
-        self.optimizer = torch.optim.SGD(params_list, lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    __constants__ = ["aux_classifier"]
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        num_classes = out_shape[0]
-        self.backbone: nn.Module = ResNet(in_shape[1], Bottleneck, [3, 4, 6, 3], num_classes=100, replace_stride_with_dilation=[False, True, True])
-        self.classifier: nn.Module = DeepLabHead(2048, num_classes)
-        self.aux_classifier: Optional[nn.Module] = None
-        self.__setattr__('exclusive', ['classifier'] if self.aux_classifier == None else ['classifier', 'aux_classifier'])
-
-    def forward(self, x: Tensor) -> Union[Dict[str, Tensor], Tensor]:
-        input_shape = x.shape[-2:]
-        c3, c4 = self.backbone_fw(x)
-        x = self.classifier(c4)
-        x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False)
-
-        if self.aux_classifier is not None:
-            result = OrderedDict()
-            result["out"] = x
-            x = self.aux_classifier(c3)
-            x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False)
-            result["aux"] = x
-            return result
-        return x
-
-    def backbone_fw(self, x):
-        x = self.backbone.conv1(x)
-        x = self.backbone.bn1(x)
-        x = self.backbone.relu(x)
-        x = self.backbone.maxpool(x)
-        c1 = self.backbone.layer1(x)
-        c2 = self.backbone.layer2(c1)
-        c3 = self.backbone.layer3(c2)
-        c4 = self.backbone.layer4(c3)
-        return c3, c4

test/nn/DeepLabV3-2.py

@@ -1,382 +0,0 @@
-from collections import OrderedDict
-from typing import Callable, Dict, List, Optional, Sequence, Type, Union
-
-import torch
-import torch.nn.functional as F
-from torch import nn, Tensor
-
-
-class DeepLabHead(nn.Sequential):
-    def __init__(self, in_channels: int, num_classes: int = 100, atrous_rates: Sequence[int] = (12, 24, 36)) -> None:
-        super(DeepLabHead, self).__init__(
-            ASPP(in_channels, atrous_rates),
-            nn.Conv2d(256, 256, 3, padding=1, bias=False),
-            nn.BatchNorm2d(256),
-            nn.ReLU(True),
-            nn.Conv2d(256, num_classes, 1),
-        )
-
-
-class ASPPConv(nn.Sequential):
-    def __init__(self, in_channels: int, out_channels: int, dilation: int) -> None:
-        modules = [
-            nn.Conv2d(in_channels, out_channels, 3, padding=dilation, dilation=dilation, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(True),
-        ]
-        super(ASPPConv, self).__init__(*modules)
-
-
-class ASPPPooling(nn.Sequential):
-    def __init__(self, in_channels: int, out_channels: int) -> None:
-        super(ASPPPooling, self).__init__(
-            nn.AdaptiveAvgPool2d(1),
-            nn.Conv2d(in_channels, out_channels, 1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        size = x.shape[-2:]
-        for mod in self:
-            x = mod(x)
-        return F.interpolate(x, size=size, mode="bilinear", align_corners=False)
-
-
-class ASPP(nn.Module):
-    def __init__(self, in_channels: int, atrous_rates: Sequence[int], out_channels: int = 256) -> None:
-        super(ASPP, self).__init__()
-        modules = []
-        modules.append(
-            nn.Sequential(nn.Conv2d(in_channels, out_channels, 1, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU())
-        )
-
-        rates = tuple(atrous_rates)
-        for rate in rates:
-            modules.append(ASPPConv(in_channels, out_channels, rate))
-
-        modules.append(ASPPPooling(in_channels, out_channels))
-
-        self.convs = nn.ModuleList(modules)
-
-        self.project = nn.Sequential(
-            nn.Conv2d(len(self.convs) * out_channels, out_channels, 1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(),
-            nn.Dropout(0.5),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        _res = []
-        for conv in self.convs:
-            _res.append(conv(x))
-        res = torch.cat(_res, dim=1)
-        return self.project(res)
-
-
-class FCNHead(nn.Sequential):
-    def __init__(self, in_channels: int, channels: int) -> None:
-        inter_channels = in_channels // 4
-        layers = [
-            nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
-            nn.BatchNorm2d(inter_channels),
-            nn.ReLU(),
-            nn.Dropout(0.1),
-            nn.Conv2d(inter_channels, channels, 1),
-        ]
-
-        super(FCNHead, self).__init__(*layers)
-
-
-def conv3x3(in_planes: int, out_planes: int, stride: int = 1, groups: int = 1, dilation: int = 1) -> nn.Conv2d:
-    return nn.Conv2d(
-        in_planes,
-        out_planes,
-        kernel_size=3,
-        stride=stride,
-        padding=dilation,
-        groups=groups,
-        bias=False,
-        dilation=dilation,
-    )
-
-
-def conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:
-    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
-
-
-class BasicBlock(nn.Module):
-    expansion: int = 1
-
-    def __init__(
-            self,
-            inplanes: int,
-            planes: int,
-            stride: int = 1,
-            downsample: Optional[nn.Module] = None,
-            groups: int = 1,
-            base_width: int = 64,
-            dilation: int = 1,
-            norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> None:
-        super().__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")
-        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: Tensor) -> Tensor:
-        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: int = 4
-
-    def __init__(
-            self,
-            inplanes: int,
-            planes: int,
-            stride: int = 1,
-            downsample: Optional[nn.Module] = None,
-            groups: int = 1,
-            base_width: int = 64,
-            dilation: int = 1,
-            norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> None:
-        super().__init__()
-        if norm_layer is None:
-            norm_layer = nn.BatchNorm2d
-        width = int(planes * (base_width / 64.0)) * groups
-        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: Tensor) -> Tensor:
-        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,
-            channels: int,
-            block: Type[Union[BasicBlock, Bottleneck]],
-            layers: List[int],
-            num_classes: int = 1000,
-            zero_init_residual: bool = False,
-            groups: int = 1,
-            width_per_group: int = 64,
-            replace_stride_with_dilation: Optional[List[bool]] = None,
-            norm_layer: Optional[Callable[..., nn.Module]] = None,
-    ) -> 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:
-            replace_stride_with_dilation = [False, False, False]
-        if len(replace_stride_with_dilation) != 3:
-            raise ValueError(
-                "replace_stride_with_dilation should be None "
-                f"or a 3-element tuple, got {replace_stride_with_dilation}"
-            )
-        self.groups = groups
-        self.base_width = width_per_group
-        self.conv1 = nn.Conv2d(channels, self.inplanes, kernel_size=7, stride=2, padding=3, 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)
-        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.fc = nn.Linear(512 * block.expansion, num_classes)
-
-        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)
-
-        if zero_init_residual:
-            for m in self.modules():
-                if isinstance(m, Bottleneck) and m.bn3.weight is not None:
-                    nn.init.constant_(m.bn3.weight, 0)
-                elif isinstance(m, BasicBlock) and m.bn2.weight is not None:
-                    nn.init.constant_(m.bn2.weight, 0)
-
-    def _make_layer(
-            self,
-            block: Type[Union[BasicBlock, Bottleneck]],
-            planes: int,
-            blocks: int,
-            stride: int = 1,
-            dilate: bool = False,
-    ) -> nn.Sequential:
-        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: Tensor) -> Tensor:
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.maxpool(x)
-
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-        x = self.fc(x)
-
-        return x
-
-    def forward(self, x: Tensor) -> Tensor:
-        return self._forward_impl(x)
-
-
-def supported_hyperparameters():
-    return {'lr', 'momentum'}
-
-
-class Net(nn.Module):
-
-    def train_setup(self, prm):
-        self.to(self.device)
-        self.criteria = (nn.CrossEntropyLoss(ignore_index=-1).to(self.device),)
-        params_list = [{'params': self.backbone.parameters(), 'lr': prm['lr']}]
-        for module in self.exclusive:
-            params_list.append({'params': getattr(self, module).parameters(), 'lr': prm['lr'] * 10})
-        self.optimizer = torch.optim.SGD(params_list, lr=prm['lr'], momentum=prm['momentum'])
-
-    def learn(self, train_data):
-        for inputs, labels in train_data:
-            inputs, labels = inputs.to(self.device), labels.to(self.device)
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            loss = self.criteria[0](outputs, labels)
-            loss.backward()
-            nn.utils.clip_grad_norm_(self.parameters(), 3)
-            self.optimizer.step()
-
-    __constants__ = ["aux_classifier"]
-
-    def __init__(self, in_shape: tuple, out_shape: tuple, prm: dict, device: torch.device) -> None:
-        super(Net, self).__init__()
-        self.device = device
-        num_classes = out_shape[0]
-        self.backbone: nn.Module = ResNet(in_shape[1], Bottleneck, [3, 4, 23, 3], num_classes=100, replace_stride_with_dilation=[False, True, True])
-        self.classifier: nn.Module = DeepLabHead(2048, num_classes)
-        self.aux_classifier: Optional[nn.Module] = None
-        self.__setattr__('exclusive', ['classifier'] if self.aux_classifier == None else ['classifier', 'aux_classifier'])
-
-    def forward(self, x: Tensor) -> Union[Dict[str, Tensor], Tensor]:
-        input_shape = x.shape[-2:]
-        c3, c4 = self.backbone_fw(x)
-        x = self.classifier(c4)
-        x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False)
-
-        if self.aux_classifier is not None:
-            result = OrderedDict()
-            result["out"] = x
-            x = self.aux_classifier(c3)
-            x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False)
-            result["aux"] = x
-            return result
-        return x
-
-    def backbone_fw(self, x):
-        x = self.backbone.conv1(x)
-        x = self.backbone.bn1(x)
-        x = self.backbone.relu(x)
-        x = self.backbone.maxpool(x)
-        c1 = self.backbone.layer1(x)
-        c2 = self.backbone.layer2(c1)
-        c3 = self.backbone.layer3(c2)
-        c4 = self.backbone.layer4(c3)
-        return c3, c4

test/nn/DenoiseUNet.py

@@ -1,135 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.optim as optim
-
-def supported_hyperparameters():
-    return {'lr'}
-
-class DoubleConv(nn.Module):
-    """(convolution => [BN] => ReLU) * 2"""
-    def __init__(self, in_channels, out_channels):
-        super().__init__()
-        self.double_conv = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True)
-        )
-
-    def forward(self, x):
-        return self.double_conv(x)
-
-class Down(nn.Module):
-    """Downscaling with maxpool then double conv"""
-    def __init__(self, in_channels, out_channels):
-        super().__init__()
-        self.maxpool_conv = nn.Sequential(
-            nn.MaxPool2d(2),
-            DoubleConv(in_channels, out_channels)
-        )
-
-    def forward(self, x):
-        return self.maxpool_conv(x)
-
-class Up(nn.Module):
-    """Upscaling then double conv"""
-    def __init__(self, in_channels, out_channels, bilinear=True):
-        super().__init__()
-        
-        if bilinear:
-            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
-            self.conv = DoubleConv(in_channels + (in_channels // 2), out_channels)
-        else:
-            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
-            self.conv = DoubleConv(in_channels, out_channels)
-
-    def forward(self, x1, x2):
-        x1 = self.up(x1)
-        diffY = x2.size()[2] - x1.size()[2]
-        diffX = x2.size()[3] - x1.size()[3]
-        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
-                        diffY // 2, diffY - diffY // 2])
-        x = torch.cat([x2, x1], dim=1)
-        return self.conv(x)
-
-class OutConv(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(OutConv, self).__init__()
-        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
-
-    def forward(self, x):
-        return self.conv(x)
-
-class Net(nn.Module):
-    """
-    Residual U-Net with Safety Clamping
-    """
-    def __init__(self, in_shape, out_shape, prm, device):
-        super(Net, self).__init__()
-        self.device = device
-        n_channels = in_shape[1]
-        
-        self.inc = DoubleConv(n_channels, 64)
-        self.down1 = Down(64, 128)
-        self.down2 = Down(128, 256)
-        self.down3 = Down(256, 512)
-        self.down4 = Down(512, 1024)
-        
-        self.up1 = Up(1024, 512)
-        self.up2 = Up(512, 256)
-        self.up3 = Up(256, 128)
-        self.up4 = Up(128, 64)
-        self.outc = OutConv(64, n_channels)
-        
-        self.to(self.device)
-        self._initialize_optimizer(prm)
-        self.criterion = nn.MSELoss()
-
-    def _initialize_optimizer(self, prm):
-        raw_lr = prm.get('lr', 0.001)
-        self.optimizer = optim.Adam(self.parameters(), lr=raw_lr)
-
-    def forward(self, x):
-        input_img = x
-        
-        x1 = self.inc(x)
-        x2 = self.down1(x1)
-        x3 = self.down2(x2)
-        x4 = self.down3(x3)
-        x5 = self.down4(x4)
-        
-        dec = self.up1(x5, x4)
-        dec = self.up2(dec, x3)
-        dec = self.up3(dec, x2)
-        dec = self.up4(dec, x1)
-        
-        logits = self.outc(dec)
-        
-        return torch.clamp(input_img + logits, 0.0, 1.0)
-
-    def train_setup(self, prm):
-        self._initialize_optimizer(prm)
-
-    def learn(self, train_data):
-        self.train()
-        total_loss = 0.0
-        count = 0
-        
-        for inputs, targets in train_data:
-            inputs = inputs.to(self.device)
-            targets = targets.to(self.device)
-            
-            self.optimizer.zero_grad()
-            outputs = self(inputs)
-            
-            loss = self.criterion(outputs, targets)
-            loss.backward()
-            self.optimizer.step()
-            
-            total_loss += loss.item()
-            count += 1
-            
-        return total_loss / count if count > 0 else 0.0