def conj_grad_iter(x, epsilon, bracket_high): # get the start time of the iteration start_time = time.time() d = -1 * gradient(x) y = x j = 1 # perform the inner loop of the method but one time since scalar output while np.linalg.norm(gradient(y), ord=2) > epsilon: # line 2 step_size = exact_line_search(y, -1 * d, bracket_high=bracket_high) y_next = y + (step_size * d) if j == x.shape[0]: break # line 3 d = (-1 * gradient(y_next)) + ( polak_rebiere(gradient(y_next), gradient(y)) * d) y = y_next j += 1 # update x_next x_next = y return [x_next, epsilon, bracket_high], (time.time() - start_time)
def bb_iter(x, x_prev, grad_prev): # check if it x_0 (k=0th) iteration since no x_prev or f'(x_prev) # are available, instead imply perform gradient descent if (x_prev is None and grad_prev is None): # get the start time of the iteration start_time = time.time() grad = gradient(x) # simple line search with alpha = beta = 0.5 step_size = inexact_line_search(grad, eval_objective(x), x, 0.5, 0.5) # simple gradient descent x_next = x - np.dot(step_size, grad) return [x_next, x, grad], (time.time() - start_time) # get the start time of the iteration start_time = time.time() grad = gradient(x) r = x - x_prev q = grad - grad_prev step_size = np.dot(r, q) / np.dot(q, q) x_next = x - (step_size * grad) return [x_next, x, grad], (time.time() - start_time)
def fista_iter(x, y, t, alpha, beta): # get the start time of the iteration start_time = time.time() t_next = 0.5 * (1 + math.sqrt(1 + (4 * (t**2)))) step_size = inexact_line_search(gradient(x), eval_objective(x), x, alpha, beta) x_next = y - (step_size * gradient(y)) y_next = x_next + (((t - 1) / t_next) * (x_next - x)) return [x_next, y_next, t_next, alpha, beta], (time.time() - start_time)
def HOG(img_name): im = Image.open(img_name).resize((IMG_SIZE, IMG_SIZE)).convert('L') img = np.array(im).astype(np.float32) M, D = hp.gradient(img) cells = make_cells(M, D) histogram = hog_feature_vector(cells).flatten() return histogram
def linear_regression(X, phi, max_itr, delta): RAW_POINTS, LABELS = helpers.get_X_Y(X) POINTS = phi(RAW_POINTS) # Apply kernel function of input data n = POINTS.shape[0] learning_rate = 1e-3 # Learning rate (hyperparameter) final_parameters = np.zeros((POINTS.shape[1], 1)) for i in range(max_itr): final_parameters = final_parameters - learning_rate * helpers.gradient(POINTS, final_parameters, LABELS, delta) return final_parameters
def agd_iter(x, y, alpha, beta, a): # get the start time of the iteration start_time = time.time() grad = gradient(x) step_size = inexact_line_search(grad, eval_objective(x), x, alpha, beta) # find x_{k+1} (regular gradient step) y_next = x - (step_size * gradient(x)) # find a_{k+1} from a_k a_next = (1 + math.sqrt(4 * (a**2))) / 2 #a_next = find_a_next(a, recip_kappa) dynamic_momentum = (1 - a) / a_next #dynamic_momentum = find_dynamic_momentum(a, a_next) # find y_{k_1} (sliding step) x_next = y_next + (dynamic_momentum * (y_next - y)) return [x_next, y_next, alpha, beta, a_next], (time.time() - start_time)
def hb_iter(x, x_prev, alpha, beta, momentum): # get the start time of the iteration start_time = time.time() # evaluate at x grad = gradient(x) obj_val = eval_objective(x) # perform backtracking line search step_size = inexact_line_search(grad, obj_val, x, alpha, beta) # subtract the gradient and add momentum x_next = (x - np.dot(step_size, grad)) + np.dot(momentum, (x - x_prev)) return [x_next, x, alpha, beta, momentum], (time.time() - start_time)
def gd_iter(x, alpha, beta): # get the start time of the iteration start_time = time.time() # evaluate at x grad = gradient(x) obj_val = eval_objective(x) # perform backtracking line search step_size = inexact_line_search(grad, obj_val, x, alpha, beta) # perform actual gradient descent x_next = x - np.dot(step_size, grad) return [x_next, alpha, beta], (time.time() - start_time)