Exemple #1
0
def MacGyver_method(tickerlist, dfeps, method='integrated'):
    '''MacGyver method of pairwise calculation'''
    periodicity = 52
    minimal = 10**(-20)
    xlams, alphas, betas = [], [], []
    for it in range(len(tickerlist) - 1):
        tick1 = tickerlist[it]
        for jt in range(it + 1, len(tickerlist)):
            tick2 = tickerlist[jt]
            InData = np.array(dfeps[[tick1, tick2]])  # global cast
            # integrated corr.
            if method == 'integrated':
                result = minimize_scalar(IntegratedCorrObj)
                xlamopt = np.exp(result.x) / (1 + np.exp(result.x))
                print(tick1, tick2)
                print('    Optimal lambda:', xlamopt)
                print('    Optimal objective function:', \
                      result.fun)
                if np.absolute(xlamopt) < minimal or xlamopt >= 1:
                    halflife = 0
                else:
                    halflife = -np.log(2) / np.log(1 - xlamopt)
                print('    Half-life (years):', halflife / periodicity)
                xlams.append(xlamopt)
            # mean revert corr.
            elif method == 'meanRev':
                #alpha and beta positive
                corr_bounds = scpo.Bounds([0, 0], [np.inf, np.inf])
                #Sum of alpha and beta is less than 1
                corr_linear_constraint = \
                    scpo.LinearConstraint([[1, 1]],[0],[.999])

                initparams = [.02, .93]
                results = scpo.minimize(MeanRevCorrObj, \
                        initparams, \
                        method='trust-constr', \
                        jac='2-point', \
                        hess=scpo.SR1(), \
                        bounds=corr_bounds, \
                        constraints=corr_linear_constraint)
                alpha, beta = results.x
                print('Optimal alpha, beta:', alpha, beta)
                print('Optimal objective function:', results.fun)
                halflife = -np.log(2) / np.log(1 - alpha)
                print('Half-life (years):', halflife / periodicity)
                alphas.append(alpha)
                betas.append(beta)
    # cout median values
    if method == 'integrated':
        print('\nMedian MacGyver lambda:', np.median(xlams))
    elif method == 'meanRev':
        print('\nMedian MacGyver alpha:', np.median(alphas))
        print('\nMedian MacGyver beta:', np.median(betas))
Exemple #2
0
def compute_meanRevCorr(df_logs, InData):
    '''Compute mean reverting correlations'''
    periodicity = 52
    #alpha and beta positive
    corr_bounds = scpo.Bounds([0, 0], [np.inf, np.inf])
    #Sum of alpha and beta is less than 1
    corr_linear_constraint = \
        scpo.LinearConstraint([[1, 1]],[0],[.999])

    initparams = [.02, .93]

    results = scpo.minimize(MeanRevCorrObj, \
            initparams, \
            method='trust-constr', \
            jac='2-point', \
            hess=scpo.SR1(), \
            bounds=corr_bounds, \
            constraints=corr_linear_constraint)

    alpha, beta = results.x
    print('Optimal alpha, beta:', alpha, beta)
    print('Optimal objective function:', results.fun)
    halflife = -np.log(2) / np.log(1 - alpha)
    print('Half-life (years):', halflife / periodicity)

    #Compute mean reverting correlations
    nobs = len(InData)
    nsecs = len(InData[0])
    previousq = np.identity(nsecs)
    Rlong = np.corrcoef(InData.T)
    rmatrices = []
    for i in range(nobs):
        stdmtrx = np.diag([1 / np.sqrt(previousq[s, s]) for s in range(nsecs)])
        rmatrices.append(np.matmul(stdmtrx, np.matmul(previousq, stdmtrx)))
        shockvec = np.mat(np.array(InData[i]))
        #Update q matrix
        shockmat = np.matmul(shockvec.T, shockvec)
        previousq = (1 - alpha -
                     beta) * Rlong + alpha * shockmat + beta * previousq

    #Plot mean-reverting correlations
    iccol = ['r', 'g', 'b']
    xtitle = 'Mean Reverting Correlations α=%1.5f' % alpha
    xtitle += ', β=%1.5f' % beta
    xtitle+=', '+min(df_logs.index.strftime("%Y-%m-%d"))+':'+ \
                 max(df_logs.index.strftime("%Y-%m-%d"))
    dates = df_logs.index
    stride = 5 * periodicity
    corr_matrix = df_logs[df_logs.columns].corr()
    plot_corrs(dates, rmatrices, corr_matrix, iccol, stride, xtitle)
