def tensorflow_fitting(strategy_dictionary_local):
    toc = tic()
    data_local = import_data(strategy_dictionary_local)
    fitting_inputs_local, continuous_targets, classification_targets = input_processing(
        data_local, strategy_dictionary)

    if strategy_dictionary_local['regression_mode'] == 'classification':
        fitting_targets_local = classification_targets
    elif strategy_dictionary_local['regression_mode'] == 'regression':
        fitting_targets_local = continuous_targets

    fitting_inputs_local, strategy_dictionary_local = preprocessing_inputs(
        strategy_dictionary_local, fitting_inputs_local)

    fitting_dictionary, error_loop, profit_factor = fit_tensorflow(
        strategy_dictionary_local, data_local, fitting_inputs_local,
        fitting_targets_local)

    if strategy_dictionary_local['plot_last']:
        strategy_dictionary_local['plot_flag'] = True

    output_strategy_results(strategy_dictionary_local,
                            fitting_dictionary,
                            data_local,
                            toc,
                            momentum_dict=simple_momentum_comparison(
                                data_local, strategy_dictionary,
                                fitting_dictionary))

    output_strategy_results(strategy_dictionary, fitting_dictionary,
                            data_local, toc)

    return strategy_dictionary, data_local, fitting_inputs_local, fitting_targets_local
def random_search(strategy_dictionary_local, n_iterations):
    toc = tic()

    data_local, data_2 = import_data(strategy_dictionary)
    fitting_inputs_local, continuous_targets, classification_targets = input_processing(
        data_local, data_2, strategy_dictionary)

    counter = 0
    error = 1e5
    while counter < n_iterations:
        counter += 1
        strategy_dictionary_local = randomise_dictionary_inputs(strategy_dictionary_local)

        if strategy_dictionary['regression_mode'] == 'classification':
            fitting_targets_local = classification_targets
        elif strategy_dictionary['regression_mode'] == 'regression':
            fitting_targets_local = continuous_targets

        fitting_inputs_local = preprocessing_inputs(strategy_dictionary, fitting_inputs_local)

        fitting_dictionary, profit_factor = fit_strategy(
            strategy_dictionary, data_local, fitting_inputs_local, fitting_targets_local)
        error_loop = fitting_dictionary['error']

        if error_loop < error and fitting_dictionary['n_trades'] != 0:
            error = error_loop
            strategy_dictionary_local_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary

    underlined_output('Best strategy fit')
    output_strategy_results(strategy_dictionary_local_optimum, fitting_dictionary_optimum, data_local, toc)

    return strategy_dictionary_local_optimum, fitting_inputs_local, fitting_targets_local, data_local
def random_search(strategy_dictionary_local, n_iterations):
    toc = tic()
    counter = 0
    error = 1e10

    while counter < n_iterations:
        counter += 1

        #strategy_dictionary['sequence_flag'] = np.random.choice([True, False])

        if strategy_dictionary['sequence_flag']:
            strategy_dictionary_local = randomise_sequence_dictionary_inputs(strategy_dictionary_local)
        else:
            strategy_dictionary_local = randomise_dictionary_inputs(strategy_dictionary_local)

        fitting_dictionary, data_to_predict, error_loop, profit_factor = fit_tensorflow(strategy_dictionary_local)

        if error_loop < error:
            error = error_loop
            strategy_dictionary_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary

    underlined_output('Best strategy fit')
    output_strategy_results(strategy_dictionary_optimum, fitting_dictionary_optimum, data_to_predict, toc)

    return strategy_dictionary_optimum
