def __init__(self,
in_channels,
out_channels,
stride=1,
padding=1,
wscale=1.0):
super(P4MTransitionBlock2D, self).__init__()
# Import the group structure
import importlib
group_name = 'E2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
e2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
self.h_grid = e2_layers.H.grid_global(8) # p4
# Parameters of the model
eps = 2e-5
bias = False
# Layers
self.bn = nn.BatchNorm3d(num_features=in_channels, eps=eps)
self.conv = e2_layers.ConvGG(N_in=in_channels,
N_out=out_channels,
kernel_size=1,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
wscale=wscale)
self.pooling = e2_layers.average_pooling_Rn
def __init__(self, N_h_in, N_in, ratio=1, group='SE2'):
super(fChannelAttentionGG, self).__init__()
self.N_in = N_in
self.ratio = ratio
self.N_h_in = N_h_in
self.N_h = N_h_in
self.weight_fc1 = torch.nn.Parameter(
torch.rand(self.N_in // ratio, self.N_in, self.N_h_in))
self.weight_fc2 = torch.nn.Parameter(
torch.rand(self.N_in, self.N_in // ratio, self.N_h_in))
# group instantiation
self.action = self._left_action_of_h_grid_se2
if group == 'E2': # TODO: Move to a more meaningful place.
import importlib
group = importlib.import_module('attgconv.group.' + group)
import attgconv
e2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4m group
n_grid = 8
self.h_grid = e2_layers.H.grid_global(n_grid)
self.action = self._left_action_on_grid_e2
# Initialize weights
self.reset_parameters()
def __init__(self, in_channels, out_channels, kernel_size=3, fiber_map='id', stride=1, padding=1, wscale=1.0):
super(P4MResBlock2D, self).__init__()
# Asserts
assert kernel_size % 2 == 1
if not padding == (kernel_size - 1) // 2:
raise NotImplementedError()
# Parameters of the group
# Import the group structure
import importlib
group_name = 'E2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
e2_layers = attgconv.layers(group) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
self.h_grid = e2_layers.H.grid_global(8) # 2*p4
# Parameters of the model
eps = 2e-5
if stride != 1:
self.really_equivariant = True
self.pooling = e2_layers.max_pooling_Rn
else:
self.really_equivariant = False
self.bn1 = nn.BatchNorm3d(num_features=in_channels, eps=eps)
self.c1 = e2_layers.ConvGG(N_in=in_channels , N_out=out_channels, kernel_size=kernel_size, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=stride, padding=padding, wscale=wscale)
if self.really_equivariant:
self.c1 = e2_layers.ConvGG(N_in=in_channels, N_out=out_channels, kernel_size=kernel_size, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=1, padding=padding, wscale=wscale)
self.bn2 = nn.BatchNorm3d(num_features=out_channels, eps=eps)
self.c2 = e2_layers.ConvGG(N_in=out_channels, N_out=out_channels, kernel_size=kernel_size, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=1 , padding=padding, wscale=wscale)
if fiber_map == 'id':
if not in_channels == out_channels:
raise ValueError('fiber_map cannot be identity when channel dimension is changed.')
self.fiber_map = nn.Sequential() # Identity
elif fiber_map == 'zero_pad':
raise NotImplementedError()
elif fiber_map == 'linear':
self.fiber_map = e2_layers.ConvGG(N_in=in_channels, N_out=out_channels, kernel_size=1, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=stride, padding=0, wscale=wscale)
if self.really_equivariant:
self.fiber_map = e2_layers.ConvGG(N_in=in_channels, N_out=out_channels, kernel_size=1, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=1, padding=0, wscale=wscale)
else:
raise ValueError('Unknown fiber_map: ' + str(type))
def __init__(self, use_bias=False):
super(RomHog_fA_P4CNN, self).__init__()
#Parameters of the group
# Import the group structure
import importlib
group_name = 'SE2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
se2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
n_grid = 4
h_grid = se2_layers.H.grid_global(n_grid)
# ----------------------
# Parameters of the model
p = 0.3
stride = 1
padding = 0
kernel_size = 3
N_channels = 10
eps = 2e-5
# ----------------------
# --------------------------------------------------------
# Store all parameters such that all (sub)models share it.
self.group_name = group_name
self.group = group
self.layers = se2_layers
self.n_grid = n_grid
self.h_grid = h_grid
self.p = p
self.stride = stride
self.padding = padding
self.kernel_size = kernel_size
self.N_channels = N_channels
self.eps = eps
from attgconv.RomHog_attention import fSpatialAttention as sp_RnG
from attgconv.RomHog_attention import fSpatialAttentionGG
sp_GG = functools.partial(fSpatialAttentionGG,
group=group,
input_h_grid=self.h_grid,
stride=stride)
self.c1 = se2_layers.fAttConvRnG(N_in=1,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
stride=stride,
padding=padding,
spatial_attention=sp_RnG(
group=group,
h_grid=self.h_grid,
N_in=1))
self.c2 = se2_layers.fAttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
spatial_attention=sp_GG(N_in=N_channels))
self.c3 = se2_layers.fAttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
spatial_attention=sp_GG(N_in=N_channels))
self.c4 = se2_layers.fAttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
spatial_attention=sp_GG(N_in=N_channels))
self.c5 = se2_layers.fAttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
spatial_attention=sp_GG(N_in=N_channels))
self.c6 = se2_layers.fAttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
spatial_attention=sp_GG(N_in=N_channels))
self.c7 = se2_layers.fAttConvGG(
N_in=N_channels,
N_out=10,
kernel_size=4,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
spatial_attention=sp_GG(N_in=N_channels))
# Dropout
self.dp = nn.Dropout(p)
# Batch Normalization
self.bn1 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn2 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn3 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn4 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn5 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn6 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
# Max Pooling
self.max_pooling = se2_layers.max_pooling_Rn
def __init__(self, num_blocks=5, n_channels=24):
super(fA_P4MDenseNet, self).__init__()
#Parameters of the group
# Import the group structure
import importlib
group_name = 'E2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
e2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
n_grid = 8
self.h_grid = e2_layers.H.grid_global(n_grid) # 2*p4
# Parameters of the model
padding = 0
stride = 1
kernel_size = 3
eps = 2e-5
bias = False
grow_ch = n_channels
# Save num_blocks
self.num_blocks = num_blocks
# Initialization parameters
wscale = sqrt(
2.) # This makes the initialization equal to that of He et. al.
# ----------------------
# Parameters of attention
# ch_ratio = 16
sp_kernel_size = 7
sp_padding = (sp_kernel_size // 2)
# --------------------------------------------------------
from attgconv.attention_layers import fChannelAttention as ch_RnG
from attgconv.attention_layers import fChannelAttentionGG # as ch_GG
from attgconv.attention_layers import fSpatialAttention # as sp_RnG
from attgconv.attention_layers import fSpatialAttentionGG
ch_GG = functools.partial(fChannelAttentionGG,
N_h_in=n_grid,
group=group_name)
sp_RnG = functools.partial(fSpatialAttention, wscale=wscale)
sp_GG = functools.partial(fSpatialAttentionGG,
group=group,
input_h_grid=self.h_grid,
wscale=wscale)
# First layer is a convolution
self.c1 = e2_layers.fAttConvRnG(N_in=3,
N_out=n_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
stride=stride,
padding=padding,
wscale=wscale,
channel_attention=ch_RnG(N_in=3,
ratio=1),
spatial_attention=sp_RnG(
group=group,
kernel_size=sp_kernel_size,
h_grid=self.h_grid,
dilation=4))
# Add num_blocks - 1 DenseBlocks and TransitionBlocks
block_layers = []
trans_layers = []
dilations = [4, 4, 3, 2]
for i in range(num_blocks - 1):
block_layers.append(
fA_P4MDenseBlock2D(in_channels=n_channels,
out_channels=grow_ch,
kernel_size=kernel_size,
stride=stride,
padding=padding,
wscale=wscale,
dilation=dilations[i]))
n_channels = n_channels + grow_ch
if i == 3:
dilations[i] = 1
trans_layers.append(
fA_P4MTransitionBlock2D(in_channels=n_channels,
out_channels=n_channels,
stride=stride,
padding=padding,
wscale=wscale,
dilation=dilations[i]))
# Add last layer to DenseBlock
block_layers.append(
fA_P4MDenseBlock2D(in_channels=n_channels,
out_channels=grow_ch,
kernel_size=kernel_size,
stride=stride,
padding=padding,
wscale=wscale,
sp_kernel_size=5))
n_channels = n_channels + grow_ch
# Add layers to self
self.block_layers = nn.Sequential(*block_layers)
self.trans_layers = nn.Sequential(*trans_layers)
# Add BN for final DenseBlock
self.bn_out = nn.BatchNorm3d(num_features=n_channels, eps=eps)
# Reduce to 2 channels (IMPORTANT! THIS IS DIFFERENT TO VEELING ET. AL. (2018), They use only one output channel with sigmoid)
self.c_out = e2_layers.fAttConvGG(
N_in=n_channels,
N_out=2,
kernel_size=1,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
wscale=wscale,
channel_attention=ch_GG(N_in=n_channels, ratio=n_channels // 2),
spatial_attention=sp_GG(kernel_size=3))
# Define last pooling layer
self.pooling = e2_layers.average_pooling_Rn
def __init__(self,
in_channels,
out_channels,
stride=1,
padding=1,
wscale=1.0,
sp_kernel_size=None,
dilation=1):
super(fA_P4TransitionBlock2D, self).__init__()
# Import the group structure
import importlib
group_name = 'SE2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
se2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
n_grid = 4
self.h_grid = se2_layers.H.grid_global(n_grid) # p4
# Parameters of the model
eps = 2e-5
bias = False
# ----------------------
# Parameters of attention
# ch_ratio = 16
if sp_kernel_size is None:
sp_kernel_size = 7
sp_padding = (sp_kernel_size // 2)
# --------------------------------------------------------
from attgconv.attention_layers import fChannelAttentionGG # as ch_GG
from attgconv.attention_layers import fSpatialAttention # as sp_RnG
from attgconv.attention_layers import fSpatialAttentionGG
ch_GG = functools.partial(fChannelAttentionGG,
N_h_in=n_grid,
group=group_name)
sp_RnG = functools.partial(fSpatialAttention, wscale=wscale)
sp_GG = functools.partial(fSpatialAttentionGG,
group=group,
input_h_grid=self.h_grid,
wscale=wscale)
# Layers
self.bn = nn.BatchNorm3d(num_features=in_channels, eps=eps)
self.conv = se2_layers.fAttConvGG(
N_in=in_channels,
N_out=out_channels,
kernel_size=1,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
wscale=wscale,
channel_attention=ch_GG(N_in=in_channels, ratio=in_channels // 2),
spatial_attention=sp_GG(kernel_size=sp_kernel_size,
dilation=dilation))
self.pooling = se2_layers.average_pooling_Rn
def __init__(self, num_blocks=5, n_channels=24):
super(P4MDenseNet, self).__init__()
#Parameters of the group
# Import the group structure
import importlib
group_name = 'E2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
e2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
self.h_grid = e2_layers.H.grid_global(8) # 2xp4
# Parameters of the model
padding = 0
stride = 1
kernel_size = 3
eps = 2e-5
bias = False
grow_ch = n_channels
# Save num_blocks
self.num_blocks = num_blocks
# Initialization parameters
wscale = sqrt(
2.) # This makes the initialization equal to that of He et. al.
# First layer is a convolution
self.c1 = e2_layers.ConvRnG(N_in=3,
N_out=n_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
stride=stride,
padding=padding,
wscale=wscale)
# Add num_blocks - 1 DenseBlocks and TransitionBlocks
block_layers = []
trans_layers = []
for i in range(num_blocks - 1):
block_layers.append(
P4MDenseBlock2D(in_channels=n_channels,
out_channels=grow_ch,
kernel_size=kernel_size,
stride=stride,
padding=padding,
wscale=wscale))
n_channels = n_channels + grow_ch
trans_layers.append(
P4MTransitionBlock2D(in_channels=n_channels,
out_channels=n_channels,
stride=stride,
padding=padding,
wscale=wscale))
# Add last layer to DenseBlock
block_layers.append(
P4MDenseBlock2D(in_channels=n_channels,
out_channels=grow_ch,
kernel_size=kernel_size,
stride=stride,
padding=padding,
wscale=wscale))
n_channels = n_channels + grow_ch
# Add layers to self
self.block_layers = nn.Sequential(*block_layers)
self.trans_layers = nn.Sequential(*trans_layers)
# Add BN for final DenseBlock
self.bn_out = nn.BatchNorm3d(num_features=n_channels, eps=eps)
# Reduce to 2 channels (IMPORTANT! THIS IS DIFFERENT TO VEELING ET. AL. (2018), They use only one output channel with sigmoid)
self.c_out = e2_layers.ConvGG(N_in=n_channels,
N_out=2,
kernel_size=1,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
wscale=wscale)
# Define last pooling layer
self.pooling = e2_layers.average_pooling_Rn
def __init__(self, in_channels, out_channels, kernel_size=3, fiber_map='id', stride=1, padding=1, wscale=1.0):
super(fA_P4MResBlock2D, self).__init__()
# Asserts
assert kernel_size % 2 == 1
if not padding == (kernel_size - 1) // 2:
raise NotImplementedError()
# Parameters of the group
# Import the group structure
import importlib
group_name = 'E2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
e2_layers = attgconv.layers(group) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
n_grid = 8
self.h_grid = e2_layers.H.grid_global(n_grid) # 2*p4
# ----------------------
# Parameters of the model
eps = 2e-5
# ----------------------
# Parameters of attention
#ch_ratio = 16
sp_kernel_size = 7
sp_padding = (sp_kernel_size // 2)
# --------------------------------------------------------
from attgconv.attention_layers import fChannelAttention as ch_RnG
from attgconv.attention_layers import fChannelAttentionGG # as ch_GG
from attgconv.attention_layers import fSpatialAttention # as sp_RnG
from attgconv.attention_layers import fSpatialAttentionGG
ch_GG = functools.partial(fChannelAttentionGG, N_h_in=n_grid, group=group_name)
sp_RnG = functools.partial(fSpatialAttention, wscale=wscale)
sp_GG = functools.partial(fSpatialAttentionGG, group=group, input_h_grid=self.h_grid, wscale=wscale)
if stride != 1:
self.really_equivariant = True
self.pooling = e2_layers.max_pooling_Rn
else:
self.really_equivariant = False
self.bn1 = nn.BatchNorm3d(num_features=in_channels, eps=eps)
self.c1 = e2_layers.fAttConvGG(N_in=in_channels , N_out=out_channels, kernel_size=kernel_size, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=stride, padding=padding, wscale=wscale,
channel_attention=ch_GG(N_in=in_channels, ratio=in_channels // 2),
spatial_attention=sp_GG(kernel_size=sp_kernel_size)
)
if self.really_equivariant:
self.c1 = e2_layers.fAttConvGG(N_in=in_channels, N_out=out_channels, kernel_size=kernel_size, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=1, padding=padding, wscale=wscale,
channel_attention=ch_GG(N_in=in_channels, ratio=in_channels // 2),
spatial_attention=sp_GG(kernel_size=sp_kernel_size)
)
self.bn2 = nn.BatchNorm3d(num_features=out_channels, eps=eps)
self.c2 = e2_layers.fAttConvGG(N_in=out_channels, N_out=out_channels, kernel_size=kernel_size, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=1 , padding=padding, wscale=wscale,
channel_attention=ch_GG(N_in=out_channels, ratio=out_channels // 2),
spatial_attention=sp_GG(kernel_size=sp_kernel_size)
)
if fiber_map == 'id':
if not in_channels == out_channels:
raise ValueError('fiber_map cannot be identity when channel dimension is changed.')
self.fiber_map = nn.Sequential() # Identity
elif fiber_map == 'zero_pad':
raise NotImplementedError()
elif fiber_map == 'linear':
self.fiber_map = e2_layers.fAttConvGG(N_in=in_channels, N_out=out_channels, kernel_size=1, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=stride, padding=0, wscale=wscale,
channel_attention=ch_GG(N_in=in_channels, ratio=in_channels // 2),
spatial_attention=sp_GG(kernel_size=sp_kernel_size)
)
if self.really_equivariant:
self.fiber_map = e2_layers.fAttConvGG(N_in=in_channels, N_out=out_channels, kernel_size=1, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=1, padding=0, wscale=wscale,
channel_attention=ch_GG(N_in=in_channels, ratio=in_channels // 2),
spatial_attention=sp_GG(kernel_size=sp_kernel_size)
)
else:
raise ValueError('Unknown fiber_map: ' + str(type))
def __init__(self, num_blocks=7, nc32=11, nc16=23, nc8=45):
"""
:param num_blocks: the number of resnet blocks per stage. There are 3 stages, for feature map width 32, 16, 8.
Total number of layers is 6 * num_blocks + 2
:param nc32: the number of feature maps in the first stage (where feature maps are 32x32)
:param nc16: the number of feature maps in the second stage (where feature maps are 16x16)
:param nc8: the number of feature maps in the third stage (where feature maps are 8x8)
"""
super(fA_P4MResNet, self).__init__()
#Parameters of the group
# Import the group structure
import importlib
group_name = 'E2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
e2_layers = attgconv.layers(group) # The layers is instantiated with the group structure as input
# Create H grid for p4m group
n_grid = 8
h_grid = e2_layers.H.grid_global(n_grid)
# ----------------------
# Parameters of the model
stride = 1
padding = 1
kernel_size = 3
eps = 2e-5
# --------------------------------------------------------
# Store in self
self.group_name = group_name
self.group = group
self.layers = e2_layers
self.n_grid = n_grid
self.h_grid = h_grid
# ----------------------
# Initialization parameters
wscale = sqrt(2.) # This makes the initialization equal to that of He et al.
# ----------------------
# Parameters of attention
ch_ratio = 16
sp_kernel_size = 7
sp_padding = (sp_kernel_size // 2)
from attgconv.attention_layers import fChannelAttention as ch_RnG
from attgconv.attention_layers import fChannelAttentionGG # as ch_GG
from attgconv.attention_layers import fSpatialAttention # as sp_RnG
from attgconv.attention_layers import fSpatialAttentionGG
ch_GG = functools.partial(fChannelAttentionGG, N_h_in=n_grid, group=group_name)
sp_RnG = functools.partial(fSpatialAttention, wscale=wscale)
sp_GG = functools.partial(fSpatialAttentionGG, group=group, input_h_grid=self.h_grid, wscale=wscale)
# Pooling layer
self.avg_pooling = e2_layers.average_pooling_Rn
# The first layer is always a convolution.
self.c1 = e2_layers.fAttConvRnG(N_in=3, N_out=nc32, kernel_size=kernel_size, h_grid=self.h_grid, stride=stride, padding=padding, wscale=wscale,
channel_attention=ch_RnG(N_in=3, ratio=1),
spatial_attention=sp_RnG(group=group, kernel_size=sp_kernel_size, h_grid=self.h_grid)
)
# Add num_blocks ResBlocks (2 * num_blocks layers) for the size 32x32 feature maps
layers_nc32 = []
for i in range(num_blocks):
layers_nc32.append(fA_P4MResBlock2D(in_channels=nc32, out_channels=nc32, kernel_size=kernel_size, fiber_map='id', stride=stride, padding=padding, wscale=wscale))
self.layers_nc32 = nn.Sequential(*layers_nc32)
# Add num_blocks ResBlocks (2 * num_blocks layers) for the size 16x16 feature maps
# The first convolution uses stride 2
layers_nc16 = []
for i in range(num_blocks):
stride_block = 1 if i > 0 else 2
fiber_map = 'id' if i > 0 else 'linear'
nc_in = nc16 if i > 0 else nc32
layers_nc16.append(fA_P4MResBlock2D(in_channels=nc_in, out_channels=nc16, kernel_size=kernel_size, fiber_map=fiber_map, stride=stride_block, padding=padding, wscale=wscale))
self.layers_nc16 = nn.Sequential(*layers_nc16)
# Add num_blocks ResBlocks (2 * num_blocks layers) for the size 8x8 feature maps
# The first convolution uses stride 2
layers_nc8 = []
for i in range(num_blocks):
stride_block = 1 if i > 0 else 2
fiber_map = 'id' if i > 0 else 'linear'
nc_in = nc8 if i > 0 else nc16
layers_nc8.append(fA_P4MResBlock2D(in_channels=nc_in, out_channels=nc8, kernel_size=kernel_size, fiber_map=fiber_map, stride=stride_block, padding=padding, wscale=wscale))
self.layers_nc8 = nn.Sequential(*layers_nc8)
# Add BN and final layer
# We do ReLU and average pooling between BN and final layer,
# but since these are stateless they don't require a Link.
self.bn_out = nn.BatchNorm3d(num_features=nc8, eps=eps)
self.c_out = e2_layers.fAttConvGG(N_in=nc8, N_out=10, kernel_size=1, h_grid=self.h_grid, input_h_grid=self.h_grid, stride=1, padding=0, wscale=wscale,
channel_attention=ch_GG(N_in=nc8, ratio=nc8 // 2),
spatial_attention=sp_GG(kernel_size=sp_kernel_size)
)
def __init__(self, use_bias=False):
super(P4CNN, self).__init__()
#Parameters of the group
# Import the group structure
import importlib
group_name = 'SE2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
se2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
self.h_grid = se2_layers.H.grid_global(4)
# Parameters of the model
p = 0.3
stride = 1
padding = 0
kernel_size = 3
N_channels = 10
eps = 2e-5
# Conv Layers
self.c1 = se2_layers.ConvRnG(N_in=1,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
stride=stride,
padding=padding)
self.c2 = se2_layers.ConvGG(N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding)
self.c3 = se2_layers.ConvGG(N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding)
self.c4 = se2_layers.ConvGG(N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding)
self.c5 = se2_layers.ConvGG(N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding)
self.c6 = se2_layers.ConvGG(N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding)
self.c7 = se2_layers.ConvGG(N_in=N_channels,
N_out=10,
kernel_size=4,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding)
# Dropout
self.dp = nn.Dropout(p)
# Batch Normalization
self.bn1 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn2 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn3 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn4 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn5 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn6 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
# Max Pooling
self.max_pooling = se2_layers.max_pooling_Rn
def __init__(self, use_bias=False, attention=False):
super(A_Sp_P4CNN, self).__init__()
#Parameters of the group
# Import the group structure
import importlib
group_name = 'SE2'
group = importlib.import_module('attgconv.group.' + group_name)
# Import the gsplintes package and the layers
import attgconv
se2_layers = attgconv.layers(
group
) # The layers is instantiated with the group structure as input
# Create H grid for p4 group
n_grid = 4
self.h_grid = se2_layers.H.grid_global(n_grid)
# Parameters of the model
p = 0.3
stride = 1
padding = 0
kernel_size = 3
N_channels = 10
eps = 2e-5
# Parameters of attention
ch_ratio = self.ch_ratio #(N_channels // 2) # Hidden layer consists of 2 neurons
sp_kernel_size = self.sp_kernel_size
from attgconv.attention_layers import ChannelAttention as ch_RnG
from attgconv.attention_layers import ChannelAttentionGG #as ch_GG
from attgconv.attention_layers import SpatialAttention #as sp_RnG
from attgconv.attention_layers import SpatialAttentionGG
ch_GG = functools.partial(ChannelAttentionGG,
N_h=n_grid,
N_h_in=n_grid)
sp_RnG = functools.partial(SpatialAttention,
group=group,
h_grid=self.h_grid,
stride=stride)
sp_GG = functools.partial(SpatialAttentionGG,
group=group,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride)
self.c1 = se2_layers.AttConvRnG(
N_in=1,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
stride=stride,
padding=padding,
#channel_attention=ch_RnG(N_out=N_channels, N_in=1 , ratio=1),
spatial_attention=sp_RnG(N_out=N_channels,
N_in=1,
kernel_size=sp_kernel_size))
self.c2 = se2_layers.AttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
#channel_attention=ch_GG(N_out= N_channels, N_in=N_channels, ratio=ch_ratio),
spatial_attention=sp_GG(N_out=N_channels,
N_in=N_channels,
kernel_size=sp_kernel_size))
self.c3 = se2_layers.AttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
#channel_attention=ch_GG(N_out=N_channels, N_in=N_channels, ratio=ch_ratio),
spatial_attention=sp_GG(N_out=N_channels,
N_in=N_channels,
kernel_size=sp_kernel_size))
self.c4 = se2_layers.AttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
#channel_attention=ch_GG(N_out=N_channels, N_in=N_channels, ratio=ch_ratio),
spatial_attention=sp_GG(N_out=N_channels,
N_in=N_channels,
kernel_size=sp_kernel_size))
self.c5 = se2_layers.AttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
#channel_attention=ch_GG(N_out=N_channels, N_in=N_channels, ratio=ch_ratio),
spatial_attention=sp_GG(N_out=N_channels,
N_in=N_channels,
kernel_size=sp_kernel_size))
self.c6 = se2_layers.AttConvGG(
N_in=N_channels,
N_out=N_channels,
kernel_size=kernel_size,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
#channel_attention=ch_GG(N_out=N_channels, N_in=N_channels, ratio=ch_ratio),
spatial_attention=sp_GG(N_out=N_channels,
N_in=N_channels,
kernel_size=sp_kernel_size))
self.c7 = se2_layers.AttConvGG(
N_in=N_channels,
N_out=10,
kernel_size=4,
h_grid=self.h_grid,
input_h_grid=self.h_grid,
stride=stride,
padding=padding,
#channel_attention=ch_GG(N_out=10 , N_in=N_channels, ratio=ch_ratio),
spatial_attention=sp_GG(N_out=10,
N_in=N_channels,
kernel_size=sp_kernel_size))
# Dropout
self.dp = nn.Dropout(p)
# Batch Normalization
self.bn1 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn2 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn3 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn4 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn5 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
self.bn6 = nn.BatchNorm3d(num_features=N_channels, eps=eps)
# Max Pooling
self.max_pooling = se2_layers.max_pooling_Rn
