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()