Пример #4
0
def random_search(strategy_dictionary_local, n_iterations):
    print("Ticking")
    toc = tic()
    print("Importing data")
    data_local, data_2 = import_data(strategy_dictionary_local)
    print("Finished Imported data")

    fitting_inputs_local, continuous_targets, classification_targets = input_processing(
        data_local, data_2, strategy_dictionary)
    print("Targets determined")

    counter = 0
    error = 1e5
    fitting_dictionary_optimum = []
    strategy_dictionary_optimum = []
    fitting_targets_local = []
    while counter < n_iterations:
        print("Starting iteration %s" % counter)
        counter += 1

        # strategy_dictionary['sequence_flag'] = np.random.choice([True, False])
        strategy_dictionary['sequence_flag'] = False

        if strategy_dictionary['sequence_flag']:
            strategy_dictionary_local = randomise_sequence_dictionary_inputs(
                strategy_dictionary_local)
        else:
            strategy_dictionary_local = randomise_dictionary_inputs(
                strategy_dictionary_local)

        if strategy_dictionary_local['regression_mode'] == 'classification':
            fitting_targets_local = classification_targets
        elif strategy_dictionary_local['regression_mode'] == 'regression':
            fitting_targets_local = continuous_targets

        fitting_inputs_local, strategy_dictionary_local = preprocessing_inputs(
            strategy_dictionary_local, fitting_inputs_local)

        fitting_dictionary, error_loop, profit_factor = fit_tensorflow(
            strategy_dictionary_local, data_local, fitting_inputs_local,
            fitting_targets_local)

        if error_loop < error:
            error = error_loop
            strategy_dictionary_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary
        print("Completed iteration")

    underlined_output('Best strategy fit')
    output_strategy_results(strategy_dictionary_optimum,
                            fitting_dictionary_optimum, data_local, toc)

    return strategy_dictionary_optimum, data_local, fitting_inputs_local, fitting_targets_local
def fit_time_scale(strategy_dictionary_input, search_iterations_local,
                   time_iterations):
    """ fit timescale variables"""

    toc = tic()
    counter = 0
    strategy_dictionary_optimum = []
    optimum_profit = -2

    while counter < time_iterations:

        strategy_dictionary_input = randomise_time_inputs(
            strategy_dictionary_input)

        strategy_dictionary_local,\
            fitting_dictionary_local,\
            fitting_inputs_local,\
            fitting_targets_local,\
            data_local,\
            test_profit\
            = random_search(
                strategy_dictionary_input,
                search_iterations_local,
                toc)

        if test_profit > optimum_profit:
            optimum_profit = test_profit
            strategy_dictionary_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary_local

        counter += 1

    underlined_output('Best strategy fit')

    if strategy_dictionary['plot_last']:
        strategy_dictionary['plot_flag'] = True

    output_strategy_results(strategy_dictionary_optimum,
                            fitting_dictionary_optimum,
                            data_local,
                            toc,
                            momentum_dict=simple_momentum_comparison(
                                data_local, strategy_dictionary_optimum,
                                fitting_dictionary_optimum))

    return strategy_dictionary_optimum,\
        fitting_inputs_local,\
        fitting_targets_local,\
        data_local
def random_search(strategy_dictionary_local, n_iterations):
    toc = tic()
    data_local, data_2 = import_data(strategy_dictionary_local)
    fitting_inputs_local, continuous_targets, classification_targets = input_processing(
        data_local, data_2, strategy_dictionary)

    counter = 0
    error = 1e5
    fitting_dictionary_optimum = []
    strategy_dictionary_optimum = []
    fitting_targets_local = []
    while counter < n_iterations:
        counter += 1

        strategy_dictionary['sequence_flag'] = np.random.choice([True, False])

        if strategy_dictionary['sequence_flag']:
            strategy_dictionary_local = randomise_sequence_dictionary_inputs(
                strategy_dictionary_local)
        else:
            strategy_dictionary_local = randomise_dictionary_inputs(
                strategy_dictionary_local)

        if strategy_dictionary_local['regression_mode'] == 'classification':
            fitting_targets_local = classification_targets
        elif strategy_dictionary_local['regression_mode'] == 'regression':
            fitting_targets_local = continuous_targets

        fitting_inputs_local, strategy_dictionary_local = preprocessing_inputs(
            strategy_dictionary_local, fitting_inputs_local)

        fitting_dictionary, error_loop, profit_factor = fit_tensorflow(
            strategy_dictionary_local, data_local, fitting_inputs_local,
            fitting_targets_local)

        if error_loop < error:
            error = error_loop
            strategy_dictionary_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary

    underlined_output('Best strategy fit')
    output_strategy_results(strategy_dictionary_optimum,
                            fitting_dictionary_optimum, data_local, toc)

    return strategy_dictionary_optimum, data_local, fitting_inputs_local, fitting_targets_local