Exemple #3
0
def trainSVM(x, y):
    x = np.asarray(x, dtype='float64')
    y = np.asarray(y, dtype='float64')
    n = x.shape[0]
    m = x.shape[1]
    left_bounds = np.zeros(n)
    right_bounds = np.full((n, ), np.inf)
    bounds = opt.Bounds(left_bounds, right_bounds)
    constr_bound = np.zeros((1, ))
    constr_matr = np.expand_dims(y, axis=0)
    constraint = opt.LinearConstraint(constr_matr, constr_bound, constr_bound)

    x0 = np.zeros_like(y)
    l = opt.minimize(
        util.lagr,
        x0,
        args=(x, y),
        method='trust-constr',
        jac='2-point',
        hess=opt.SR1(),
        #jac=util.lagr_der, hess=util.lagr_hess,
        constraints=constraint,
        bounds=bounds)
    l = l.x
    support_points = np.array(
        [not math.isclose(0., li, rel_tol=0., abs_tol=1e-03) for li in l])
    x = x[support_points]
    y = y[support_points]
    l = l[support_points]
    n_supp = x.shape[0]

    lyx = np.expand_dims(l * y, 1) * x
    w = np.sum(lyx, axis=0)
    b = y[0] - np.dot(w, x[0])

    def classifier(input):
        input = np.asarray(input, dtype='float64')
        to_sum = np.dot(lyx, input.T)
        s = np.sum(to_sum, axis=0)
        return np.sign(s + b)

    return classifier
Exemple #4
0
#Done with MeanRevCorrObj

import scipy.optimize as scpo
#alpha and beta positive
corr_bounds = scpo.Bounds([0, 0], [np.inf, np.inf])
#Sum of alpha and beta is less than 1
corr_linear_constraint = \
    scpo.LinearConstraint([[1, 1]],[0],[.999])

initparams = [.02, .93]

results = scpo.minimize(MeanRevCorrObj, \
        initparams, \
        method='trust-constr', \
        jac='2-point', \
        hess=scpo.SR1(), \
        bounds=corr_bounds, \
        constraints=corr_linear_constraint)

alpha, beta = results.x
print('Optimal alpha, beta:', alpha, beta)
print('Optimal objective function:', results.fun)
halflife = -np.log(2) / np.log(1 - alpha)
print('Half-life (months):', halflife)

#Plot mean reverting correlations
previousq = np.identity(len(InData[0]))
Rlong = np.corrcoef(InData.T)
rmatrices = []
for i in range(len(InData)):
    stdmtrx = np.diag(
Exemple #5
0
def sr1_method(initial_approximation, args, eps=1e-3):
    """
        Newton's method with SR1 strategy by scipy.optimize.SR1.
        param:  initial_approximation: initial approximation - tuple of float
                args: list length of 3 arguments:
                    1.  f: regression function - reference type
                    2.  x: np.array of float - (n, )
                    3.  y: np.array of float - (n, )
                eps: estimated error - 1e-3
        return: xn_1: tuple of float params
    """
    # Initialize SR1 hessian
    hessian = optimize.SR1()
    hessian.initialize(n=2, approx_type='inv_hess')

    xn = initial_approximation
    old_old_error = None

    def hessian_dot_fprime(xn, f, x, y):
        """
            Method to return multiplication of SR1 hessian and jacobian
                of MSE function.
            param:  xn: tuple of float parameters
                    f: regression function - reference type
                    x: np.array of float - (n, )
                    y: np.array of float - (n, )
            return: multiplication of matrix SR1 hessian and jacobian
                of MSE function
        """
        return hessian.dot(error_mse_fprime(xn, f, x, y))

    while True:
        d_xn = hessian_dot_fprime(xn, args[0], args[1], args[2])

        # Compute a step size using scipy.optimize.line_search to satisfy
        # the Wolfe conditions
        step = optimize.line_search(error_mse,
                                    hessian_dot_fprime,
                                    xn,
                                    -d_xn,
                                    gfk=d_xn,
                                    old_fval=error_mse(xn, args[0], args[1],
                                                       args[2]),
                                    old_old_fval=old_old_error,
                                    args=(args[0], args[1], args[2]),
                                    maxiter=10000)
        step = step[0]

        if step is None:
            step = 0

        # Compute new params
        xn_1 = xn - step * d_xn

        # Write a callback
        callback_function(xn_1)

        if abs(
                error_mse(xn, args[0], args[1], args[2]) -
                error_mse(xn_1, args[0], args[1], args[2])) < eps:
            break

        # Update SR1 hessian
        hessian.update(
            xn_1 - xn,
            error_mse_fprime(xn_1, args[0], args[1], args[2]) -
            error_mse_fprime(xn, args[0], args[1], args[2]))

        old_old_error = error_mse(xn, args[0], args[1], args[2])
        xn = xn_1

    return xn_1
Exemple #6
0
 def __init__(self):
     self.method = 'trust-constr'    # Optimization method
     self.jac = "2-point"            # Automatic Jacobian finite differenciation
     self.hess =  opt.SR1()          # opt.BFGS() method for the hessian computation
     self.ul = np.pi / 4             # Max turn constraint for our problem (action limits). How much the vehicle can turn