def test_transform_points(batch_size, num_points, num_dims, device_type):
# generate input data
eye_size = num_dims + 1
points_src = torch.rand(batch_size, num_points, num_dims)
points_src = points_src.to(torch.device(device_type))
dst_homo_src = utils.create_random_homography(batch_size, eye_size)
dst_homo_src = dst_homo_src.to(torch.device(device_type))
# transform the points from dst to ref
points_dst = tgm.transform_points(dst_homo_src, points_src)
# transform the points from ref to dst
src_homo_dst = torch.inverse(dst_homo_src)
points_dst_to_src = tgm.transform_points(src_homo_dst, points_dst)
# projected should be equal as initial
error = utils.compute_mse(points_src, points_dst_to_src)
assert pytest.approx(error.item(), 0.0)
# functional
assert torch.allclose(points_dst,
tgm.TransformPoints(dst_homo_src)(points_src))
# evaluate function gradient
points_src = utils.tensor_to_gradcheck_var(points_src) # to var
dst_homo_src = utils.tensor_to_gradcheck_var(dst_homo_src) # to var
assert gradcheck(tgm.transform_points, (
dst_homo_src,
points_src,
),
raise_exception=True)
def test(model):
model.eval()
transformer = data_transforms['valid']
names = gen_test_names()
mse_losses = AverageMeter()
sad_losses = AverageMeter()
i = 0
for name in tqdm(names):
fcount = int(name.split('.')[0].split('_')[0])
bcount = int(name.split('.')[0].split('_')[1])
im_name = fg_test_files[fcount]
bg_name = bg_test_files[bcount]
trimap_name = im_name.split('.')[0] + '_' + str(i) + '.png'
trimap = cv.imread('data/Combined_Dataset/Test_set/Adobe-licensed images/trimaps/' + trimap_name, 0)
i += 1
if i == 20:
i = 0
img, alpha, fg, bg, new_trimap = process_test(im_name, bg_name, trimap, trimap_name)
h, w = img.shape[:2]
x = torch.zeros((1, 4, h, w), dtype=torch.float)
img = img[..., ::-1] # RGB
img = transforms.ToPILImage()(img) # [3, 320, 320]
img = transformer(img) # [3, 320, 320]
x[0:, 0:3, :, :] = img
x[0:, 3, :, :] = torch.from_numpy(new_trimap.copy() / 255.)
# Move to GPU, if available
x = x.type(torch.FloatTensor).to(device) # [1, 4, 320, 320]
alpha = alpha / 255.
with torch.no_grad():
pred = model(x) # [1, 4, 320, 320]
pred = pred.cpu().numpy()
pred = pred.reshape((h, w)) # [320, 320]
pred[new_trimap == 0] = 0.0
pred[new_trimap == 255] = 1.0
cv.imwrite('images/test/out/' + trimap_name, pred * 255)
# Calculate loss
mse_loss = compute_mse(pred, alpha, trimap)
sad_loss = compute_sad(pred, alpha)
# Keep track of metrics
mse_losses.update(mse_loss.item())
sad_losses.update(sad_loss.item())
return sad_losses.avg, mse_losses.avg
def linear_sarsa(self, iters, lambda_, compare_to_monctecarlo = False):
"""
Linear Function Approximation of sarsa lambda algorithm
"""
if compare_to_monctecarlo:
monte_carlo_iterations = 1000000
env = Environment()
agent = Agent(env)
agent.monte_carlo_control(monte_carlo_iterations)
Q_monte_carlo = agent.Q
mse_all = []
for episode in range(0, iters):
E = np.zeros(self.number_of_features)
#initialize state and action
state = self.env.get_initial_state()
reward = 0
action = self.epsilon_greedy_linear_constant(state)
# self.N[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)] += 1
while not state.terminal:
# update number of visits
self.N[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)] += 1
[reward, state_forward] = self.env.step(state, action)
action_forward = self.epsilon_greedy_linear_constant(state_forward)
if not state_forward.terminal:
current_estimate = reward + self.estimate_Q(state_forward, action_forward)
else:
current_estimate = reward
previous_estimate = self.estimate_Q(state, action)
delta = current_estimate - previous_estimate
E = np.add(E, self.get_feature_vector(state, action))
step_size = 0.01
self.weights += step_size * delta * E
E = lambda_ * E
action = action_forward
state = state_forward
if compare_to_monctecarlo:
mse_all.append(compute_mse(self.approximation_to_Q(), Q_monte_carlo))
if compare_to_monctecarlo:
# print (mse_all[-1])
plt.plot(range(0, iters), mse_all, 'r-')
plt.xlabel("episodes")
plt.ylabel("MSE")
# plt.title("lambda = 0")
plt.show()
for (dealer_sum, player_sum), value in np.ndenumerate(self.V):
s = State(dealer_sum+1, player_sum+1)
self.Q[dealer_sum, player_sum ,0] = np.dot(self.get_feature_vector(s, Action.hit), self.weights)
self.Q[dealer_sum, player_sum ,1] = np.dot(self.get_feature_vector(s, Action.stick), self.weights)
self.V[dealer_sum, player_sum] = max(self.estimate_Q(s,Action.hit), self.estimate_Q(s,Action.stick))
def val(val_loader, model):
mse_losses = AverageMeter()
sad_losses = AverageMeter()
gradient_losses = AverageMeter()
connectivity_losses = AverageMeter()
model.eval()
# Batches
for i, (img, alpha_label, trimap_label, img_path) in enumerate(val_loader):
# Move to GPU, if available
img = img.type(torch.FloatTensor).to(device) # [N, 4, 320, 320]
alpha_label = alpha_label.type(torch.FloatTensor).to(
device) # [N, 320, 320]
alpha_label = alpha_label.unsqueeze(1)
trimap_label = trimap_label.to(device)
# Forward prop.
trimap_out, alpha_out = model(img) # [N, 3, 320, 320]
trimap_out.squeeze(0)
# alpha_out = alpha_out.reshape((-1, 1, im_size * im_size)) # [N, 320*320]
trimap_out = trimap_out.argmax(dim=1)
trimap_out = trimap_out.squeeze(0)
trimap_out[trimap_out == 1] = 128
trimap_out[trimap_out == 2] = 255
trimap_out = np.array(trimap_out.cpu(), dtype=np.uint8)
# print(trimap_out)
# return trimap, alpha
mse_loss = compute_mse(alpha_out, alpha_label, trimap_label)
sad_loss = compute_sad(alpha_out, alpha_label)
gradient_loss = compute_gradient_loss(alpha_out, alpha_label,
trimap_label)
connectivity_loss = compute_connectivity_error(alpha_out, alpha_label,
trimap_label)
print("sad:{} mse:{} gradient: {} connectivity: {}".format(
sad_loss.item(), mse_loss.item(), gradient_loss,
connectivity_loss))
# f.write("sad:{} mse:{} gradient: {} connectivity: {}".format(sad_loss.item(), mse_loss.item(), gradient_loss, connectivity_loss) + "\n")
alpha_out = (alpha_out.copy() * 255).astype(np.uint8)
draw_str(
alpha_out, (10, 20),
"sad:{} mse:{} gradient: {} connectivity: {}".format(
sad_loss.item(), mse_loss.item(), gradient_loss,
connectivity_loss))
cv.imwrite(
os.path.join('images/test/out/', output_folder,
img_path[0].split('/')[-1]), alpha_out)
# print(os.path.join('images/test/out', output_folder, img_path[0].split('/')[-1]))
# cv.imwrite(os.path.join('images/test/out', output_folder, img_path[0].split('/')[-1]), alpha_out)
print("sad_avg:{} mse_avg:{} gradient_avg: {} connectivity_avg: {}".format(
sad_losses.avg, mse_losses.avg, gradient_losses.avg,
connectivity_losses.avg))
def test_deg2rad(self):
# generate input data
x_deg = 180. * torch.rand(2, 3, 4)
# convert radians/degrees
x_rad = tgm.deg2rad(x_deg)
x_rad_to_deg = tgm.rad2deg(x_rad)
# compute error
error = utils.compute_mse(x_deg, x_rad_to_deg)
self.assertAlmostEqual(error.item(), 0.0, places=4)
# functional
self.assertTrue(torch.allclose(x_rad, tgm.DegToRad()(x_deg)))
def test_deg2rad(batch_shape, device_type):
# generate input data
x_deg = 180. * torch.rand(batch_shape)
x_deg = x_deg.to(torch.device(device_type))
# convert radians/degrees
x_rad = kornia.deg2rad(x_deg)
x_rad_to_deg = kornia.rad2deg(x_rad)
# compute error
error = utils.compute_mse(x_deg, x_rad_to_deg)
assert pytest.approx(error.item(), 0.0)
assert gradcheck(kornia.deg2rad, (utils.tensor_to_gradcheck_var(x_deg),),
raise_exception=True)
def test_rad2deg(batch_shape, device_type):
# generate input data
x_rad = kornia.pi * torch.rand(batch_shape)
x_rad = x_rad.to(torch.device(device_type))
# convert radians/degrees
x_deg = kornia.rad2deg(x_rad)
x_deg_to_rad = kornia.deg2rad(x_deg)
# compute error
error = utils.compute_mse(x_rad, x_deg_to_rad)
# evaluate function gradient
assert gradcheck(kornia.rad2deg, (utils.tensor_to_gradcheck_var(x_rad),),
raise_exception=True)
def test_convert_points_from_homogeneous(self):
# generate input data
batch_size = 2
points_h = torch.rand(batch_size, 2, 3)
points_h[..., -1] = 1.0
# to euclidean
points = tgm.convert_points_from_homogeneous(points_h)
error = utils.compute_mse(points_h[..., :2], points)
self.assertAlmostEqual(error.item(), 0.0, places=4)
# functional
self.assertTrue(
torch.allclose(points,
tgm.ConvertPointsFromHomogeneous()(points_h)))
def test_inverse(self):
# generate input data
batch_size = 2
eye_size = 3 # identity 3x3
homographies = utils.create_random_homography(batch_size, eye_size)
homographies_inv = tgm.inverse(homographies)
# H_inv * H == I
res = torch.matmul(homographies_inv, homographies)
eye = utils.create_eye_batch(batch_size, eye_size)
error = utils.compute_mse(res, eye)
self.assertAlmostEqual(error.item(), 0.0, places=4)
# functional
self.assertTrue(
torch.allclose(homographies_inv,
tgm.Inverse()(homographies)))
def test_convert_points_from_homogeneous(batch_shape, device_type):
# generate input data
points_h = torch.rand(batch_shape)
points_h = points_h.to(torch.device(device_type))
points_h[..., -1] = 1.0
# to euclidean
points = tgm.convert_points_from_homogeneous(points_h)
error = utils.compute_mse(points_h[..., :2], points)
assert pytest.approx(error.item(), 0.0)
# functional
assert torch.allclose(points, tgm.ConvertPointsFromHomogeneous()(points_h))
# evaluate function gradient
points = utils.tensor_to_gradcheck_var(points) # to var
assert gradcheck(tgm.convert_points_from_homogeneous, (points, ),
raise_exception=True)
def test_rad2deg(batch_shape, device_type):
# generate input data
x_rad = tgm.pi * torch.rand(batch_shape)
x_rad = x_rad.to(torch.device(device_type))
# convert radians/degrees
x_deg = tgm.rad2deg(x_rad)
x_deg_to_rad = tgm.deg2rad(x_deg)
# compute error
error = utils.compute_mse(x_rad, x_deg_to_rad)
assert pytest.approx(error.item(), 0.0)
# functional
assert torch.allclose(x_deg, tgm.RadToDeg()(x_rad))
# evaluate function gradient
assert gradcheck(tgm.rad2deg, (utils.tensor_to_gradcheck_var(x_rad), ),
raise_exception=True)
def test_transform_points(self, batch_size, num_points, num_dims,
device_type):
# generate input data
eye_size = num_dims + 1
points_src = torch.rand(batch_size, num_points, num_dims)
points_src = points_src.to(torch.device(device_type))
dst_homo_src = utils.create_random_homography(batch_size, eye_size)
dst_homo_src = dst_homo_src.to(torch.device(device_type))
# transform the points from dst to ref
points_dst = tgm.transform_points(dst_homo_src, points_src)
# transform the points from ref to dst
src_homo_dst = torch.inverse(dst_homo_src)
points_dst_to_src = tgm.transform_points(src_homo_dst, points_dst)
# projected should be equal as initial
error = utils.compute_mse(points_src, points_dst_to_src)
assert pytest.approx(error.item(), 0.0)
def test_transform_points(self):
# generate input data
batch_size = 2
num_points = 2
num_dims = 2
eye_size = 3 # identity 3x3
points_src = torch.rand(batch_size, 2, num_dims)
dst_homo_src = utils.create_random_homography(batch_size, eye_size)
# transform the points from dst to ref
points_dst = tgm.transform_points(dst_homo_src, points_src)
# transform the points from ref to dst
src_homo_dst = tgm.inverse(dst_homo_src)
points_dst_to_src = tgm.transform_points(src_homo_dst, points_dst)
# projected should be equal as initial
error = utils.compute_mse(points_src, points_dst_to_src)
self.assertAlmostEqual(error.item(), 0.0, places=4)
# functional
self.assertTrue(
torch.allclose(points_dst,
tgm.TransformPoints()(dst_homo_src, points_src)))
with torch.no_grad():
y_pred = model(x_test)
y_pred = y_pred.cpu().numpy()
# print('y_pred.shape: ' + str(y_pred.shape))
y_pred = np.reshape(y_pred, (im_size, im_size))
# print(y_pred.shape)
y_pred[trimap == 0] = 0.0
y_pred[trimap == 255] = 1.0
alpha = alpha / 255. # [0., 1.]
sad = compute_sad(y_pred, alpha)
mse = compute_mse(y_pred, alpha, trimap)
str_msg = 'sad: %.4f, mse: %.4f, size: %s' % (sad, mse, str(crop_size))
print(str_msg)
out = (y_pred * 255).astype(np.uint8)
draw_str(out, (10, 20), str_msg)
cv.imwrite('images/{}_out.png'.format(i), out)
sample_bg = sample_bgs[i]
bg = cv.imread(os.path.join(bg_test, sample_bg))
bh, bw = bg.shape[:2]
wratio = im_size / bw
hratio = im_size / bh
ratio = wratio if wratio > hratio else hratio
if ratio > 1:
bg = cv.resize(src=bg,
_, pred = model(x) # [1, 4, 320, 320]
pred = pred.cpu().numpy()
pred = pred.reshape((h, w)) # [320, 320]
pred[trimap == 0] = 0.0
pred[trimap == 255] = 1.0
cv.imwrite(os.path.join(save_root, trimap_name), pred * 255)
mask = np.zeros([h, w])
mask[trimap == 128] = 1
w = np.sum(mask)
# Calculate loss
# loss = criterion(alpha_out, alpha_label)
sad_loss = compute_sad(pred, alpha)
mse_loss = compute_mse(pred, alpha, mask)
grad_loss = compute_grad(pred, alpha, mask)
connectivity_loss = compute_connectivity(pred, alpha, mask, step=0.1)
str_msg = 'sad: %.4f, mse: %.4f, grad_loss: %.4f, con_loss: %.4f' % (
sad_loss, mse_loss, grad_loss, connectivity_loss)
print('test: {0}/{1}, '.format(i + 1, 20) + str_msg)
sad_losses.update(sad_loss.item())
mse_losses.update(mse_loss.item())
grad_losses.update(grad_loss.item())
connectivity_losses.update(connectivity_loss.item())
print("SAD:{:0.2f}, MSE:{:0.4f}, GRAD:{:0.2f}, CON:{:0.2f}".format(
sad_losses.avg, mse_losses.avg, grad_losses.avg,
connectivity_losses.avg))
agent = Agent(env)
agent.monte_carlo_control(monte_carlo_iterations)
Q_monte_carlo = agent.Q
alphas = np.linspace(0,1,11)
mse_all_acc = []
mse_all_replace = []
mse_all_dutch = []
avg_iters = 10
for alpha in alphas:
mse_current = 0
for i in range (0,avg_iters):
agent.reset()
agent.td_learning(td_iterations, alpha, trace = Trace.accumulating)
Q_tf = agent.Q
mse_current += compute_mse(Q_tf, Q_monte_carlo, True)
mse_all_acc.append(mse_current / avg_iters)
mse_current = 0
for i in range (0,avg_iters):
agent.reset()
agent.td_learning(td_iterations, alpha, trace = Trace.replacing)
Q_tf = agent.Q
mse_current += compute_mse(Q_tf, Q_monte_carlo, True)
mse_all_replace.append(mse_current / avg_iters)
mse_current = 0
for i in range (0,avg_iters):
agent.reset()
agent.td_learning(10000, 0.0, True, trace = Trace.accumulating)
agent.reset()
print ('lambda = 1')
agent.td_learning(10000, 1.0, True, trace = Trace.accumulating)
agent.reset()
print ('The mean-squared error against lambda')
monte_carlo_iterations = 1000000
td_iterations = 10000
agent.monte_carlo_control(monte_carlo_iterations)
Q_monte_carlo = agent.Q
alphas = np.linspace(0,1,11)
mse_all = []
avg_iters = 1 # change it to average over more iterations
for alpha in alphas:
mse_current = 0
for i in range (0,avg_iters):
agent.reset()
agent.td_learning(td_iterations, alpha)
Q_tf = agent.Q
mse_current += compute_mse(Q_tf, Q_monte_carlo, False)
mse_all.append(mse_current / avg_iters)
plt.plot(alphas, mse_all, 'r-')
plt.xlabel("lambda")
plt.ylabel("MSE")
plt.show()
agent.linear_sarsa(10000, 0.0, True)
agent.reset()
print ('lambda = 1')
agent.linear_sarsa(10000, 1.0, True)
agent.reset()
print ('The mean-squared error against lambda')
monte_carlo_iterations = 1000000
td_iterations = 10000
agent.monte_carlo_control(monte_carlo_iterations)
Q_monte_carlo = agent.Q
alphas = np.linspace(0,1,11)
mse_all = []
avg_iters = 1 # change it to average over more iterations
for alpha in alphas:
mse_current = 0
for i in range (0,avg_iters):
agent.reset()
agent.linear_sarsa(td_iterations, alpha)
Q_tf = agent.Q
mse_current += compute_mse(Q_tf, Q_monte_carlo, False)
mse_all.append(mse_current / avg_iters)
plt.plot(alphas, mse_all, 'r-')
plt.xlabel("lambda")
plt.ylabel("MSE")
plt.show()
# 'trials',
'attention']].shift(n_back) # same thing for the target, but shifting downward
.dropna()
.values
)
features.append(feature)
targets.append(target)
features = np.concatenate(features)
targets = np.concatenate(targets)
# features,targets = shuffle(features,targets)
df_working = pd.DataFrame(np.hstack([features,targets]),)
df_working.columns=['correct','awareness','confidence','attention']
traces,models = logistic_regression(df_working,sample_size=5000)
ppcs = {name:compute_ppc(trace,m,samples=int(1e4)) for (name,trace),m in zip(traces.items(),models.values())}
mses = {name:compute_mse(df_working,ppc,'attention') for name,ppc in ppcs.items()}
r2s = {name:compute_r2(df_working,ppc,'attention') for name,ppc in ppcs.items()}
for name in df_working.columns[:-1]:
results['feature'].append(name)
results['r_squred'].append(np.mean(r2s[name]))
results['beta_mean'].append(np.mean(traces[name].get_values(name)))
results['beta_higher_bound'].append(stats.scoreatpercentile(traces[name].get_values(name),97.5))
results['beta_lower_bound'].append(stats.scoreatpercentile(traces[name].get_values(name),2.5))
results['window'].append(n_back)
results['sub'].append(participant)
model_save['trace'].append(traces[name])
model_save['model'].append(models[name])
model_save['feature'].append(name)
model_save['window'].append(n_back)
model_save['sub'].append(participant)
def td_learning(self, iters, lambda_, compare_to_monctecarlo = False, trace = Trace.accumulating):
"""
sarsa lambda algorithm
"""
if compare_to_monctecarlo:
monte_carlo_iterations = 1000000
env = Environment()
agent = Agent(env)
agent.monte_carlo_control(monte_carlo_iterations)
Q_monte_carlo = agent.Q
mse_all = []
for episode in range(0, iters):
E = np.zeros(((self.env.dealer_values, self.env.player_values, self.env.action_values)))
#initialize state and action
state = self.env.get_initial_state()
reward = 0
action = self.epsilon_greedy(state)
while not state.terminal:
# update number of visits
self.N[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)] += 1
[reward, state_forward] = self.env.step(state, action)
action_forward = self.epsilon_greedy(state_forward)
if not state_forward.terminal:
current_estimate = reward + self.Q[state_forward.dealer_card - 1, state_forward.player_sum - 1, Action.get_value(action_forward)]
else:
current_estimate = reward
previous_estimate = self.Q[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)]
delta = current_estimate - previous_estimate
step_size = 1.0 / self.N[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)]
if trace == Trace.accumulating:
E[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)] += 1
elif trace == Trace.replacing:
E[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)] = 1
elif trace == Trace.dutch:
E[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)] = E[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)] + step_size*(1 - E[state.dealer_card - 1, state.player_sum - 1, Action.get_value(action)])
if trace == Trace.dutch:
self.Q += delta * E
else:
self.Q += step_size * delta * E
E = lambda_ * E
action = action_forward
state = state_forward
if compare_to_monctecarlo:
mse_all.append(compute_mse(self.Q, Q_monte_carlo))
if compare_to_monctecarlo:
# print (mse_all[-1])
plt.plot(range(0, iters), mse_all, 'r-')
plt.xlabel("episodes")
plt.ylabel("MSE")
# plt.title("lambda = 1")
plt.show()
#update policy based on action-value function
for (dealer_sum, player_sum), value in np.ndenumerate(self.V):
self.V[dealer_sum, player_sum] = max(self.Q[dealer_sum, player_sum, :])
# Move to GPU, if available
x = x.type(torch.FloatTensor).to(device)
alpha = alpha / 255.
with torch.no_grad():
pred = model(x)
pred = pred.cpu().numpy()
pred = pred.reshape((h, w))
pred[trimap == 0] = 0.0
pred[trimap == 255] = 1.0
# Calculate loss
# loss = criterion(alpha_out, alpha_label)
mse_loss = compute_mse(pred, alpha, trimap)
sad_loss = compute_sad(pred, alpha)
str_msg = 'sad: %.4f, mse: %.4f' % (sad_loss, mse_loss)
print(str_msg)
out = (pred.copy() * 255).astype(np.uint8)
draw_str(out, (10, 20), str_msg)
cv.imwrite('images/{}_out.png'.format(i), out)
new_bg = new_bgs[i]
new_bg = cv.imread(os.path.join(bg_test, new_bg))
bh, bw = new_bg.shape[:2]
wratio = w / bw
hratio = h / bh
ratio = wratio if wratio > hratio else hratio
print('ratio: ' + str(ratio))
agent = Agent(env)
agent.monte_carlo_control(monte_carlo_iterations)
Q_monte_carlo = agent.Q
alphas = np.linspace(0, 1, 11)
mse_all_acc = []
mse_all_replace = []
mse_all_dutch = []
avg_iters = 10
for alpha in alphas:
mse_current = 0
for i in range(0, avg_iters):
agent.reset()
agent.td_learning(td_iterations, alpha, trace=Trace.accumulating)
Q_tf = agent.Q
mse_current += compute_mse(Q_tf, Q_monte_carlo, True)
mse_all_acc.append(mse_current / avg_iters)
mse_current = 0
for i in range(0, avg_iters):
agent.reset()
agent.td_learning(td_iterations, alpha, trace=Trace.replacing)
Q_tf = agent.Q
mse_current += compute_mse(Q_tf, Q_monte_carlo, True)
mse_all_replace.append(mse_current / avg_iters)
mse_current = 0
for i in range(0, avg_iters):
agent.reset()
