def test_rnn_bidirectional():
hidden_size = 20
input_size = 10
seq_len = 5
batch_size = 7
for bias in (True, False):
for batch_first in (True, False):
input = var(T.randn(batch_size, seq_len,
input_size)) if batch_first else var(
T.randn(seq_len, batch_size, input_size))
hx = None
rnn = SubLSTM(input_size,
hidden_size,
num_layers=3,
bias=bias,
batch_first=batch_first,
bidirectional=True)
outputs = []
for i in range(6):
output, hx = rnn(input, hx)
outputs.append(output)
T.stack(outputs).sum().backward()
assert hx[-1][-1][0].size() == T.Size([batch_size, hidden_size])
assert hx[-1][-1][1].size() == T.Size([batch_size, hidden_size])
def fit(model, train_loader, test_loader, learning_rate, epochs):
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
for e in range(epochs):
correct = 0
for batch_idx, (X_batch, y_batch) in enumerate(train_loader):
var_X_batch = var(X_batch).float()
var_y_batch = var(y_batch).float()
output = model(var_X_batch)
loss = criterion(output, var_y_batch)
optimizer.zero_grad()
loss.backward()
optimizer.step()
pred = [1 if i > 0.5 else 0 for i in output]
for i in range(len(pred)):
if int(pred[i]) == int(var_y_batch[i]): correct += 1
if batch_idx % 20 == 0:
print(
'Epoch : {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\t Accuracy:{:.3f}%'
.format(
e, batch_idx * len(X_batch), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.data[0],
float(correct * 100) / float(var_y_batch.shape[0] *
(batch_idx + 1))))
print()
evaluate(model, test_loader, 32)
def generate_data(batch_size, bits=7, cuda=-1):
max_N = 2**(bits - 1) + 1
N = np.random.randint(1, max_N)
k = np.random.randint(1, N + 1)
input_data = np.zeros((batch_size, N + 3 + k + 1, bits + 2),
dtype=np.float32)
target_output = np.zeros((batch_size, N + 3 + k + 1, bits + 2),
dtype=np.float32)
for i in range(batch_size):
inp_sequence, sorted_top_k = get_example(N, k, bits)
input_data[i, :N, :bits] = inp_sequence
target_output[i, N + 3:N + 3 + k, :bits] = sorted_top_k
input_data[i, N + 1, :bits] = get_bit_sequence(np.array([k]), bits)
input_data[:, N, -2] = 1
input_data[:, N + 2, -1] = 1
target_output[:, N + 3 + k, -1] = 1
input_data = T.from_numpy(input_data)
target_output = T.from_numpy(target_output)
if cuda != -1:
input_data = input_data.cuda(cuda)
target_output = target_output.cuda(cuda)
return var(input_data), var(target_output)
def generate_data(
batch_size, total_length, input_length, npy_idx,
base_path='/home/kaji/data/frames_cleanpass/np_out/',
cuda=-1, loop_mode=False):
if loop_mode:
flag_list = [2] * total_length
else:
flag_list = [1] * total_length
for i in range(input_length):
flag_list[i] = 0
if input_length < total_length:
flag_list[input_length] = 1
npy_path = base_path + str(npy_idx) + ".npy"
npy_values = np.load(npy_path)
input_data = []
target_output = []
for i in range(batch_size):
start_idx = random.randrange(0, len(npy_values)-total_length-3)
in_data = npy_values[start_idx:start_idx+total_length]
out_data = npy_values[(start_idx+1):(start_idx+1)+total_length]
input_data.append(in_data)
target_output.append(out_data)
input_data = np.stack(input_data, axis=0).astype("float32")
target_output = np.stack(target_output, axis=0).astype("float32")
input_data = T.from_numpy(input_data)
target_output = T.from_numpy(target_output)
if cuda != -1:
input_data = input_data.cuda()
target_output = target_output.cuda()
return var(input_data), var(target_output), flag_list
def init_params(self, bs=None):
"""
if self.cell_type == "LSTM":
self.hidden_c = (self.init_hidden(bs), self.init_hidden(bs))
self.hidden_q = (self.init_hidden(bs), self.init_hidden(bs))
self.hidden_coatt = (self.init_hidden_coatt(
bs), self.init_hidden_coatt(bs))
self.hidden_bmod1 = (self.init_hidden_bmod(bs),
self.init_hidden_bmod(bs))
"""
if self.cell_type == "GRU":
self.hidden_c, self.hidden_q = self.init_hidden(
bs), self.init_hidden(bs)
self.hidden_coatt = self.init_hidden_coatt(bs)
self.hidden_bmod1 = self.init_hidden_bmod(bs)
else:
raise TypeError("Invalid Cell Type - use LSTM or GRU")
if torch.cuda.is_available():
self.beta = var(
torch.ones((
bs,
self.c_size,
)) * (1 / self.c_size)).cuda()
else:
self.beta = var(
torch.ones((
bs,
self.c_size,
)) * (1 / self.c_size))
def train(net, trainloader, trainset, criterian):
'''Training the network
'''
learning_rate = 1e-3
epoches = 200
#optimizer = optim.SGD(net.parameters(), lr=learning_rate);
optimizer = optim.Adam(net.parameters())
for iteration in range(epoches):
running_loss = 0
running_acc = 0
for (img, label) in trainloader:
img = var(img).cuda()
label = var(label).cuda()
# forward pass
optimizer.zero_grad()
output = net(img)
loss = criterian(output, label)
# backward pass and update the net
loss.backward()
optimizer.step()
# compute the training loss and training Accuracy
running_loss += loss.data[0]
_, predict = torch.max(output, 1)
correct_num = (predict == label).sum()
running_acc += correct_num.data[0]
#end_for
running_loss /= len(trainset)
running_acc /= len(trainset)
print('Train[%d / %d] loss: %.5f, Acc: %.2f' %
(iteration + 1, epoches, running_loss, 100 * running_acc))
def __getitem__(self, idx):
imgstr = self.imgstrs[idx]
img1str = os.path.join(self.readdir, imgstr)
img2str = os.path.join(self.readdir, imgstr[:-6] + '_R.bmp')
corder = 0
if corder == 0 or self.transform is None:
img1 = cv2.imread(img1str)
img2 = cv2.imread(img2str)
else:
img1 = cv2.imread(img2str)
img2 = cv2.imread(img1str)
img3 = cv2.imread(os.path.join(self.readdir, imgstr[:-6] + '_M.bmp'))
img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB).astype(np.float32)
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB).astype(np.float32)
img3 = cv2.cvtColor(img3, cv2.COLOR_BGR2RGB).astype(np.float32)
if self.transform is not None:
# random shift and crop
cropx = random.randint(2, 20)
cropy = random.randint(2, 20)
shift = random.randint(0, 2)
ifx = random.randint(0, 1)
shiftx = 0
shifty = 0
img3 = img3[cropy:cropy + 128, cropx:cropx + 128, :]
img1 = img1[cropy - shifty:cropy + 128 - shifty,
cropx - shiftx:cropx + 128 - shiftx, :]
img2 = img2[cropy + shifty:cropy + 128 + shifty,
cropx + shiftx:cropx + 128 + shiftx, :]
flipH = random.randint(0, 1)
flipV = random.randint(0, 1)
if flipH == 1:
img1 = np.flip(img1, 0)
img2 = np.flip(img2, 0)
img3 = np.flip(img3, 0)
if flipV == 1:
img1 = np.flip(img1, 1)
img2 = np.flip(img2, 1)
img3 = np.flip(img3, 1)
# Then prepare for the RGB2GRAY
img1 = (
cv2.cvtColor(img2, cv2.COLOR_RGB2GRAY).astype(np.float32) -
cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY).astype(np.float32)).reshape(
[img2.shape[0], img2.shape[1], 1])
# IPython.embed()
# exit()
# Finish te transfer from RGB to GRAY, and img1 is no longer needed
# I have to note that for PIL, what we get is RGB, but in cv2, what we get is BGR
return var(torch.from_numpy(img1.transpose(2,0,1).astype(np.float32) / 255.0)), var(torch.from_numpy(img2.transpose(2,0,1).astype(np.float32) / 255.0)), \
var(torch.from_numpy(img3.transpose(2,0,1).astype(np.float32) / 255.0))
def evaluate(model, test_loader, batch_size):
correct = 0
for test_imgs, test_labels in test_loader:
test_imgs = var(test_imgs).float()
var_y_batch = var(test_labels).float()
output = model(test_imgs)
pred = [1 if i > 0.5 else 0 for i in output]
for i in range(len(pred)):
if int(pred[i]) == int(var_y_batch[i]): correct += 1
print("Test accuracy:{:.3f}% ".format(float(correct) * 100 / 5000))
def __getitem__(self, idx):
imgstr = self.imgstrs[idx]
imgs = []
for i in range(7):
fname = os.path.join(self.readdir, imgstr, 'im%d.png' % (i + 1))
imgs.append(np.array(pilImg.open(fname)))
if self.transform is not None:
# random shift and crop
cropx = random.randint(2, 100)
cropy = random.randint(2, 100)
for i in range(7):
imgs[i] = imgs[i][cropy:cropy + 128, cropx:cropx + 128, :]
flipH = random.randint(0, 1)
flipV = random.randint(0, 1)
if flipH == 1:
for i in range(7):
imgs[i] = np.flip(imgs[i], 0)
if flipV == 1:
for i in range(7):
imgs[i] = np.flip(imgs[i], 1)
return [
var(
torch.from_numpy(
tmpimg.transpose(2, 0, 1).astype(np.float32) / 255.0))
for tmpimg in imgs
]
def forward(self, word_index_list):
assert len(word_index_list) == self.batch_size
lookup_block = torch.LongTensor(word_index_list)
lookup_block = var(lookup_block, requires_grad=False)
if use_cuda: lookup_block = lookup_block.cuda()
assert lookup_block.size() == (self.batch_size, max_words)
sent_block = self.W_wrd(lookup_block).transpose(1,2)
assert sent_block.size() == (self.batch_size, self.d_wrd, max_words)
sent_block = sent_block.contiguous()
input_to_conv = sent_block.view(self.batch_size, 1, self.d_wrd, max_words)
x1 = F.relu(self.word_level_conv(input_to_conv))
assert x1.size() == (self.batch_size, self.clu1, 1, max_words)
y1 = x1.view(self.batch_size, self.clu1, max_words)
y2 = self.word_level_maxpool(y1)
assert y2.size() == (self.batch_size,self.clu1,1)
y2 = y2.view(self.batch_size, self.clu1)
if self.use_dropout:
y2 = self.dropout(y2)
if self.hlu == 0:
y2 = self.fc1(y2)
else:
y2 = F.relu(self.fc1(y2))
y2 = self.fc2(y2)
assert y2.size() == (self.batch_size, self.num_classes)
return y2
def RunSingleTest(net):
img = im.open(args.single)
if args.tencrop:
img = img.resize((256, 256), im.LANCZOS)
img = tv.transforms.TenCrop((224, 224))(img)
img = torch.stack(
[normalize(tv.transforms.ToTensor()(crop)) for crop in img])
else:
img = img.resize((224, 224), im.LANCZOS)
img = normalize(tv.transforms.ToTensor()(img))
img = var(img.view(1, *img.shape))
if not args.cpu:
img = img.cuda()
if args.tencrop:
bs, ncrops, c, h, w = img.size()
img = img.view(-1, c, h, w)
ret = net(img)
if args.tencrop:
ret = ret.view(bs, ncrops, -1).mean(1)
utils.WriteSinglePred(ret, sys.stdout, args.csv)
if args.output_file is not None:
with open(args.output_file, 'w') as f:
utils.WriteSinglePred(ret, f, args.csv)
def forward(self, source, target, source_lengths, target_lengths):
attentions = []
encoded, hidden = self.encoder(source, source_lengths)
hidden = tuple([h[:self.decoder.n_layers] for h in hidden])
batch_size = len(source)
outputs = cuda(T.zeros(batch_size, max(target_lengths),
self.decoder.output_size),
gpu_id=self.gpu_id)
# todo: use tensor instead of numpy
input = cudavec(np.array([SOS] * batch_size, dtype=np.long),
gpu_id=self.gpu_id).unsqueeze(1)
# manually unrolled
for x in range(max(target_lengths)):
o, hidden, att = self.decoder(input, encoded, hidden)
outputs[:, x, :] = o
attentions.append(att.data.cpu().numpy())
if self._teacher_force():
input = target[:, x].unsqueeze(1).long()
else:
input = var(o.data.topk(1)[0].squeeze(1).long())
return outputs, np.array(attentions)
def forward(self,
source,
target,
source_lengths,
target_lengths,
hidden=None):
attentions = []
encoded, controller_hidden = self.controller(source, source_lengths,
hidden)
# the encoder LSTM's last hidden layer
hidden = tuple(
[h[:self.decoder.n_layers] for h in controller_hidden[0]])
batch_size = len(source)
outputs = cuda(T.zeros(batch_size, max(target_lengths),
self.decoder.output_size),
gpu_id=self.gpu_id)
input = cuda(T.LongTensor([SOS] * batch_size),
gpu_id=self.gpu_id).unsqueeze(1)
# manually unrolled
for x in range(max(target_lengths)):
o, hidden, att = self.decoder(input, encoded, hidden)
outputs[:, x, :] = o
# attentions.append(att.data.cpu().numpy())
if self._teacher_force():
input = target[:, x].unsqueeze(1).long()
else:
input = var(o.data.topk(1)[0].squeeze(1).long())
return outputs, np.array(attentions), controller_hidden
def test_dnc_rnn():
input = var(T.randn(10, 50, 64))
model = DNC('RNN', 64, num_layers=1, mem_size=5, read_heads=2, gpu_id=-1)
o, h = model(input)
assert o.size() == input.size()
def read_from_sparse_memory(self, memory, indexes, keys, least_used_mem, usage):
b = keys.size(0)
read_positions = []
# we search for k cells per read head
for batch in range(b):
distances, positions = indexes[batch].search(keys[batch])
read_positions.append(positions)
read_positions = T.stack(read_positions, 0)
# add least used mem to read positions
# TODO: explore possibility of reading co-locations or ranges and such
(b, r, k) = read_positions.size()
read_positions = var(read_positions).squeeze(1).view(b, -1)
# no gradient here
# temporal reads
(b, m, w) = memory.size()
# get the top KL entries
max_length = int(least_used_mem[0, 0].data.cpu().numpy()) if not self.mem_limit_reached else (m-1)
# differentiable ops
# append forward and backward read positions, might lead to duplicates
read_positions = T.cat([read_positions, least_used_mem], 1)
read_positions = T.clamp(read_positions, 0, max_length)
visible_memory = memory.gather(1, read_positions.unsqueeze(2).expand(b, self.c, w))
read_weights = σ(θ(visible_memory, keys), 2)
read_vectors = T.bmm(read_weights, visible_memory)
read_weights = T.prod(read_weights, 1)
return read_vectors, read_positions, read_weights, visible_memory
def WritePred(net, t_loader, filename, cuda=True, tencrop=False, out_arr=None):
assert t_loader.batch_size == 1
with open(filename, 'w') as f:
tl = len(t_loader)
idx = 0
for data in tqdm(t_loader, file=sys.stdout):
in_img = var(data)
if cuda:
in_img = in_img.cuda()
if tencrop:
bs, ncrops, c, h, w = in_img.size()
in_img = in_img.view(-1, c, h, w)
ret = net(in_img)
if tencrop:
ret = ret.view(bs, ncrops, -1).mean(1)
_, p3 = torch.topk(ret, 3)
p3 = p3.view(-1).cpu().data.numpy()
print('test/' + t_loader.dataset.getName(idx),
p3[0],
p3[1],
p3[2],
file=f)
if out_arr is not None:
out_arr.append([p3[0], p3[1], p3[2]])
idx += 1
def generate_data(batch_size, bits=6, cuda=-1):
n = np.random.randint(10, 25 + 1)
sample_edges = []
sample_queries = []
sample_shortest_paths = []
sample_lengths = []
for i in range(batch_size):
edges, query, shortest_paths, length_of_shortest_path = construct_example(
n, bits)
sample_edges.append(edges)
sample_queries.append(query)
sample_shortest_paths.append(shortest_paths)
sample_lengths.append(length_of_shortest_path)
m = sample_edges[0].shape[0] // 2
# print("m",m)
length = m + 1 + 1 + 1 + np.max(
sample_lengths) + 1 # edges + eoe + query + eoq + output + eoo
size = 2 * bits + 2
input_data = np.zeros((batch_size, length, size), dtype=np.float32)
for i in range(batch_size):
input_data[i, :m, :bits] = sample_edges[i][::2]
input_data[i, :m, bits:2 * bits] = sample_edges[i][1::2]
input_data[i, m + 1, :bits] = sample_queries[i][0]
input_data[i, m + 1, bits:2 * bits] = sample_queries[i][1]
input_data[:, m, -2] = 1
input_data[:, m + 2, -1] = 1
def target_output(actual_output):
actual_output = actual_output.cpu().detach().numpy()
target_array = np.zeros((batch_size, length, size), dtype=np.float32)
for i in range(batch_size):
# find closest target output
curr_output = actual_output[i,
m + 3:m + 3 + sample_lengths[i], :-2]
# print("sample_lengths[i]",sample_lengths[i])
curr_targets = sample_shortest_paths[i].reshape(
(len(sample_shortest_paths[i]), -1, 2 * bits))
# print("curr_output",curr_output)
# print("curr_targets",curr_targets)
best_target = np.argmin(
np.sum(np.abs(curr_targets - curr_output), axis=(1, 2)))
best_target = curr_targets[best_target]
# constrct target array
target_array[i, m + 3:m + 3 + sample_lengths[i], :-2] = best_target
target_array[i, m + 3 + sample_lengths[i]:, -1] = 1
target_array = T.from_numpy(target_array)
if cuda != -1:
target_array = target_array.cuda(cuda)
return var(target_array)
input_data = T.from_numpy(input_data)
if cuda != -1:
input_data = input_data.cuda(cuda)
return var(input_data), target_output
def init_hidden_coatt(self, bs=None): # for context_attention GRU
weight_scale = 0.01
if bs is None:
bs = self.batch_size
weight = next(self.parameters()).data
return var(
weight.new(self.n_layers * self.dirs, bs,
self.hidden_size * 2 * self.dirs)).zero_()
def init_hidden_bmod(self, bs=None):
weight_scale = 0.01
if bs is None:
bs = self.batch_size
weight = next(self.parameters()).data
return var(weight.new(self.n_layers, bs,
self.hidden_size)) \
.uniform_(-weight_scale, weight_scale)
def test_vision():
vgg = SimpleVGG(128)
res = SimpleResNet()
x = var(torch.rand(8, 3, 256, 256))
assert vgg(x).size() == (8, 128, 32, 32)
assert res(x).size() == (8, 128, 32, 32)
def test_multilayer_dnc_lstm():
input = var(T.randn(10, 50, 64))
model = DNC('LSTM', 64, num_layers=4, mem_size=5, read_heads=4, gpu_id=-1)
o, h = model(input)
assert o.size() == input.size()
def generate_data(batch_size, length, size, device):
input_data = np.zeros((batch_size, 2 * length + 1, size), dtype=np.float32)
target_output = np.zeros(
(batch_size, 2 * length + 1, size), dtype=np.float32)
sequence = np.random.binomial(1, 0.5, (batch_size, length, size - 1))
input_data[:, :length, :size - 1] = sequence
input_data[:, length, -1] = 1 # the end symbol
target_output[:, length + 1:, :size - 1] = sequence
input_data = T.from_numpy(input_data)
target_output = T.from_numpy(target_output)
input_data = input_data.to(device)
target_output = target_output.to(device)
return var(input_data), var(target_output)
def test_cell():
hidden_size = 20
input_size = 10
for bias in (True, False):
input = var(T.randn(3, input_size))
hx = var(T.randn(3, hidden_size))
cx = var(T.randn(3, hidden_size))
cell = SubLSTMCell(input_size, hidden_size, bias=bias)
for i in range(6):
(hx, cx) = cell(input, (hx, cx))
hx.sum().backward()
assert hx.size() == T.Size([3, hidden_size])
assert cx.size() == T.Size([3, hidden_size])
def test_cell():
hidden_size = 20
input_size = 10
for bias in (True, False):
input = var(T.randn(3, input_size))
hx = var(T.randn(3, hidden_size))
cx = var(T.randn(3, hidden_size))
cell = SubLSTMCell(input_size, hidden_size, bias=bias)
for i in range(6):
(hx, cx) = cell(input, (hx, cx))
hx.sum().backward()
assert hx.size() == T.Size([3, hidden_size])
assert cx.size() == T.Size([3, hidden_size])
def __getitem__(self, idx):
imgstr = self.imgstrs[idx]
img1str = os.path.join(self.readdir, imgstr)
img2str = os.path.join(self.readdir, imgstr[:-6] + '_R.bmp')
corder = 0
if corder == 0 or self.transform is None:
img1 = np.array(pilImg.open(img1str))
img2 = np.array(pilImg.open(img2str))
else:
img1 = np.array(pilImg.open(img2str))
img2 = np.array(pilImg.open(img1str))
img3 = np.array(
pilImg.open(os.path.join(self.readdir, imgstr[:-6] + '_M.bmp')))
if self.transform is not None:
# random shift and crop
cropx = random.randint(2, 20)
cropy = random.randint(2, 20)
shift = random.randint(0, 2)
ifx = random.randint(0, 1)
shiftx = 0
shifty = 0
img3 = img3[cropy:cropy + 128, cropx:cropx + 128, :]
img1 = img1[cropy - shifty:cropy + 128 - shifty,
cropx - shiftx:cropx + 128 - shiftx, :]
img2 = img2[cropy + shifty:cropy + 128 + shifty,
cropx + shiftx:cropx + 128 + shiftx, :]
flipH = random.randint(0, 1)
flipV = random.randint(0, 1)
if flipH == 1:
img1 = np.flip(img1, 0)
img2 = np.flip(img2, 0)
img3 = np.flip(img3, 0)
if flipV == 1:
img1 = np.flip(img1, 1)
img2 = np.flip(img2, 1)
img3 = np.flip(img3, 1)
return var(torch.from_numpy(img1.transpose(2,0,1).astype(np.float32) / 255.0)), var(torch.from_numpy(img2.transpose(2,0,1).astype(np.float32) / 255.0)), \
var(torch.from_numpy(img3.transpose(2,0,1).astype(np.float32) / 255.0))
def test(net, testset, testloader, criterian, batch_size, n_class, log_file):
'''Testing the network
'''
net.eval()
testloss, testacc = 0., 0.
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
for (img, label) in testloader:
img = var(img).cuda()
label = var(label).cuda()
#forward pass
output = net(img)
#loss
loss = criterian(output, label)
testloss += loss.data[0]
#prediction
_, predict = torch.max(output, 1)
num_correct = (predict == label).sum()
testacc += num_correct.data[0]
#
c = (predict == label).squeeze()
for i in range(batch_size):
l = label[i].data[0]
class_correct[l] += c[i].data[0]
class_total[l] += 1
#end_for
#end_for
testloss /= len(testset)
testacc /= len(testset)
f = open(log_file, 'a')
f.write('\n-------------------\n')
print("Test: Loss: %.5f, Acc: %.2f %%" % (testloss, 100 * testacc))
f.write("Test: Loss: %.5f, Acc: %.2f %%\n" % (testloss, 100 * testacc))
for i in range(10):
print('Accuracy of %5d : %2d %%' %
(i, 100 * class_correct[i] / class_total[i]))
f.write('Accuracy of %5d : %2d %%\n' %
(i, 100 * class_correct[i] / class_total[i]))
#end_for
f.close()
def pim(im):
val_tfm = Compose([
tsfms.Resize(256),
tsfms.CenterCrop(256),
tsfms.Normalize((0.48, 0.225), mode='meanstd'),
tsfms.ToTensor()
])
imt = val_tfm(im)
imb = imt.unsqueeze(0)
imb = var(imb.cuda(), requires_grad=True)
return imb
def test_memory():
ξ = var(T.randn(64, 32))
# ξ = var(T.randn(64, (32 * 4) + (3 * 32) + (5 * 4) + 3))
n = Memory(32)
hx = n.reset(64)
v, hx = n(ξ, hx)
assert v.size() == T.Size([64, 32, 4])
v1, hx = n(ξ, hx)
assert v1.size() == T.Size([64, 32, 4])
def ig_grad(im, model, base, steps=50):
try:
print(pim(im).size)
score = F.softmax(model.forward(pim(im)))
print(score[0][1].data.cpu())
sc = score[0][1].data.cpu()[0]
if sc < 1:
sample_batch, step = gen_ten(im, base, steps)
sample_batch = var(sample_batch.data, requires_grad=True)
sample_out = F.softmax(model.forward(sample_batch))
crit = get_crit()
sample_loss = crit(sample_out,
var(torch.ones((steps)).long().cuda()))
sample_loss.backward()
sample_grad = sample_batch.grad * step
return (True, sample_grad.sum(0))
else:
return (False, None)
except Exception as e:
print(e)
def validate(model,data):
# To get validation accuracy = (correct/total)*100.
total = 0
correct = 0
for i,(images,labels) in enumerate(data):
images = var(images.cuda())
x = model(images)
value,pred = torch.max(x,1)
pred = pred.data.cpu()
total += x.size(0)
correct += torch.sum(pred == labels)
return correct*100./total
def test_function():
hidden_size = 20
input_size = 10
for bias in (True, False):
weight_ih = T.nn.Parameter(T.Tensor(4 * hidden_size, input_size))
weight_hh = T.nn.Parameter(T.Tensor(4 * hidden_size, hidden_size))
bias_ih = T.nn.Parameter(T.Tensor(4 * hidden_size)) if bias else None
bias_hh = T.nn.Parameter(T.Tensor(4 * hidden_size)) if bias else None
input = var(T.randn(3, input_size))
hx = var(T.randn(3, hidden_size))
cx = var(T.randn(3, hidden_size))
cell = SubLSTMCellF
for i in range(6):
hx, cx = cell(input, (hx, cx), weight_ih, weight_hh, bias_ih, bias_hh)
hx.sum().backward()
assert hx.size() == T.Size([3, hidden_size])
assert cx.size() == T.Size([3, hidden_size])
def test_rnn_bidirectional():
hidden_size = 20
input_size = 10
seq_len = 5
batch_size = 7
for bias in (True, False):
for batch_first in (True, False):
input = var(T.randn(batch_size, seq_len, input_size)) if batch_first else var(T.randn(seq_len, batch_size, input_size))
hx = None
rnn = SubLSTM(input_size, hidden_size, num_layers=3, bias=bias, batch_first=batch_first, bidirectional=True)
outputs = []
for i in range(6):
output, hx = rnn(input, hx)
outputs.append(output)
T.stack(outputs).sum().backward()
assert hx[-1][-1][0].size() == T.Size([batch_size, hidden_size])
assert hx[-1][-1][1].size() == T.Size([batch_size, hidden_size])
def __getitem__(self, idx):
imgstr = self.imgstrs[idx]
img1str = os.path.join(self.readdir, imgstr, 'im1.png')
img2str = os.path.join(self.readdir, imgstr, 'im2.png')
img1 = np.array(pilImg.open(img2str))
img2 = np.array(pilImg.open(img1str))
img3 = np.array(
pilImg.open(os.path.join(self.readdir, imgstr, 'im3.png')))
img3 = img3[:256, :256, :]
img1 = img1[:256, :256, :]
img2 = img2[:256, :256, :]
if self.transform is not None:
# random shift and crop
# cropx = random.randint(2, 20)
# cropy = random.randint(2, 20)
# shift = random.randint(0, 2)
# ifx = random.randint(0, 1)
# shiftx = 0
# shifty = 0
# img3 = img3[cropy:cropy + 128, cropx:cropx + 128, :]
# img1 = img1[cropy - shifty:cropy + 128 - shifty, cropx - shiftx : cropx + 128 - shiftx,:]
# img2 = img2[cropy + shifty:cropy + 128 + shifty, cropx + shiftx : cropx + 128 + shiftx,:]
flipH = random.randint(0, 1)
flipV = random.randint(0, 1)
if flipH == 1:
img1 = np.flip(img1, 0)
img2 = np.flip(img2, 0)
img3 = np.flip(img3, 0)
if flipV == 1:
img1 = np.flip(img1, 1)
img2 = np.flip(img2, 1)
img3 = np.flip(img3, 1)
return var(torch.from_numpy(img1.transpose(2,0,1).astype(np.float32) / 255.0)), var(torch.from_numpy(img2.transpose(2,0,1).astype(np.float32) / 255.0)), \
var(torch.from_numpy(img3.transpose(2,0,1).astype(np.float32) / 255.0))
