def __init__(self):
super(KDD_LCAE, self).__init__()
self.x_dim = 115
self.encoder_h_dim = [30]
self.z_dim = 5
self.decoder_h_dim = [30]
self.encoder_layers = []
self.encoder_layers.append(nn.Linear(self.x_dim,
self.encoder_h_dim[0]))
self.encoder_layers.append(nn.ReLU())
for i in range(len(self.encoder_h_dim) - 1):
self.encoder_layers.append(
nn.Linear(self.encoder_h_dim[i], self.encoder_h_dim[i + 1]))
self.encoder_layers.append(nn.ReLu())
self.encoder_layers.append(
nn.Linear(self.encoder_h_dim[len(self.encoder_h_dim) - 1],
self.z_dim))
self.encoder_layers = nn.ModuleList(self.encoder_layers)
self.decoder_layers = []
self.decoder_layers.append(nn.Linear(self.z_dim,
self.decoder_h_dim[0]))
self.decoder_layers.append(nn.ReLU())
for i in range(len(self.decoder_h_dim) - 1):
self.decoder_layers.append(
nn.Linear(self.decoder_h_dim[i], self.decoder_h_dim[i + 1]))
self.decoder_layers.append(nn.ReLu())
self.decoder_layers.append(
nn.Linear(self.decoder_h_dim[len(self.decoder_h_dim) - 1],
self.x_dim))
self.decoder_layers.append(nn.Tanh())
self.decoder_layers = nn.ModuleList(self.decoder_layers)
def __init__(self, num_players, rnn_size, comm_size, num_actions,
observation_size, init_param_range):
super(DRQNet, self).__init__()
self.num_players = 3
self.rnn_size = 128
self.comm_size = 2
self.num_actions = num_actions
self.observation_size = observation_size
self.init_param_range = (-0.08, 0.08)
#Embedding matrix for DRQN
self.action_matrix = nn.Embedding(self.num_players, self.rnn_size)
self.observation_matrix = nn.Embedding(self.observation_size,
self.rnn_size)
self.previous_action_matrix = nn.Embedding(self.num_actions,
self.rnn_size)
#Single layer NN for producing embeddings for messages
self.message = nn.Sequential(nn.BatchNorm1d(self.comm_size),
nn.Linear(self.comm_size, self.rnn_size),
nn.ReLu(inplace=True))
#RNN component for history over POMDP
self.rnn = nn.GRU(input_size=self.rnn_size,
hidden_size=self.rnn_size,
num_layers=2,
batch_first=True)
#Output from RNN layer
self.output = nn.Sequential(
nn.Linear(self.rnn_size, self.rnn_size),
nn.BatchNorm1d(self.rnn_size), nn.ReLu(),
nn.Linear(self.rnn_size, self.observation_size))
def __init__(self, gridSize=25):
super(FaceGridModel, self).__init__()
self.fc = nn.Sequential(
nn.Linear(gridSize * gridSize, 256),
nn.ReLu(inplace=True),
nn.Linear(256, 128),
nn.ReLu(inplace=True),
)
def __init__(self):
super(ItrackerImageModel, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=0),
nn.ReLu(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(96, 64, kernel_size=1, stride=1, padding=0),
nn.ReLu(inplace=True),
)
def forward(self, x):
x = nn.ReLu(self.conv1(x))
x = nn.bn1(x)
x = nn.ReLu(self.conv2(x))
x = nn.bn2(x)
x += self.skip_layer(x)
x = nn.ReLu()(x)
return x
def __init__(self, num_features: int):
self.num_features = num_features
super().__init__()
self.block1 = nn.Sequential(nn.Linear(num_features, 256),
nn.BatchNormalization(256), nn.ReLu())
self.block2 = nn.Sequential(nn.Linear(256, 128),
nn.BatchNormalization(128), nn.ReLu())
self.out = nn.Linear(128, 1)
def _init_(self):
super(LeNet, self)._init_()
self.CN = nn.Sequential(nn.Conv2d(3, 6, 5), nn.ReLu(), nn.MaxPool2d(2),
nn.Conv2d(6, 16, 5), nn.ReLu(),
nn.MaxPool2d(2))
self.FC = nn.Sequential(
nn.Linear(16 * 5 * 5, 120),
nn.ReLu(),
nn.Linear(120, 84),
nn.ReLu(),
nn.Linear(84, 10),
)
def __init__(self, input_size, output_size, requires_grad=True):
super().__init__()
# vehicle embedding
self.vehicle_embedding = nn.Sequential(nn.Linear(8, 16), nn.ReLU(),
nn.Linear(16, 32), nn.ReLU(),
nn.Linear(32, 64), nn.ReLU(),
nn.Linear(64, 32), nn.ReLu(),
nn.Linear(32, 32))
# create a neural network
self.network = nn.Sequential(
nn.Linear(32, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 512),
nn.ReLU(),
#nn.Linear(512, 512),
#nn.ReLU(),
nn.Linear(512, output_size))
self.loss_fn = F.mse_loss
self.optimiser = torch.optim.Adam(self.network.parameters())
if not requires_grad:
for parameter in self.network.parameters():
parameter.requires_grad = False
def __init__(self):
super(FaceImageModel, self).__init__()
self.conv = ItrackerImageModel()
self.fc = nn.Sequential(
nn.Linear(43264, 64),
nn.ReLu(inplace=True),
)
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
groups=1,
base_width=64,
dilation=1,
norm_layer=None):
super(BasicBlock, self).__init__()
if norm_layer is None:
norm_layer = nn.BatchNorm2d
if groups != 1 or base_width != 64:
raise ValueError(
'BasicBlock only support 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 __init__(self,
input_size,
hidden_size,
num_layers,
dropout,
use_gpu=False,
output_dim=1):
super(LSTM, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.num_layers = num_layers
self.output_dim = output_dim
self.lstm = nn.LSTM(input_size=int(input_size),
hidden_size=int(hidden_size),
num_layers=int(num_layers),
dropout=float(dropout),
batch_first=True)
self.use_gpu = use_gpu
#Deal with Pytorch initialization for LSTMs being flawed
for name, param in self.lstm.named_parameters():
if 'weight' in name:
init.kaiming_uniform(param)
#TODO: Layer Norm?
self.fc1 = nn.Linear(hidden_size, 50)
self.fc2 = nn.Linear(50, 1)
self.relu = nn.ReLu(dim=2)
self.float = self.FloatTensor
if use_gpu:
self.float = torch.cuda.FloatTensor
def __init__(self, total_size, ics, init_weights=True):
super(DenseNet, self).__init__()
self.total_size = total_size
self.init_weights = init_weights
self.ics = ics
self.num_ics = sum(self.ics)
self.num_class = 10
self.num_output = 0
self.train_func = mf.iter_training_0
self.test_func = mf.sdn_test
self.input_size = 32
self.in_channels = 16
self.cum_in_channels = self.in_channels
self.init_conv = nn.Sequential(*[
nn.Conv2d(3, self.in_channels, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(self.in_channels),
nn.ReLu()
])
self.end_layers = nn.Sequential(*[
nn.AvgPool2d(kernel_size=8),
af.Flatten(),
nn.linear(2560, self.num_class)
])
self.grow()
if self.init_weights:
self._init_weights(self.modules())
def single_conv_module(in_chs,
out_chs,
kernel,
deconv=False,
activation=True,
leaky=True):
assert kernel % 2 == 1
layers = [
nn.Conv2d(in_chs,
out_chs,
kernel_size=kernel,
padding=(kernel - 1) // 2),
nn.BatchNorm2d(out_chs),
nn.LeakyReLU(0.2, inplace=True)
]
if deconv:
layers[0] = nn.ConvTranspose2d(in_chs,
out_chs,
kernel_size=kernel,
padding=(kernel - 1) // 2)
if not activation:
del layers[-1]
if not leaky:
layers[2] = nn.ReLu(inplace=True)
return nn.Sequential(*layers)
def __init__(self, block, blocks_num, num_class=1000, include_top=True):
super(ResNet, self).__init__()
self.include_top = include_top
self.in_channel = 64
self.relu = nn.ReLu()
self.conv1 = nn.Conv2d(3,
self.in_channel,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(self.in_channel)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, blocks_num[0])
self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)
self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)
self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)
if self.include_top:
# avgpool
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
# Linear
self.fc = nn.Linear(512 * block.expansion, num_class)
for m in self.modules():
if isinstance((m, nn.Conv2d)):
nn.init.kaiming_normal_(m.weight,
mode='fan_out',
nonlinearity='relu')
def conv(i, normalization="batch", dropout=None, activ='relu'):
in_dim = n_input_ch if i == 0 else n_filt[i - 1]
out_dim = n_filt[i]
cnn.add_module(
"conv{0}".format(i),
nn.Conv2d(in_dim, out_dim, kernel[i], stride[i], pad[i]))
if normalization == "batch":
cnn.add_module(
"batchnorm{0}".format(i),
nn.BatchNorm2d(out_dim, eps=0.001, momentum=0.99))
elif normalization == "layer":
cnn.add_module("layernorm{0}".format(i),
nn.GroupNorm(1, out_dim))
if activ.lower() == "leakyrelu":
cnn.add_module("Relu{0}".format(i), nn.LeakyReLu(0.2))
elif activ.lower() == "relu":
cnn.add_module("Relu{0}".format(i), nn.ReLu())
elif activ.lower() == "glu":
cnn.add_module("glu{0}".format(i), GLU(out_dim))
elif activ.lower() == "cg":
cnn.add_module("cg{0}".format(i), ContextGating(out_dim))
if dropout is not None:
cnn.add_module("dropout{0}".format(i), nn.Dropout(dropout))
def __init__(self, state_dim, action_dim):
super(MLSHMasterPolicy, self).__init__()
self._A = action_dim
self._mlp = nn.Sequential(_init(nn.Linear(state_dim, 64)), nn.ReLU(),
_init(nn.Linear(64, 64)), nn.ReLu(),
_init(nn.Linear(64, self._A * 2)))
return
def __init__(self,in_f,out_f,p_size=2,k_size=3,
stride=1,activation=nn.ReLu()):
super(BNConv1D,self).__init__()
self.conv = nn.Conv1d(in_f,out_f,k_size,stride,padding=k_size/2)
self.pool = nn.MaxPool1d(p_size)
self.bn = nn.BatchNorm1d(out_f)
self.activation = activation
def __init__(self, in_planes, out_planes, stride=1):
super(ResNetBlock, self).__init__()
self.res = nn.Sequential(nn.BatchNorm2d(in_planes),
nn.ReLU(inplace=True),
nn.Conv2d(in_planes, out_planes, 3, stride),
nn.BatchNorm2d(in_planes),
nn.ReLu(inplace=True),
nn.Conv2d(in_planes, out_planes, 3, stride))
def __init__(self):
super(CNN, self).__init__()
self.layer1 = nn.Sequential(
nn.Conv2d(1, 16, kernel_size=3),
nn.BatchNorm2d(16),
nn.ReLU(inplace=True),
)
self.layer2 = nn.Sequential(nn.Conv2d(16, 32, kernel=3),
nn.BatchNorm2d(32), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2))
self.layer3 = nn.Sequential(nn.Conv2d(32, 64, kernel=3),
nn.BatchNorm2d(64), nn.ReLu(inplace=True))
self.layer4 = nn.Sequential(nn.Conv2d(64, 128, kernel=3),
nn.BatchNorm2d(128), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2))
self.fc = nn.Sequential(nn.Linear(128 * 4 * 4, 1024),
nn.ReLu(inplace=True), nn.Linear(1024, 128),
nn.ReLu(inplace=True), nn.Linear(128, 10))
def __init__(self, in_channel, out_channel, kernel=3, stride=2):
self.conv = nn.Conv2d(in_channel,
out_channel,
kernel,
stride,
padding=1,
padding_mode='reflect')
self.norm = nn.InstanceNorm2d(out_channel)
self.act = nn.ReLu()
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nn.ReLu(inplce=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride = stride
def __init__(self, inchannnel, outchannel, stride=1, shortcut=None):
super(ResidualBlock, self).__init__()
self.left = nn.Sequential(
nn.Conv2d(inchannnel, outchannel, 3, stride, 1, bias=False),
nn.BatchNorm2d(outchannel),
nn.ReLu(inplace=True),
nn.Conv2d(outchannel, outchannel, 3, 1, 1, bias=False),
nn.BatchNorm2d(outchannel)
)
self.right = shortcut
def __init__(self,
src_vocab_size,
tgt_vocab_size,
word_emb_size,
src_vocab,
tgt_vocab,
use_cuda=False):
super(Discriminator, self).__init__()
self.src_vocab_size = src_vocab_size
self.tgt_vocab_size = tgt_vocab_size
self.word_emb_size = word_emb_size
self.src_vocab = src_vocab
self.tgt_vocab = tgt_vocab
self.use_cuda = use_cuda
self.embedding_s = nn.Embedding(src_vocab_size, word_emb_size)
self.embedding_t = nn.Embedding(tgt_vocab_size, word_emb_size)
self.conv1 = nn.Sequential(
nn.Conv2d(
in_channel=word_emb_size * 2,
out_channel=64,
kernel_size=3,
stride=1,
padding=1,
), nn.BatchNorm2d(64), nn.ReLu(),
nn.MaxPool2d(kernel_size=2, stride=2))
self.conv2 = nn.Sequential(
nn.Conv2d(
in_channel=64,
out_channel=20,
kernel_size=3,
stride=1,
padding=1,
), nn.BatchNorm2d(20), nn.ReLu(),
nn.MaxPool2d(kernel_size=2, stride=2))
#why 1280
self.mlp = nn.Linear(1280, 20)
self.ll = nn.Linear(20, 2)
self.sigmoid = nn.Sigmoid()
def __init__(self):
super(NeuralNetwor, self).__init__()
self.number_of_actions = 2
self.gamma = 0.95
self.final_epsilon = 0.0001
self.initial_epsilon = 0.1
self.number_of_iterations = 2000000
self.replay_memory_size = 10000
self.minibatch_size = 32
self.conv1 = nn.Conv2d(4, 32, 8, 4)
self.relu1 = nn.ReLu(inplace=True)
self.conv2 = nn.Conv2d(32, 64, 4, 2)
self.relu2 = nn.ReLu(inplace=True)
self.conv3 = nn.Conv2d(64, 64, 3, 1)
self.relu3 = nn.ReLu(inplace=True)
self.fc4 = nn.Linear(3136, 512)
self.relu4 = nn.ReLu(inplace=True)
self.fc5 = nn.Linear(512, self.number_of_actions)
def __init__(self, class_num, filter_num, num):
super().__init__():
self.layer1 = nn.Sequential(nn.Conv2d(in_channels = 1,
out_channels = 32,
kernel_size = 5,
stride = 1,
padding = 2),
nn.BatchNorm2d(num_feature = 32),
nn.ReLu(),
nn.MaxPool2d(kernel_size = 2, stride = 2))
self.layer2 = nn.Sequential(nn.Conv2d(in_channels = 32,
out_channels = 64,
kernel_size = 5,
stride = 1,
padding = 2),
nn.BatchNorm2d(num_features = 64),
nn.ReLu(),
nn.MaxPool2d(kernel_size = 2, stride = 2))
self.fc = nn.Linear(out_channels * num * num, class_num)
self.dropout = nn.Dropout()
def __init__(self, n_neurons):
super(BasicNN, self).__init__()
self.hidden_block = nn.Sequential(
nn.Linear(21, n_neurons),
nn.ReLu(inplace=True)
)
self.out_block = nn.Sequential(
nn.Linear(n_neurons, 2),
nn.Sigmoid()
)
def make_conv_layers(vgg16_config):
layers = []
in_channels = 3
for ii in vgg16_config:
if ii == 'Max':
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = nn.Conv2d(in_channels, 64, kernel_size =3, padding =1)
layers += [conv2d, nn.ReLu(inplace=True)]
in_channels = ii
return nn.Sequential(*layers)
def __init__(self, in_channels, out_channels, add_ic=False, num_classes=10, input_size=32):
super(ConvBNRLUnit, self)
self.layers = nn.Sequential(*[
nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1),
nn.BatchNorm2d(out_channels),
nn.ReLu()
])
if add_ic:
self.ic = af.InternalClassifier(input_size, out_channels, num_classes)
else:
self.ic = None
def __init__(self):
super(ITrackerModel, self).__init__()
self.eyeModel = ItrackerImageModel()
self.faceModel = FaceImageModel()
self.gridModel = FaceGridModel()
# Joining both eyes
self.eyesFC = nn.Sequential(
nn.Linear(2 * 12 * 12 * 64, 128),
nn.ReLu(inplace=True),
)
# Joining everything
self.fc = nn.Sequential(nn.Linear(128 + 64 + 128, 2), )
def downsampling_module(in_chs, pooling_kenel, leaky=True):
layers = [
nn.AvgPool2d(pooling_kenel),
nn.Conv2d(in_chs, in_chs * 2, kernel_size=1, padding=0),
nn.BatchNorm2d(in_chs * 2),
nn.LeakyReLU(0.2, inplace=True)
]
if not leaky:
layers[3] = nn.ReLu(inplace=True)
return nn.Sequential(*layers)
