def __init__(self,
input_shape,
num_classes=10,
filters=96,
pool_rotations=True):
super(GroupAllConvolutional, self).__init__()
h, w, c = input_shape
self.pool_rotations = pool_rotations
self.name = "AllGConvolutional"
filters2 = filters * 2
self.conv1 = P4ConvZ2(c, filters, kernel_size=3, padding=1)
self.conv2 = P4ConvP4(filters, filters, kernel_size=3, padding=1)
self.conv2 = P4ConvP4(filters,
filters,
kernel_size=3,
padding=1,
stride=2)
self.conv3 = P4ConvP4(filters, filters2, kernel_size=3, padding=1)
self.conv4 = P4ConvP4(filters2, filters2, kernel_size=3, padding=1)
self.conv5 = P4ConvP4(filters2, filters2, kernel_size=3, padding=1)
self.conv6 = P4ConvP4(filters2,
filters2,
kernel_size=3,
padding=1,
stride=2)
self.conv7 = P4ConvP4(filters2, filters2, kernel_size=3, padding=1)
self.conv8 = P4ConvP4(filters2, filters2, kernel_size=1)
if self.pool_rotations:
final_filters = filters2
else:
final_filters = filters2 * 4
self.class_conv = nn.Conv2d(final_filters, num_classes, 1)
def __init__(self, in_channel, out_channel):
super().__init__()
self.conv0 = P4ConvZ2(in_channel,
out_channel,
kernel_size=5,
padding=2)
self.relu = nn.LeakyReLU(0.2, inplace=True)
def __init__(self,
input_shape,
num_classes,
filters=16,
fc_filters=32,
pool_rotations=True):
super(SimpleGConv, self).__init__()
self.name = "SimpleGConv"
h, w, channels = input_shape
self.pool_rotations = pool_rotations
self.conv1 = P4ConvZ2(channels, filters, kernel_size=3, padding=1)
self.conv2 = P4ConvP4(filters, filters, kernel_size=3, padding=1)
self.conv3 = P4ConvP4(filters, filters, kernel_size=3, padding=1)
self.conv4 = P4ConvP4(filters, filters * 2, kernel_size=3, padding=1)
self.conv5 = P4ConvP4(filters * 2,
filters * 4,
kernel_size=3,
padding=1)
linear_size = (h // 4) * (w // 4) * filters * 4
if not self.pool_rotations:
linear_size *= 4
self.fc1 = nn.Linear(linear_size, fc_filters)
self.bn1 = nn.BatchNorm1d(fc_filters)
self.fc2 = nn.Linear(fc_filters, num_classes)
def __init__(self, *args, **kwargs):
super(Net, self).__init__()
self.conv1 = P4ConvZ2(1, 10, kernel_size=3)
self.conv2 = P4ConvP4(10, 10, kernel_size=3)
self.conv3 = P4ConvP4(10, 20, kernel_size=3)
self.conv4 = P4ConvP4(20, 20, kernel_size=3)
self.fc1 = nn.Linear(5*5*20*4, 50)
self.fc2 = nn.Linear(50, 10)
def test_p4_net_equivariance():
from groupy.gfunc import Z2FuncArray, P4FuncArray
import groupy.garray.C4_array as c4a
im = np.random.randn(1, 1, 11, 11).astype('float32')
check_equivariance(
im=im,
layers=[
P4ConvZ2(in_channels=1, out_channels=2, kernel_size=3),
P4ConvP4(in_channels=2, out_channels=3, kernel_size=3)
],
input_array=Z2FuncArray,
output_array=P4FuncArray,
point_group=c4a,
)
def __init__(self,
input_shape,
num_classes,
filters=96,
pool_rotations=True):
super(AllGConv, self).__init__()
self.name = "AllGConvolutional"
filters2 = filters * 2
h, w, channels = input_shape
self.pool_rotations = pool_rotations
# self.conv1 = nn.Sequential(
# P4MConvZ2(channels, filters, kernel_size=3,padding=1),
# nn.BatchNorm2d(filters),
# nn.ReLU()
# )
# self.conv2 = ConvBNAct(filters,filters)
# self.conv3 = ConvBNAct(filters, filters,stride=2)
# self.conv4 = ConvBNAct(filters, filters2, stride=2)
# self.conv5 = ConvBNAct(filters2, filters2)
# self.conv6 = ConvBNAct(filters2, filters2, stride=2)
# self.conv7 = ConvBNAct(filters2, filters2)
# self.conv8 = ConvBNAct(filters2, filters2, kernel_size=1)
self.conv = nn.Sequential(
P4ConvZ2(channels, filters, kernel_size=3, padding=1),
#nn.BatchNorm2d(filters),
nn.ReLU(),
ConvBNAct(filters, filters),
ConvBNAct(filters, filters, stride=2),
ConvBNAct(
filters,
filters2,
),
ConvBNAct(filters2, filters2),
ConvBNAct(filters2, filters2, stride=2),
ConvBNAct(filters2, filters2),
ConvBNAct(filters2, filters2, kernel_size=1),
)
final_channels = filters2
if not self.pool_rotations:
final_channels *= 4
self.class_conv = nn.Conv2d(final_channels, num_classes, 1)
def test_g_z2_conv_equivariance():
from groupy.gfunc import Z2FuncArray, P4FuncArray, P4MFuncArray
import groupy.garray.C4_array as c4a
import groupy.garray.D4_array as d4a
im = np.random.randn(1, 1, 11, 11).astype('float32')
check_equivariance(
im=im,
layers=[P4ConvZ2(1, 2, 3)],
input_array=Z2FuncArray,
output_array=P4FuncArray,
point_group=c4a,
)
check_equivariance(
im=im,
layers=[P4MConvZ2(1, 2, 3)],
input_array=Z2FuncArray,
output_array=P4MFuncArray,
point_group=d4a,
)