def __init__(self, input_size=28, hidden_size=100, output=10, tasks=8, s_init=False, beta=False): super(ATwoLayer, self).__init__() # A bunch of convolutions one after another # self.l1 = ALinear(784, hidden_size, datasets=tasks, same_init=s_init, Beta=beta) self.l1 = ALinear(input_size, hidden_size, datasets=tasks, same_init=s_init, Beta=beta) self.l2 = ALinear(hidden_size, hidden_size, datasets=tasks, same_init=s_init, Beta=beta) self.l3 = ALinear(hidden_size, hidden_size, datasets=tasks, same_init=s_init, Beta=beta) self.l4 = ALinear(hidden_size, output, datasets=tasks, same_init=s_init, Beta=beta) self.relu = nn.ReLU() self.ls = nn.LogSoftmax(dim=1)
def __init__(self, data_dim, hidden_dim, augment_dim=0, time_dependent=False, non_linearity='relu'): super(AODEFunc, self).__init__() self.augment_dim = augment_dim self.data_dim = data_dim self.input_dim = data_dim + augment_dim self.hidden_dim = hidden_dim self.nfe = 0 # Number of function evaluations self.time_dependent = time_dependent if time_dependent: self.fc1 = ALinear(self.input_dim + 1, hidden_dim) else: self.fc1 = ALinear(self.input_dim, hidden_dim) self.fc2 = ALinear(hidden_dim, hidden_dim) self.fc3 = ALinear(hidden_dim, self.input_dim) if non_linearity == 'relu': self.non_linearity = nn.ReLU(inplace=True) elif non_linearity == 'softplus': self.non_linearity = nn.Softplus()
def __init__(self, input_shape, tasks=1): """ :param input_shape: input image shape, (h, w, c) """ super(ANet2, self).__init__() self.features = Sequential( AConv2d(input_shape[-1], 64, kernel_size=10, datasets=tasks), ReLU(), MaxPool2d(kernel_size=(2, 2), stride=2), AConv2d(64, 128, kernel_size=7, datasets=tasks), ReLU(), MaxPool2d(kernel_size=(2, 2), stride=2), AConv2d(128, 128, kernel_size=4, datasets=tasks), ReLU(), MaxPool2d(kernel_size=(2, 2), stride=2), AConv2d(128, 256, kernel_size=4, datasets=tasks), ReLU()) # self.features.forward = mod_forward # Compute number of input features for the last fully-connected layer input_shape = (1, ) + input_shape[::-1] x = Variable(torch.rand(input_shape), requires_grad=False) x = mod_forward(x, 0, self.features) x = Flatten()(x) n = x.size()[1] self.classifier = ALinear(n, 4096, datasets=tasks)
def __init__(self, input_shape, tasks=1): """ :param input_shape: input image shape, (h, w, c) """ super(ANet, self).__init__() self.conv1 = AConv2d(input_shape[-1], 64, kernel_size=10, datasets=tasks) self.mp1 = MaxPool2d(kernel_size=(2, 2), stride=2) self.conv2 = AConv2d(64, 128, kernel_size=7, datasets=tasks) self.mp2 = MaxPool2d(kernel_size=(2, 2), stride=2) self.conv3 = AConv2d(128, 128, kernel_size=4, datasets=tasks) self.mp3 = MaxPool2d(kernel_size=(2, 2), stride=2) self.conv4 = AConv2d(128, 256, kernel_size=4, datasets=tasks) self.relu = nn.ReLU() # Compute number of input features for the last fully-connected layer input_shape = (1, ) + input_shape[::-1] x = Variable(torch.rand(input_shape), requires_grad=False) x = self.mp1(self.relu(self.conv1(x, 0))) x = self.mp2(self.relu(self.conv2(x, 0))) x = self.mp3(self.relu(self.conv3(x, 0))) x = self.relu(self.conv4(x, 0)) x = Flatten()(x) n = x.size()[1] self.linear = ALinear(n, 4096, datasets=tasks) self.sm = Sigmoid()
def __init__(self, img_size, num_filters, output_dim=1, augment_dim=0, time_dependent=False, non_linearity='relu', tol=1e-3, adjoint=False): super(AConvODENet, self).__init__() self.img_size = img_size self.num_filters = num_filters self.augment_dim = augment_dim self.output_dim = output_dim self.flattened_dim = (img_size[0] + augment_dim) * img_size[1] * img_size[2] self.time_dependent = time_dependent self.tol = tol odefunc = AConvODEFunc(img_size, num_filters, augment_dim, time_dependent, non_linearity) self.odeblock = AODEBlock(odefunc, is_conv=True, tol=tol, adjoint=adjoint) self.linear_layer = ALinear(self.flattened_dim, self.output_dim)
def __init__(self, input_shape, tasks=1): """ :param input_shape: input image shape, (h, w, c) """ super(ASiameseNetworks, self).__init__() self.net = ANet(input_shape) self.classifier = ALinear(4096, 1, bias=False, datasets=tasks)
def __init__(self, layer_size=64, output_shape=55, input_size=784, num_channels=1, keep_prob=1.0, image_size=28, tasks=1, bn_boole=False): super(ClassifierMLP, self).__init__() """ Build a CNN to produce embeddings :param layer_size:64(default) :param num_channels: :param keep_prob: :param image_size: """ self.conv1 = ALinear(num_channels * input_size, layer_size, datasets=tasks) self.conv2 = ALinear(layer_size, layer_size, datasets=tasks) self.conv3 = ALinear(layer_size, layer_size, datasets=tasks) self.conv4 = ALinear(layer_size, layer_size, datasets=tasks) self.bn1 = nn.ModuleList( [nn.BatchNorm1d(layer_size) for j in range(tasks)]) self.bn2 = nn.ModuleList( [nn.BatchNorm1d(layer_size) for j in range(tasks)]) self.bn3 = nn.ModuleList( [nn.BatchNorm1d(layer_size) for j in range(tasks)]) self.bn4 = nn.ModuleList( [nn.BatchNorm1d(layer_size) for j in range(tasks)]) self.do = nn.Dropout(keep_prob) self.relu = nn.ReLU() self.sm = nn.Sigmoid() self.outSize = layer_size self.linear = ALinear(layer_size, output_shape, datasets=tasks, multi=True) self._weight_init()
def __init__(self, layer_size=64, num_channels=1, keep_prob=1.0, image_size=28, tasks=1): super(OmniV, self).__init__() self.classifier = Classifier(layer_size, num_channels, keep_prob, image_size, tasks) # self.linear = ALinear(self.classifier.outSize,1, datasets = tasks) self.linear = ALinear(28 * 28, 1, datasets=tasks)
def __init__(self, layer_size=64, output_shape=55, num_channels=1, keep_prob=1.0, image_size=28, tasks=1, bn_boole=False): super(Classifier, self).__init__() """ Build a CNN to produce embeddings :param layer_size:64(default) :param num_channels: :param keep_prob: :param image_size: """ self.conv1 = AConv2d(num_channels, layer_size, 3, 1, 1, datasets=tasks) self.conv2 = AConv2d(layer_size, layer_size, 3, 1, 1, datasets=tasks) self.conv3 = AConv2d(layer_size, layer_size, 3, 1, 1, datasets=tasks) self.conv4 = AConv2d(layer_size, layer_size, 3, 1, 1, datasets=tasks) self.bn1 = nn.ModuleList( [nn.BatchNorm2d(layer_size) for j in range(tasks)]) self.bn2 = nn.ModuleList( [nn.BatchNorm2d(layer_size) for j in range(tasks)]) self.bn3 = nn.ModuleList( [nn.BatchNorm2d(layer_size) for j in range(tasks)]) self.bn4 = nn.ModuleList( [nn.BatchNorm2d(layer_size) for j in range(tasks)]) self.mp1 = nn.MaxPool2d(kernel_size=2, stride=2) self.mp2 = nn.MaxPool2d(kernel_size=2, stride=2) self.mp3 = nn.MaxPool2d(kernel_size=2, stride=2) self.mp4 = nn.MaxPool2d(kernel_size=2, stride=2) self.do = nn.Dropout(keep_prob) self.relu = nn.ReLU() self.sm = nn.Sigmoid() finalSize = int(math.floor(image_size / (2 * 2 * 2 * 2))) self.outSize = finalSize * finalSize * layer_size self.linear = ALinear(self.outSize, output_shape, datasets=tasks, multi=True) self._weight_init()
def __init__(self, layer_size=64, num_channels=2, keep_prob=1.0, image_size=28, tasks=1): super(Classifier2, self).__init__() """ Build a CNN to produce embeddings :param layer_size:64(default) :param num_channels: :param keep_prob: :param image_size: """ self.conv1 = AConv2d(num_channels, layer_size, 3, 1, 1, datasets=tasks) self.conv2 = AConv2d(layer_size, layer_size, 3, 1, 1, datasets=tasks) self.conv3 = AConv2d(layer_size, layer_size, 3, 1, 1, datasets=tasks) self.conv4 = AConv2d(layer_size, layer_size, 3, 1, 1, datasets=tasks) self.bn1 = nn.BatchNorm2d(layer_size) self.bn2 = nn.BatchNorm2d(layer_size) self.bn3 = nn.BatchNorm2d(layer_size) self.bn4 = nn.BatchNorm2d(layer_size) self.mp1 = nn.MaxPool2d(kernel_size=2, stride=2) self.mp2 = nn.MaxPool2d(kernel_size=2, stride=2) self.mp3 = nn.MaxPool2d(kernel_size=2, stride=2) self.mp4 = nn.MaxPool2d(kernel_size=2, stride=2) self.do = nn.Dropout(keep_prob) self.relu = nn.ReLU() self.sm = nn.Sigmoid() finalSize = int(math.floor(image_size / (2 * 2 * 2 * 2))) self.outSize = finalSize * finalSize * layer_size # self.linear = ALinear(self.outSize, 1, datasets=tasks) self.linear = ALinear(64, 1, datasets=tasks)
def __init__(self, data_dim, hidden_dim, output_dim=1, augment_dim=0, time_dependent=False, non_linearity='relu', tol=1e-3, adjoint=False): super(AODENet, self).__init__() self.data_dim = data_dim self.hidden_dim = hidden_dim self.augment_dim = augment_dim self.output_dim = output_dim self.time_dependent = time_dependent self.tol = tol odefunc = AODEFunc(data_dim, hidden_dim, augment_dim, time_dependent, non_linearity) self.odeblock = AODEBlock(odefunc, tol=tol, adjoint=adjoint) self.linear_layer = ALinear(self.odeblock.odefunc.input_dim, self.output_dim)