def __init__(self, in_dim):
super(CrissCrossAttention, self).__init__()
# Q, K, V 矩阵
self.query_conv = nn.Conv2d(in_channels=in_dim,
out_channels=in_dim // 8,
kernel_size=1)
self.key_conv = nn.Conv2d(in_channels=in_dim,
out_channels=in_dim // 8,
kernel_size=1)
self.value_conv = nn.Conv2d(in_channels=in_dim,
out_channels=in_dim,
kernel_size=1)
# softmax操作
self.softmax = Softmax(dim=3)
self.INF = INF
self.gamma = nn.Parameter(torch.zeros(1))
def __init__(self, config, vis):
super(Attention, self).__init__()
self.vis = vis
self.num_attention_heads = config.transformer["num_heads"]
self.attention_head_size = int(config.hidden_size / self.num_attention_heads)
self.all_head_size = self.num_attention_heads * self.attention_head_size
self.query = Linear(config.hidden_size, self.all_head_size)
self.key = Linear(config.hidden_size, self.all_head_size)
self.value = Linear(config.hidden_size, self.all_head_size)
self.out = Linear(config.hidden_size, config.hidden_size)
self.attn_dropout = Dropout(config.transformer["attention_dropout_rate"])
self.proj_dropout = Dropout(config.transformer["attention_dropout_rate"])
self.softmax = Softmax(dim=-1)
def __init__(self, in_dim):
super(PAM_Module, self).__init__()
self.chanel_in = in_dim
self.query_conv = Conv2d(in_channels=in_dim,
out_channels=in_dim // 8,
kernel_size=1)
self.key_conv = Conv2d(in_channels=in_dim,
out_channels=in_dim // 8,
kernel_size=1)
self.value_conv = Conv2d(in_channels=in_dim,
out_channels=in_dim,
kernel_size=1)
self.gamma = Parameter(torch.zeros(1))
self.softmax = Softmax(dim=-1)
def __init__(self, token_embedder, agenda_dim, decoder_dim, encoder_dim,
attn_dim, no_insert_delete_attn, num_layers):
super(AttentionDecoderCell, self).__init__()
input_dim = token_embedder.embed_dim
self.num_layers = num_layers
# see definition of `x_augment` in `forward` method
# we augment the input to each RNN layer with 3 attention contexts + the agenda
augment_dim = encoder_dim + input_dim + input_dim + agenda_dim
self.rnn_cells = []
for layer in range(num_layers):
in_dim = input_dim if layer == 0 else decoder_dim # first layer takes word vectors
out_dim = decoder_dim
rnn_cell = LSTMCell(in_dim + augment_dim, out_dim)
self.add_module('decoder_layer_{}'.format(layer), rnn_cell)
self.rnn_cells.append(rnn_cell)
# see definition of `z` in `forward` method
# to predict words, we condition on the hidden state h + 3 attention contexts
z_dim = decoder_dim + encoder_dim + 2 * input_dim
if no_insert_delete_attn:
z_dim = decoder_dim + encoder_dim
self.vocab_projection_pos = Linear(
z_dim, input_dim
) # TODO(kelvin): these big params may need regularization
self.vocab_projection_neg = Linear(z_dim, input_dim)
self.relu = torch.nn.ReLU()
self.h0 = Parameter(torch.zeros(decoder_dim))
self.c0 = Parameter(torch.zeros(decoder_dim))
self.vocab_softmax = Softmax()
self.source_attention = Attention(encoder_dim, decoder_dim, attn_dim)
if not no_insert_delete_attn:
self.insert_attention = Attention(input_dim, decoder_dim, attn_dim)
self.delete_attention = Attention(input_dim, decoder_dim, attn_dim)
else:
self.insert_attention = DummyAttention(input_dim, decoder_dim,
attn_dim)
self.delete_attention = DummyAttention(input_dim, decoder_dim,
attn_dim)
self.token_embedder = token_embedder
self.no_insert_delete_attn = no_insert_delete_attn
def __init__(self,
nb_classes,
verbose=False,
build=True,
batch_size=64,
nb_filters=32,
use_residual=True,
use_bottleneck=True,
depth=6,
kernel_size=41,
nb_epochs=1500,
stride=1,
activation='linear'):
# self.output_directory = output_directory
self.nb_filters = nb_filters
self.use_residual = use_residual
self.use_bottleneck = use_bottleneck
self.depth = depth
self.kernel_size = kernel_size - 1
self.callbacks = None
self.batch_size = batch_size
self.bottleneck_size = 32
self.nb_epochs = nb_epochs
self.depth = depth
self.nb_classes = nb_classes
self.stride = stride
super().__init__()
net = [
InceptionBlockWithResidual.InceptionBlockWithResidual(
1, 32, 8, 18),
inceptionModule.InceptionModule(32, 64, 1, 24, 32, 32, True),
InceptionBlockWithResidual.InceptionBlockWithResidual(
32, 32, 20, 12),
inceptionModule.InceptionModule(32, 32, 1, 8, 32, 32, True)
]
#net = [InceptionBlockWithResidual.InceptionBlockWithResidual(1,32),
# inceptionModule.InceptionModule(32,64,1,41,32,32,True),
# InceptionBlockWithResidual.InceptionBlockWithResidual(32,32),
# inceptionModule.InceptionModule(32,32,1,41,32,32,True)]
self.net = Sequential(*net)
self.output_layer = Sequential(Linear(32, nb_classes), Softmax(1))
def __init__(self,
num_of_layers,
hidden_size,
dropout=0.0,
inner_activation=None):
super(AttendedState, self).__init__()
self.__input_size = hidden_size
self.__output_size = hidden_size
self.mlp = MultiLayerPerceptron(num_of_layers=num_of_layers,
init_size=hidden_size,
out_size=hidden_size,
dropout=dropout,
inner_activation=inner_activation,
outer_activation=inner_activation)
self.attention = Linear(hidden_size, 1)
self.at_softmax = Softmax()
def LeNet(self):
model = getattr(models, 'GoogLeNet')(pretrained=self.pretrained)
conv = model.conv1[0]
classifier = model.fc
model.conv1[0] = Conv2d(self.in_channels,
conv.out_channels,
kernel_size=conv.kernel_size,
stride=conv.stride,
padding=conv.padding,
bias=conv.bias)
# todo inherit og 1st layer weights
model.fc = Linear(in_features=classifier.in_features,
out_features=self.out_classes,
bias=True)
return Sequential(model, Softmax(1)) if self.soft_max else model
def __init__(self, vocab_size, embedding_dim):
"""Initializes model layers.
Args:
vocab_size (int): Number of tokens in corpus. This is used to init embeddings.
embedding_dim (int): Dimension of embedding vector.
"""
super().__init__()
self._embedding_dim = embedding_dim
self.encoder_in = Encoder(vocab_size, embedding_dim)
self.encoder_out = Encoder(vocab_size, embedding_dim)
self.linear = Linear(embedding_dim, embedding_dim, bias=False)
self.similarity = CosineSimilarity(dim=2)
self.softmax = Softmax(dim=2)
def parse_activation(name):
if name in relu_names:
return ReLU()
if name in leaky_relu_names:
return LeakyReLU()
if name in sigmoid_names:
return Sigmoid()
if name in log_sigmoid_name:
return LogSigmoid()
if name in p_relu_names:
return PReLU()
if name in tanh_names:
return Tanh()
if name in softmax_names:
return Softmax(dim=1)
if name in log_softmax_names:
return LogSoftmax(dim=1)
def __init__(self,
in_channels: int,
num_classes: int,
class_type: str = "single"):
super().__init__()
self.avgpool = AdaptiveAvgPool2d(1)
self.fc = Linear(in_channels, num_classes)
if class_type == "single":
self.softmax = Softmax(dim=1)
elif class_type == "multi":
self.softmax = Sigmoid()
else:
raise ValueError(
"unknown class_type given of {}".format(class_type))
self.initialize()
def sample(model, text_field, prompt="", max_len=50, temp=1.0, k=0, p=1):
assert (k == 0 or p == 1), "Cannot combine top-k and top-p sampling"
hidden_size = model._modules['rnn'].hidden_size
n_layers = model._modules['rnn'].num_layers
h_t_prev = torch.zeros(n_layers, 1, hidden_size)
c_t_prev = torch.zeros(n_layers, 1, hidden_size)
w_t = text_field.process([text_field.tokenize(prompt.lower())])
sampling_criterion = Softmax(dim=1)
words = []
for i in range(max_len):
s_t, h_t, c_t = model(w_t, h_t_prev, c_t_prev)
w_t_next = sampling_criterion(s_t[-1] / temp)
if k != 0:
# Top-k Sampling
topk_vals, topk_indices = torch.topk(w_t_next, k)
topk_vals /= topk_vals.sum(dim=1)
prob_dist = Categorical(topk_vals)
w_t = topk_indices.view(-1)[prob_dist.sample()].unsqueeze(dim=0)
elif p > 0:
# Top-p Sampling
sorted_wts, sorted_indices = torch.sort(w_t_next, descending=True)
cumulative_probs = torch.cumsum(input=sorted_wts, dim=1).squeeze()
sorted_indices_to_remove = cumulative_probs > p
sorted_indices_to_remove[1:] = sorted_indices_to_remove[:-1].clone()
sorted_indices_to_remove[0] = 0
indices_to_remove = sorted_indices[sorted_indices_to_remove.unsqueeze(0)]
w_t_next.squeeze()[indices_to_remove] = 0
w_t_next /= w_t_next.sum()
prob_dist = Categorical(w_t_next)
w_t = prob_dist.sample().unsqueeze(0)
else:
# Vanilla and Temperature-Scaled Sampling
prob_dist = Categorical(w_t_next)
w_t = prob_dist.sample().unsqueeze(dim=0)
words.append(w_t)
h_t_prev = h_t
c_t_prev = c_t
decoded_string = prompt + " " + reverseNumeralize(torch.cat(words).squeeze(), text_field)
return decoded_string
def special_mario_downsampling(num_scales, scales, image, token_list):
"""
Special Downsampling Method designed for Super Mario Bros. Token based levels.
num_scales : number of scales the image is scaled down to.
scales : downsampling scales. Should be an array tuples (scale_x, scale_y) of length num_scales.
image : Original level to be scaled down. Expects a torch tensor.
token_list : list of tokens appearing in the image in order of channels from image.
"""
scaled_list = []
for sc in range(num_scales):
scale_v = scales[sc][0]
scale_h = scales[sc][1]
# Initial downscaling of one-hot level tensor is normal bilinear scaling
bil_scaled = interpolate(image, (int(image.shape[-2] * scale_v), int(image.shape[-1] * scale_h)),
mode='bilinear', align_corners=False)
# Init output level
img_scaled = torch.zeros_like(bil_scaled)
for x in range(bil_scaled.shape[-2]):
for y in range(bil_scaled.shape[-1]):
curr_h = 0
curr_tokens = [tok for tok in token_list if bil_scaled[:, token_list.index(tok), x, y] > 0]
for h in range(len(HIERARCHY)): # find out which hierarchy group we're in
for token in HIERARCHY[h].keys():
if token in curr_tokens:
curr_h = h
for t in range(bil_scaled.shape[-3]):
if not (token_list[t] in HIERARCHY[curr_h].keys()):
# if this token is not on the correct hierarchy group, set to 0
img_scaled[:, t, x, y] = 0
else:
# if it is, keep original value
img_scaled[:, t, x, y] = bil_scaled[:, t, x, y]
# Adjust level to look more like the generator output through a Softmax function.
img_scaled[:, :, x, y] = Softmax(dim=1)(30*img_scaled[:, :, x, y])
scaled_list.append(img_scaled)
scaled_list.reverse()
return scaled_list
def __init__(self,in_dim, device):
'''
Parameters
----------
in_dim : int
channels of input
device: torch.device
'''
super(CC_module, self).__init__()
self.query_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
self.key_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
self.value_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)
self.softmax = Softmax(dim=3)
self.INF = INF
self.gamma = nn.Parameter(torch.zeros(1)).to(device)
self.device = device
def get_possible_answers(question, context, n_ans):
p = Softmax(dim=0)
inputs = tokenizer_fast(question,
context,
truncation=True,
padding=True,
max_length=500,
return_tensors="pt")
input_ids = inputs["input_ids"].tolist()[0]
context_ids = np.array(input_ids)[np.array(inputs['token_type_ids'][0],
dtype=bool)]
text_tokens = tokenizer_fast.convert_ids_to_tokens(input_ids)
outputs = model(**inputs)
answer_start_scores = outputs.start_logits[0][torch.tensor(
inputs['token_type_ids'][0], dtype=bool)][:-1]
answer_end_scores = outputs.end_logits[0][torch.tensor(
inputs['token_type_ids'][0], dtype=bool)][:-1]
total_scores = np.array([[
float(answer_start_scores[i] + answer_end_scores[j])
for j in range(len(answer_start_scores))
] for i in range(len(answer_start_scores))])
possibles = []
possible_scores = []
i = 0
while (len(possibles) < n_ans) & (i < total_scores.shape[0]):
row, col = np.unravel_index(np.argsort(total_scores.ravel()),
total_scores.shape)
row, col = row[::-1], col[::-1]
start = row[i]
end = col[i]
if (end >= start) & (tokenizer_fast.convert_ids_to_tokens(context_ids[start:(start+1)])[0][0:2] != "##")&\
(tokenizer_fast.convert_ids_to_tokens(context_ids[(end+1):(end+2)])[0][0:2] != "##"):
score = torch.tensor(total_scores)[start, end]
answer = tokenizer_fast.convert_tokens_to_string(
tokenizer_fast.convert_ids_to_tokens(
context_ids[start:(end + 1)]))
if (len(answer) <= 100) & (1 -
("(" in answer) & ~(")" in answer)
) & (~(answer in possibles)):
possibles.append(answer)
possible_scores.append(score)
i += 1
possible_scores_prob = p(torch.tensor(possible_scores))
return possibles, possible_scores_prob
def __init__(self, n_inputs):
super(MLP, self).__init__()
# input to first hidden layer
self.hidden1 = Linear(n_inputs, 10)
kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
self.act1 = ReLU()
# second hidden layer
self.hidden2 = Linear(10, 8)
kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
self.act2 = ReLU()
# third hidden layer and output
self.hidden3 = Linear(8, 3)
xavier_uniform_(self.hidden3.weight)
self.act3 = Softmax(dim=1)
def visualize(pov,pred,label,prev_label,next_label):
y = Softmax(0)(pred.squeeze().detach())
width = 0.8
x = np.arange(len(aclist))
# y = np.random.sample(30)
## plotting
plt.rcdefaults()
# similar to tight_layout, but works better!
fig, (ax1, ax2) = plt.subplots(1, 2, constrained_layout=True)
rects1 = ax2.barh(x, y,height=width/4,label='logits')
y_ = np.zeros(30)
y_[label[0]] = 1
rects0 = ax2.barh(x-width/4, y_,label='label',height=width/4)
if prev_label != None:
y_ = np.zeros(30)
y_[prev_label[0]] = 1
ax2.barh(x+width / 4, y_,label='prev_label',height=width/4)
if next_label != None:
y_ = np.zeros(30)
y_[next_label[0]] = 1
ax2.barh(x-width/2, y_,label='next_label',height=width/4)
plt.xlim(0, 1)
ax1.imshow(pov.squeeze() / 255)
ax1.axis('off')
ax2.set_yticks(x)
ax2.set_yticklabels(aclist, fontsize=3)
ax2.tick_params(axis='x',labelsize=3,tickdir='in')
ax2.set_xlabel('softmaxed logits',fontsize = 3)
def __init__(self,
in_channels,
out_channels,
key_channels,
psp_size=(1, 4, 8, 16),
bn=False,
res=True,
v_conv_kernel=1):
super(NLPM, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.key_channels = key_channels
self.query_channels = key_channels
self.psp_size = psp_size
self.bn = bn
self.res = res
self.query_conv = nn.Conv2d(in_channels,
key_channels,
kernel_size=1,
bias=False)
self.key_conv = nn.Conv2d(in_channels,
key_channels,
kernel_size=1,
bias=False)
self.key_psp = PSPModule(sizes=psp_size)
self.value_conv = nn.Conv2d(in_channels,
out_channels,
kernel_size=v_conv_kernel,
padding=v_conv_kernel // 2,
bias=False)
self.value_psp = PSPModule(sizes=psp_size)
if bn:
self.query_bn = nn.BatchNorm2d(key_channels)
self.key_bn = nn.BatchNorm2d(key_channels)
print('Initing NLPM')
self.softmax = Softmax(dim=-1)
self.alpha = nn.Parameter(torch.zeros(1))
def valid_model(device, model, dataloader, criterion):
best_IOU = 0.0
step_message = "val_loss = {:6.4f}, val_IOU = {:6.4f} --- {:5.2f} ms/batch"
best_result_message = "-" * 30 + "\n" + \
"Best IOU : {:<6.4f}" + "\n" + \
"-" * 30
# container for IOU
# we only concern for road
iou_record = np.zeros(2, dtype=int)
running_loss = 0
since = time.time()
for i, datas in enumerate(dataloader):
images, labels = datas
images = images.to(device)
labels = labels.to(device)
# forward pass
outputs = model(images)
outputs = outputs.permute(0, 2, 3, 1).reshape(-1, 2)
labels = labels.permute(0, 2, 3, 1).reshape(-1, 2)
outputs = Softmax(dim=1)(outputs)
loss = criterion(outputs, labels)
pred = (outputs > 0.5)[:, 1].type(torch.uint8)
labels = (labels > 0.5)[:, 1].type(torch.uint8)
# pred correctly
iou_record[0] += torch.sum((pred == 0) & (labels == 0)).item()
# all gt pixel belongs to road and all pred pixel belongs to road
iou_record[1] += torch.sum(labels == 0).item() + torch.sum(
pred == 0).item()
running_loss += loss.item()
time_eplased = time.time()
iou = iou_record[0] / (iou_record[1] - iou_record[0])
print(step_message.format(running_loss, iou, (time_eplased - since) * 100))
iou = iou_record[0] / (iou_record[1] - iou_record[0])
if iou > best_IOU:
best_IOU = iou
# best_model_wts = copy.deepcopy(model.state_dict())
print(best_result_message.format(best_IOU))
def __init__(self, pretrained=True):
super().__init__()
self.conv1 = Conv2d(3, 10, kernel_size=3)
self.prelu1 = PReLU(10)
self.pool1 = MaxPool2d(2, 2, ceil_mode=True)
self.conv2 = Conv2d(10, 16, kernel_size=3)
self.prelu2 = PReLU(16)
self.conv3 = Conv2d(16, 32, kernel_size=3)
self.prelu3 = PReLU(32)
self.conv4_1 = Conv2d(32, 2, kernel_size=1)
self.softmax4_1 = Softmax(dim=1)
self.conv4_2 = Conv2d(32, 4, kernel_size=1)
self.training = False
if pretrained:
state_dict_path = os.path.join(os.path.dirname(__file__),
'pnet.pt')
state_dict = torch.load(state_dict_path)
self.load_state_dict(state_dict)
def __init__(self,
n_dim: int,
e_dim: int,
p_dim: int,
c_dim: int,
dropout=0.,
use_cuda=False):
super(MolGATMesPassing, self).__init__()
self.linear = Linear(n_dim + p_dim + n_dim, c_dim, bias=True)
self.linear_e = Linear(n_dim + p_dim + n_dim, e_dim, bias=True)
self.relu1 = LeakyReLU()
self.relu2 = LeakyReLU()
self.relu_e = LeakyReLU()
self.attention = Linear(e_dim + p_dim, 1, bias=True)
self.softmax = Softmax(dim=1)
self.elu = ELU()
self.dropout = Dropout(p=dropout)
self.use_cuda = use_cuda
def inference(self, image, path=True):
img = self.load_image(image, path)
self.model.eval()
print('predicting')
with torch.no_grad():
image_tensor = transforms.ToTensor()(img).unsqueeze_(0).to(
self.device)
output = self.model(image_tensor)
softmax_output = Softmax(dim=1)(output)
confidence, predicted_index = torch.max(softmax_output, 1)
predicted = self.index2label[int(predicted_index[0])]
if confidence < .5:
predicted = 'unknown firearm'
return float(confidence), predicted
def VGG(self, name='vgg16'):
model = getattr(models, name)(pretrained=self.pretrained)
conv = model.features[0]
classifier = model.classifier[-1]
model.features[0] = Conv2d(self.in_channels,
conv.out_channels,
kernel_size=conv.kernel_size,
stride=conv.stride,
padding=conv.padding)
model.features[0].bias.data = conv.bias
model.features[0].weight.data = conv.weight.mean(1).unsqueeze(
1) # inherit og 1st layer weights
model.classifier[-1] = Linear(in_features=classifier.in_features,
out_features=self.out_classes,
bias=True)
return Sequential(model, Softmax(1)) if self.soft_max else model
def __init__(self, in_dim, dropout=False):
# def __init__(self, in_dim, dropout=True): #20191217_2
super(PAM_Module, self).__init__()
self.channel_in = in_dim
t = int(abs(math.log(self.channel_in, 2) + 1) / 2)
self.k = t if t % 2 else t + 1
self.query_conv = Conv1d(in_channels=1,
out_channels=1,
kernel_size=self.k,
padding=int(self.k / 2),
bias=False)
self.key_conv = Conv1d(in_channels=1,
out_channels=1,
kernel_size=self.k,
padding=int(self.k / 2),
bias=False)
# self.value_conv = Conv1d(in_channels=1, out_channels=1, kernel_size=self.k, padding=int(self.k/2), bias=False)
# self.query_conv = Conv2d(in_channels=in_dim, out_channels=in_dim // 8, kernel_size=1)
# self.key_conv = Conv2d(in_channels=in_dim, out_channels=in_dim // 8, kernel_size=1)
self.value_conv = Conv2d(in_channels=in_dim,
out_channels=in_dim,
kernel_size=1) #20191212_3
# self.res_conv = Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1) #20191215_2
self.gamma = Parameter(torch.zeros(1))
# self.gamma = Parameter(torch.zeros(1)) 20191212_2
self.softmax = Softmax(dim=-1)
self.bn = nn.BatchNorm2d(in_dim)
if dropout:
# self.dropout = nn.Dropout(0.3) # 20191215_1
self.dropout = nn.Dropout(0.1) # 20191216_3
if dropout:
self.is_dropout = True
else:
self.is_dropout = False
# self.scale = torch.sqrt(torch.FloatTensor([in_dim // 8])) #20191212_4
self._init_param()
def __init__(self, output_dim=10, dropout=0.5):
super(MLP, self).__init__()
#These are encoder layers
self.encoders = []
#Layer Sizes
self.ls = [784, 1000, 500, 250, 250, 250]
n_layers = len(ls) #6
for i in xrange(n_layers - 1):
self.encoders[i] = Sequential()
self.encoders[i].add_module('l_{}'.format(i),
Linear(self.ls[i], self.ls[i + 1]))
#*** eps, momentum are default nonzero, torch imp sets both to 0
#*** affine default to true giving learnable params, torch imp sets to false
#self.encoders[i].add_module('bn_{}'.format(i), BatchNorm1d(self.ls[i+1], ))
self.encoders[i].add_module(
'bn_{}'.format(i), BatchNorm1d(self.ls[i + 1], 0.0, 0.0,
False))
self.encoders[i].add_module('relu_{}'.format(i), ReLU())
self.encoders[n_layers] = Sequential()
self.encoders[n_layers].add_module(
'l_n', Linear(self.ls[n_layers], output_dim))
#*** eps, momentum are default nonzero, torch imp doesn't set to 0 in last layer
#*** affine default to true giving learnable params, torch imp leaves it as true
#self.encoders[n_layers].add_module('bn_n', BatchNorm1d(output_dim))
self.encoders[n_layers].add_module(
'bn_n', BatchNorm1d(output_dim, 0.0, 0.0, False))
self.encoders[n_layers].add_module('relu_{}', ReLU())
#***This may have to be it's own sequential...unsure
# TODO: Use LogSoftmax because we have to use Negative Log Likelihood
self.encoders[n_layers].add_module('softmax', Softmax())
#***Need decoder layers here
self.decoders = [] #Should also be 6
#***Do something unique for last layer, then can loop through
self.decoders[n_layers - 1] = Sequential()
#self.decoders[n_layers-1].add_module(
#self.decoders[n_layers-1].add_module(
#4,3,2,1
for i in xrange(n_layers - 2, 0, -1):
self.decoders[i] = Sequential()
def __init__(self, token_embedder, hidden_dim, input_dim, agenda_dim,
num_layers):
super(MultilayeredDecoderCell, self).__init__()
self.linear = Linear(hidden_dim, input_dim)
self.h0 = Parameter(torch.zeros(hidden_dim))
self.c0 = Parameter(torch.zeros(hidden_dim))
self.softmax = Softmax()
self.token_embedder = token_embedder
self.num_layers = num_layers
self.rnn_cells = []
for layer in range(num_layers):
in_dim = (
input_dim + agenda_dim
) if layer == 0 else hidden_dim # inputs to first layer are word vectors
out_dim = hidden_dim
rnn_cell = LSTMCell(in_dim, out_dim)
self.add_module('decoder_layer_{}'.format(layer), rnn_cell)
self.rnn_cells.append(rnn_cell)
def __init__(self, n_channels):
super(CNN, self).__init__()
self.hidden1 = Conv2d(n_channels, 32, (3, 3))
kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
self.act1 = ReLU()
self.pool1 = MaxPool2d((2, 2), stride=(2, 2))
self.hidden2 = Conv2d(32, 32, (3, 3))
kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
self.act2 = ReLU()
self.pool2 = MaxPool2d((2, 2), stride=(2, 2))
self.hidden3 = Linear(5 * 5 * 32, 100)
kaiming_uniform_(self.hidden3.weight, nonlinearity='relu')
self.act3 = ReLU()
self.hidden4 = Linear(100, 10)
xavier_uniform_(self.hidden4.weight)
self.act4 = Softmax(dim=1)
def __init__(self, args):
super(AttentionMILFeatures, self).__init__()
width_fe = is_in_args(args, 'width_fe', 64)
self.feature_extractor = Sequential(
Linear(args.feature_depth, width_fe), ReLU(),
Dropout(p=args.dropout), Linear(width_fe, width_fe), ReLU(),
Dropout(p=args.dropout))
self.weight_extractor = Sequential(
Linear(width_fe, int(width_fe / 2)),
Tanh(),
Linear(int(width_fe / 2), 1),
Softmax(dim=-2) # Softmax sur toutes les tuiles. somme à 1.
)
self.classifier = Sequential(
Linear(width_fe, int(width_fe / 2)),
ReLU(), # Added 25/09
Dropout(p=args.dropout), # Added 25/09
Linear(int(width_fe / 2), 1), # Added 25/09
Sigmoid())
def __GenerateSequence(self, input_nodes, hidden_nodes, output_nodes):
"""
* Generate layers for neural network.
"""
self.__inputsize = input_nodes
self.__outputsize = output_nodes
layers = []
for num, hidden_dim in enumerate(hidden_nodes):
if num == 0:
layers.append(Linear(input_nodes, hidden_dim))
else:
layers.append(Linear(hidden_nodes[num - 1], hidden_dim))
layers.append(Linear(hidden_dim, output_nodes))
sequence = []
for layer in layers:
sequence.append(layer)
sequence.append(Sigmoid())
sequence.append(Softmax())
return sequence
def main(batch_size, data_full_path, dtype, num_batches, pdf_name):
sm = Softmax(dim=0)
data_manager = DataManager(data_full_path=data_full_path,
data_set_cls=AttackedDataset)
dl = data_manager.get_data_loader(batch_size=batch_size)
with PdfPages(pdf_name) as pdf:
for iter_num, (inputs, labels, init_outputs, perturbed_outputs) \
in enumerate(dl, 0):
if iter_num >= num_batches:
break
n_cols = int(np.sqrt(batch_size))
n_rows = int(np.ceil(batch_size / n_cols))
# make grid, plots
gs = plt.GridSpec(n_rows, n_cols)
for evt, img_tnsr in enumerate(inputs):
# color codes
# * green if prediction is correct and adv fails
# * red if prediction is wrong and adv doesn't flip
# * blue if prediction is correct and adv flips
# * black if prediction is wrong and adv doesn't flip
adv_swp = torch.argmax(init_outputs[evt]) == \
torch.argmax(perturbed_outputs[evt])
init_pred_correct = torch.argmax(init_outputs[evt]) == \
labels[evt]
color = 'k'
if init_pred_correct and adv_swp:
color = 'g'
if init_pred_correct and (not adv_swp):
color = 'b'
if (not init_pred_correct) and (not adv_swp):
color = 'r'
titlestr = data_manager.label_names[labels[evt]] + '\n' + \
str(sm(init_outputs[evt]).numpy()) + ' atk-> ' + \
str(sm(perturbed_outputs[evt]).numpy())
ax = plt.subplot(gs[evt])
ax.axis('on')
ax.xaxis.set_major_locator(plt.NullLocator())
ax.yaxis.set_major_locator(plt.NullLocator())
_ = ax.imshow(
np.moveaxis(img_tnsr.numpy().astype(dtype), 0, -1))
plt.title(titlestr, fontsize=6, color=color)
# plt.tight_layout()
pdf.savefig()
def __init__(self, ):
super(GCN, self).__init__()
self.size = 128
self.in_features = 600
self.l1 = GraphLinearEmbedding(self.in_features,
self.size,
with_bn=False,
with_act_func=True)
# self.dropout1 = Dropout(p = 0.5)
self.gc1 = GraphConvolution(self.size, self.size*4, 4, with_bn = False, \
with_act_func = True)
# self.dropout2 = Dropout(p = 0.5)
self.gc2 = GraphConvolution(self.size*4, self.size*8, 4, with_bn = False, \
with_act_func = True)
# self.dropout3 = Dropout(p = 0.5)
# # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~```
self.gc6 = GraphConvolution(self.size*8, self.size*4, 4, with_bn = False, \
with_act_func = True)
self.gc7 = GraphConvolution(self.size*4, self.size, 4, with_bn = False, \
with_act_func = True)
# # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
self.l3 = GraphLinearEmbedding(self.size, self.size * 4, with_bn=False)
self.gc3 = GraphConvolution(self.size*4, self.size*8, 4, with_bn = False, \
with_act_func = True)
self.gc4 = GraphConvolution(self.size*8, self.size*4, 4, with_bn = False, \
with_act_func = True)
self.gc5 = GraphConvolution(self.size*4, self.size, 4, with_bn = False, \
with_act_func = True)
self.l2 = GraphLinearEmbedding(self.size,
5,
with_bn=False,
with_act_func=True)
self.softmax = Softmax(-1)
self.criterion = torch.nn.CrossEntropyLoss()