def random_search(strategy_dictionary_local, n_iterations):
    """random search to find optimum machien learning algorithm and preprocessing"""

    toc = tic()

    data_local = import_data(strategy_dictionary_local)
    fitting_inputs_local, continuous_targets, classification_targets = input_processing(
        data_local, strategy_dictionary_local)

    counter = 0
    error = 1e5
    fitting_targets_local = []
    fitting_dictionary_optimum = []
    strategy_dictionary_optimum = []
    while counter < n_iterations:
        counter += 1
        strategy_dictionary_local = randomise_dictionary_inputs(
            strategy_dictionary_local)

        if strategy_dictionary_local['regression_mode'] == 'classification':
            fitting_targets_local = classification_targets.astype(int)
        elif strategy_dictionary_local['regression_mode'] == 'regression':
            fitting_targets_local = continuous_targets

        fitting_inputs_local, strategy_dictionary = preprocessing_inputs(
            strategy_dictionary_local, fitting_inputs_local)

        fitting_dictionary, profit_factor = fit_strategy(
            strategy_dictionary, data_local, fitting_inputs_local,
            fitting_targets_local)

        error_loop = fitting_dictionary['error']

        if error_loop < error and fitting_dictionary['n_trades'] != 0:
            error = error_loop
            strategy_dictionary_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary

    underlined_output('Best strategy fit')
    output_strategy_results(strategy_dictionary_optimum,
                            fitting_dictionary_optimum, data_local, toc)

    return strategy_dictionary_optimum, fitting_inputs_local, fitting_targets_local, data_local
def random_search(strategy_dictionary_local, n_iterations):
    toc = tic()

    counter = 0
    error = -1e5
    while counter < n_iterations:
        counter += 1
        strategy_dictionary_local = randomise_dictionary_inputs(strategy_dictionary_local)
        fitting_dictionary, data_to_predict, profit_factor = fit_strategy(strategy_dictionary_local)
        error_loop = fitting_dictionary['error']

        if error_loop > error and fitting_dictionary['n_trades'] != 0:
            error = error_loop
            strategy_dictionary_local_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary

    underlined_output('Best strategy fit')
    output_strategy_results(strategy_dictionary_local_optimum, fitting_dictionary_optimum, data_to_predict, toc)

    return strategy_dictionary_local_optimum
Пример #9
0
def tensorflow_fitting(strategy_dictionary_local):
    toc = tic()
    data_local, data_2 = import_data(strategy_dictionary_local)
    fitting_inputs_local, continuous_targets, classification_targets = input_processing(
        data_local, data_2, strategy_dictionary)

    if strategy_dictionary_local['regression_mode'] == 'classification':
        fitting_targets_local = classification_targets
    elif strategy_dictionary_local['regression_mode'] == 'regression':
        fitting_targets_local = continuous_targets

    fitting_inputs_local, strategy_dictionary_local = preprocessing_inputs(
        strategy_dictionary_local, fitting_inputs_local)

    fitting_dictionary, error_loop, profit_factor = fit_tensorflow(
        strategy_dictionary_local, data_local, fitting_inputs_local,
        fitting_targets_local)

    underlined_output('Best strategy fit')
    output_strategy_results(strategy_dictionary, fitting_dictionary,
                            data_local, toc)

    return strategy_dictionary, data_local, fitting_inputs_local, fitting_targets_local
Пример #10
0
        if test_profit > optimum_profit:
            optimum_profit = test_profit
            strategy_dictionary_optimum = strategy_dictionary_local
            fitting_dictionary_optimum = fitting_dictionary_local

        counter += 1

    return strategy_dictionary_optimum,\
        fitting_dictionary_optimum,\
        fitting_inputs_local,\
        fitting_targets_local,\
        data_local


if __name__ == '__main__':
    toc = tic()

    strategy_dictionary = {
        'trading_currencies': ['XMR', 'DASH'],
        'ticker_1': 'XMR_DASH',
        'scraper_currency_1': 'DASH',
        'candle_size': 300,
        'n_days': 50,
        'offset': 0,
        'bid_ask_spread': 0.003,
        'transaction_fee': 0.0025,
        'train_test_validation_ratios': [0.5, 0.2, 0.3],
        'output_flag': True,
        'plot_flag': False,
        'plot_last': True,
        'ml_iterations': 15,