def __init__(self):
super(BasicBlockD3, self).__init__()
densenum = 32
basenum = 256
level = 1
self.bl1 = BasicLayerD(inplanes=level * basenum + densenum * 0)
self.bl2 = BasicLayerD(inplanes=level * basenum + densenum * 1)
self.bl3 = BasicLayerD(inplanes=level * basenum + densenum * 2)
self.bl4 = BasicLayerD(inplanes=level * basenum + densenum * 3)
self.bl5 = BasicLayerD(inplanes=level * basenum + densenum * 4)
self.bl6 = BasicLayerD(inplanes=level * basenum + densenum * 5)
self.bl7 = BasicLayerD(inplanes=level * basenum + densenum * 6)
self.bl8 = BasicLayerD(inplanes=level * basenum + densenum * 7)
self.bl9 = BasicLayerD(inplanes=level * basenum + densenum * 8)
self.bl10 = BasicLayerD(inplanes=level * basenum + densenum * 9)
self.bl11 = BasicLayerD(inplanes=level * basenum + densenum * 10)
self.bl12 = BasicLayerD(inplanes=level * basenum + densenum * 11)
self.bl13 = BasicLayerD(inplanes=level * basenum + densenum * 12)
self.bl14 = BasicLayerD(inplanes=level * basenum + densenum * 13)
self.bl15 = BasicLayerD(inplanes=level * basenum + densenum * 14)
self.bl16 = BasicLayerD(inplanes=level * basenum + densenum * 15)
self.bl17 = BasicLayerD(inplanes=level * basenum + densenum * 16)
self.bl18 = BasicLayerD(inplanes=level * basenum + densenum * 17)
self.bl19 = BasicLayerD(inplanes=level * basenum + densenum * 18)
self.bl20 = BasicLayerD(inplanes=level * basenum + densenum * 19)
self.bl21 = BasicLayerD(inplanes=level * basenum + densenum * 20)
self.bl22 = BasicLayerD(inplanes=level * basenum + densenum * 21)
self.bl23 = BasicLayerD(inplanes=level * basenum + densenum * 22)
self.bl24 = BasicLayerD(inplanes=level * basenum + densenum * 23)
self.nlfT = nn.PReLU()
self.nlfT2 = nn.PReLU()
self.convT = hg.Conv2d(level * basenum + densenum * 24, 512, 1, 1)
self.convT2 = hg.Conv2d(512, 512, 1, 2)
def __init__(self, input_dim, output_dim):
"""
:param input_dim:
:param output_dim:
"""
super(DQN_network, self).__init__()
## global state
self.hexconv_1 = hexagdly.Conv2d(in_channels=4,
out_channels=16,
kernel_size=5,
stride=3,
bias=True)
# self.hexpool = hexagdly.MaxPool2d(kernel_size=1, stride=2)
self.hexconv_2 = hexagdly.Conv2d(16, 64, 3, 3) # 1, 16, 15, 18
self.global_fc = nn.Sequential((nn.Linear(64 * 5 * 6,
256))) # ,nn.Dropout(0.5)
## local state
self.local_fc = nn.Linear(input_dim, 256)
self.fc_adv = nn.Linear(256, 64)
self.fc_v = nn.Linear(256, 64)
self.output_adv = nn.Linear(64, output_dim)
self.output_v = nn.Linear(64, 1)
## concat_fc
self.cat_fc = nn.Linear(64 * 5 * 6 + 3, 256)
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
nonlinear_function=None):
super(BasicBlock2, self).__init__()
if nonlinear_function is None:
nonlinear_function = nn.ReLU()
self.conv1 = hg.Conv2d(inplanes, planes,
1) # conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nonlinear_function
self.conv2 = hg.Conv2d(planes, planes, 3, stride)
self.bn2 = nn.BatchNorm2d(planes)
# self.downsample = downsample
self.stride = stride
self.downsample = nn.Sequential(
hg.Conv2d(inplanes,
planes,
kernel_size=1,
stride=stride,
bias=False),
nn.BatchNorm2d(planes),
)
def __init__(self, inplanes, planes, stride=1, downsample=False):
super(BasicBlockQ3, self).__init__()
self.conv1 = hg.Conv2d(inplanes, planes,
1) # conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu1 = nn.PReLU()
self.conv2 = hg.Conv2d(planes, planes, 1)
self.bn2 = nn.BatchNorm2d(planes)
self.relu_end = nn.PReLU()
self.downsample = (inplanes != planes)
self.stride = stride
if self.downsample:
self.conv3 = hg.Conv2d(planes, planes, 3, stride=2)
self.bn3 = nn.BatchNorm2d(planes)
self.relu2 = nn.PReLU()
self.downsample_res = nn.Sequential(
hg.Conv2d(inplanes,
planes,
kernel_size=1,
stride=stride,
bias=False),
nn.BatchNorm2d(planes),
)
def __init__(self, input_dim, output_dim):
super(DQN_target_network, self).__init__()
## global state
self.hexconv_1 = hexagdly.Conv2d(in_channels=4,
out_channels=16,
kernel_size=5,
stride=3)
# self.hexpool = hexagdly.MaxPool2d(kernel_size=1, stride=2)
self.hexconv_2 = hexagdly.Conv2d(16, 64, 3, 3) # 1, 16, 15, 18
self.global_fc = nn.Linear(64 * 6 * 6, 256) # ,nn.Dropout(0.5)
nn.init.xavier_normal_(self.global_fc.weight)
## local state
self.local_fc = nn.Linear(input_dim, 256)
nn.init.xavier_normal_(self.local_fc.weight)
self.fc_adv = nn.Linear(256, 64)
nn.init.xavier_normal_(self.fc_adv.weight)
self.fc_v = nn.Linear(256, 64)
nn.init.xavier_normal_(self.fc_v.weight)
self.output_adv = nn.Linear(64, output_dim)
nn.init.xavier_normal_(self.output_adv.weight)
self.output_v = nn.Linear(64, 1)
nn.init.xavier_normal_(self.output_v.weight)
## concat_fc
self.cat_fc = nn.Linear(64 * 6 * 6 + 3, 256)
nn.init.xavier_normal_(self.cat_fc.weight)
def __init__(self,
inplanes,
stride=1,
downsample=None,
nonlinear_function=None):
super(BasicLayerD, self).__init__()
self.conv1 = hg.Conv2d(inplanes, 128,
1) # conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(128)
self.relu1 = nn.PReLU()
self.conv2 = hg.Conv2d(128, 32, 3, stride)
self.bn2 = nn.BatchNorm2d(32)
self.relu2 = nn.PReLU()
def __init__(self):
super(HexNetDeep_dense1_it, self).__init__()
# size before x.view / batch size
input_channel = 4
self.cinput = hg.Conv2d(input_channel, 64, 1, 1)
self.nlf1 = nn.PReLU()
self.nlf2 = nn.PReLU()
self.nlf3 = nn.PReLU()
self.nlf4 = nn.PReLU()
self.nlf5 = nn.PReLU()
self.block1 = BasicBlockD1()
self.block2 = BasicBlockD2()
self.block3 = BasicBlockD3()
self.endpool = nn.AvgPool2d(5)
self.size2 = 512
self.fc3 = nn.Linear(self.size2, self.size2)
self.fc4 = nn.Linear(self.size2, 2)
self.nlf3_fc = nn.PReLU()
self.nlf4_fc = nn.PReLU()
def __init__(self,
n_conv_filters=4,
n_hidden=36,
n_hidden_layer=1,
n_out=1,
drop_out=0.0,
ny=13,
nz=13):
super(SAMFixedConvNet, self).__init__()
self.n_conv_filters = n_conv_filters
# INPUT: (1 x 6 x 6)
# Conv Output: (1 x 6 x 6)
# Pool Output: (1 x 3 x 3)
self.layer1 = nn.Sequential(
hexagdly.Conv2d(1,
n_conv_filters,
kernel_size=1,
stride=1,
bias=True), nn.ReLU(),
hexagdly.MaxPool2d(kernel_size=1, stride=2))
# Determine pooling output size (ugh, hackish)
dummy = torch.rand((1, 1, nz, ny))
p = hexagdly.MaxPool2d(kernel_size=1, stride=2)
self.n_pool_out = np.prod(p(dummy).shape) * n_conv_filters
# Fully-connected layer(s)
self.o = nn.Linear(self.n_pool_out, n_out, bias=True)
def __init__(self,
n_conv_filters=4,
n_hidden_layer=1,
n_node_hidden=36,
n_node_feature=0,
n_out=1,
drop_out=0.0,
ny=14,
nz=13):
super(SAMConvNetSimple, self).__init__()
self.n_conv_filters = n_conv_filters
## Conv and pooling layer
# INPUT: (1 x ny x nz)
# Conv Output: (1 x ny x nz)
# Pool Output: (1 x ny/2 x nz/2) (check!)
self.conv1 = nn.Sequential(
hexagdly.Conv2d(1,
n_conv_filters,
kernel_size=1,
stride=1,
bias=True), nn.ReLU(),
hexagdly.MaxPool2d(kernel_size=1, stride=2))
# Determine pooling output size (ugh, hackish)
dummy = torch.rand((1, 1, nz, ny))
#p = hexagdly.MaxPool2d(kernel_size=1, stride=2)
#embed()
self.n_pool_out = np.prod(self.conv1(dummy).detach().shape)
# Fully-connected hidden layer(s), optional feature layer, and output layer
self.fc = SAMNet(self.n_pool_out, n_hidden_layer, n_node_hidden,
n_node_feature, n_out, drop_out)
def __init__(self):
super(BasicBlockD1, self).__init__()
densenum = 32
basenum = 64
level = 1
self.bl1 = BasicLayerD(inplanes=level * basenum + densenum * 0)
self.bl2 = BasicLayerD(inplanes=level * basenum + densenum * 1)
self.bl3 = BasicLayerD(inplanes=level * basenum + densenum * 2)
self.bl4 = BasicLayerD(inplanes=level * basenum + densenum * 3)
self.bl5 = BasicLayerD(inplanes=level * basenum + densenum * 4)
self.bl6 = BasicLayerD(inplanes=level * basenum + densenum * 5)
self.nlfT = nn.PReLU()
self.nlfT2 = nn.PReLU()
self.convT = hg.Conv2d(level * basenum + densenum * 6, 128, 1, 1)
self.convT2 = hg.Conv2d(128, 128, 1, 2)
def __init__(self,
n_conv_filters=4,
n_hidden_layer=1,
n_node_hidden=36,
n_node_feature=0,
kernel_size=1,
n_out=1,
drop_out=0.0,
nx=12,
ny=11):
super(SAMConvNet, self).__init__()
self.n_conv_filters = n_conv_filters
## Conv and pooling layer
# INPUT: (1 x ny x nz)
# Conv Output: (1 x ny x nz)
# Pool Output: (1 x ny/2 x nz/2) (check!)
self.conv1 = hexagdly.Conv2d(1,
n_conv_filters,
kernel_size=kernel_size,
stride=1,
bias=True)
self.pool = hexagdly.MaxPool2d(kernel_size=1, stride=2)
self.conv2 = hexagdly.Conv2d(n_conv_filters,
n_conv_filters,
kernel_size=1,
stride=1,
bias=True)
# Determine pooling output size (ugh, hackish)
dummy = torch.rand((1, 1, ny, nx))
o = self.conv1(dummy).detach()
o = self.pool(o)
o = self.conv2(o)
o = self.pool(o)
self.n_pool_out = np.prod(o.shape)
# Fully-connected hidden layer(s), optional feature layer, and output layer
self.fc = SAMNet(self.n_pool_out, n_hidden_layer, n_node_hidden,
n_node_feature, n_out, drop_out)
def _init_corrector(self):
cnn_layers = []
cnn_layers.append(
hexagdly.Conv2d(in_channels=self.n_classes,
out_channels=32,
kernel_size=1,
stride=1,
bias=True))
cnn_layers.append(
hexagdly.Conv2d(in_channels=32,
out_channels=32,
kernel_size=1,
stride=1,
bias=True))
if self.use_bn:
cnn_layers.append(nn.BatchNorm2d(self.n_classes))
cnn_layers.append(nn.ReLU())
cnn_layers.append(
hexagdly.Conv2d(in_channels=32,
out_channels=32,
kernel_size=1,
stride=1,
bias=True))
cnn_layers.append(
hexagdly.Conv2d(in_channels=32,
out_channels=32,
kernel_size=1,
stride=1,
bias=True))
if self.use_bn:
cnn_layers.append(nn.BatchNorm2d(self.n_classes))
cnn_layers.append(nn.ReLU())
cnn_layers.append(
hexagdly.Conv2d(in_channels=32,
out_channels=self.n_classes,
kernel_size=1,
stride=1,
bias=True))
return nn.Sequential(*cnn_layers)
def __init__(self):
super(BasicBlockD2, self).__init__()
densenum = 32
basenum = 128
level = 1
self.bl1 = BasicLayerD(inplanes=level * basenum + densenum * 0)
self.bl2 = BasicLayerD(inplanes=level * basenum + densenum * 1)
self.bl3 = BasicLayerD(inplanes=level * basenum + densenum * 2)
self.bl4 = BasicLayerD(inplanes=level * basenum + densenum * 3)
self.bl5 = BasicLayerD(inplanes=level * basenum + densenum * 4)
self.bl6 = BasicLayerD(inplanes=level * basenum + densenum * 5)
self.bl7 = BasicLayerD(inplanes=level * basenum + densenum * 6)
self.bl8 = BasicLayerD(inplanes=level * basenum + densenum * 7)
self.bl9 = BasicLayerD(inplanes=level * basenum + densenum * 8)
self.bl10 = BasicLayerD(inplanes=level * basenum + densenum * 9)
self.bl11 = BasicLayerD(inplanes=level * basenum + densenum * 10)
self.bl12 = BasicLayerD(inplanes=level * basenum + densenum * 11)
self.nlfT = nn.PReLU()
self.nlfT2 = nn.PReLU()
self.convT = hg.Conv2d(level * basenum + densenum * 12, 256, 1, 1)
self.convT2 = hg.Conv2d(256, 256, 1, 2)
def get_tensors(self, in_channels, kernel_size, stride, bias):
channel_dist = 1000
if bias is False:
bias_value = 0
else:
bias_value = 1.0
# input tensor
array = self.get_array()
array = np.expand_dims(
np.stack([j * channel_dist + array for j in range(in_channels)]),
0)
tensor = torch.FloatTensor(array)
# expected output tensor
if kernel_size == 1:
conv2d_array = self.get_array_conv2d_size1_stride1()
n_neighbours = self.get_n_neighbors_size1()
elif kernel_size == 2:
conv2d_array = self.get_array_conv2d_size2_stride1()
n_neighbours = self.get_n_neighbors_size2()
convolved_array = np.sum(
np.stack([(channel * channel_dist) * n_neighbours + conv2d_array
for channel in range(in_channels)]),
0,
)
if stride == 2:
convolved_array = self.get_array_stride_2(convolved_array)
elif stride == 3:
convolved_array = self.get_array_stride_3(convolved_array)
convolved_array = np.expand_dims(np.expand_dims(convolved_array, 0), 0)
convolved_tensor = torch.FloatTensor(convolved_array) + bias_value
# output tensor of test method
conv2d = hex.Conv2d(in_channels, 1, kernel_size, stride, bias, True)
return conv2d(tensor), convolved_tensor
import hexagdly
from hexagdly_tools import plot_hextensor
feat_vec, energies, poly, pos_ext, patch_indices, methyl_pos, adj_mat = load_and_prep(
'data/sam_pattern_data.dat.npz')
plt.ion()
feat = feat_vec[310]
#plot_from_feat(pos_ext, feat)
# On 6x6 grid and mirrored
myfeat = feat.reshape(6, 6).T[::-1, ::-1]
myfeat = torch.tensor(np.ascontiguousarray(myfeat)).reshape(1, 1, 6, 6)
#plot_hextensor(myfeat.reshape(1,1,6,6))
hexconv = hexagdly.Conv2d(1,
1,
kernel_size=1,
stride=1,
bias=False,
debug=True)
out = hexconv(myfeat).detach()
dataset = SAMConvDataset(feat_vec, poly)
net = SAMConvNet()
out = net(myfeat)
