def test_indicator(file_name, start_date, end_date, figure_title, candlestick_width): csv_data = utils.load_data(file_name, "%Y.%m.%d %H:%M:%S") plot_data = csv_data.copy() print('Sample data:') plot_data['SMA'] = simple_moving_average(plot_data['Close'], 10) print(plot_data.tail(20)) subplot_df1 = plot_data.drop(['Volume', 'SMA'], 1).loc[start_date:end_date] subplot_df2 = plot_data['SMA'].loc[start_date:end_date] df1_tuples = utils.candlestick_tuples(subplot_df1) fig, ax = plt.subplots() plt.xticks(rotation=45) plt.title(figure_title) fplt.candlestick_ochl(ax, df1_tuples, width=candlestick_width, colorup='g', colordown='r') subplot_df2.plot(ax=ax) plt.show()
def test_indicator(file_name, start_date, end_date, figure_title, candlestick_width): csv_data = utils.load_data(file_name, "%Y.%m.%d %H:%M:%S") print("Sample data:") print(csv_data.head(10)) data_CHO = chaikin_oscillator(csv_data) print("") print(data_CHO.tail(20)) ax1_data = data_CHO.drop( ['Volume', 'ADL', '3 day EMA of ADL', '10 day EMA of ADL', 'CHO'], 1) ax1_data = ax1_data.loc[start_date:end_date] ax2_data = data_CHO.drop(['Open', 'High', 'Low', 'Close', 'Volume', 'CHO'], 1) ax2_data = ax2_data.loc[start_date:end_date] ax3_data = data_CHO['CHO'].loc[start_date:end_date] # fig1.suptitle('Hourly OHLC data') <- figure title df1_tuples = utils.candlestick_tuples(ax1_data) fig1, ax1 = plt.subplots(1, 1) ax1.xaxis_date() ax1.set_ylabel('OHLC', color='g') ax1.set_title(figure_title) for tick in ax1.get_xticklabels(): tick.set_rotation(45) for t1 in ax1.get_yticklabels(): t1.set_color('g') ax1.grid() fplt.candlestick_ochl(ax1, df1_tuples, width=candlestick_width, colorup='g', colordown='r') ax2 = ax1.twinx() ax2.plot(ax3_data, 'b-') ax2.set_ylabel('%R', color='b') for t1 in ax2.get_yticklabels(): t1.set_color('b') fig1.show() fig2 = plt.figure(2) plt.plot(ax2_data) plt.title('ADL vs EMAs') plt.legend(['ADL', '3 day EMA of ADL', '10 day EMA of ADL']) plt.xlabel('Laikas') plt.ylabel('ADL') plt.grid() plt.xticks(rotation=90) fig2.show() plt.close()
def main(): args = get_args() arch_name = args.arch epochs = args.epochs image_datasets, dataloaders = load_data(args.data_directory) model = create_model(arch_name, args.hidden_units) device = create_device(args.gpu) train_model(device, model, dataloaders, args.learning_rate, epochs) model.cpu() model.arch_name = arch_name model.class_to_idx = image_datasets['Training'].class_to_idx model.epochs_count = epochs save_model(model, args.save_directory)
def test_indicator(file_name, start_date, end_date, figure_title, candlestick_width): csv_data = utils.load_data(file_name, "%Y.%m.%d %H:%M:%S") # print("Sample data:") # print(csv_data.head(10)) plot_data = williams_r(csv_data, 14) # print("") # print(plot_data.tail(20)) subplot_df1 = plot_data.drop(['Volume', '%R', 'Highest high', 'Lowest low'], 1).loc[start_date:end_date] subplot_df2 = plot_data['%R'].loc[start_date:end_date] df1_tuples = utils.candlestick_tuples(subplot_df1) subplot_df2 = utils.reset_date_index(subplot_df2) # subplots fig, (ax1, ax2) = plt.subplots(2, 1, sharex='col') # fig.set_size_inches(8, 8) ax1.xaxis_date() # ax1.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S')) ax1.set_title(figure_title) for tick in ax1.get_xticklabels(): tick.set_rotation(45) ax1.grid() fplt.candlestick_ochl(ax1, df1_tuples, width=candlestick_width, colorup='g', colordown='r') subplot_df2.plot(ax=ax2) for tick in ax2.get_xticklabels(): tick.set_rotation(90) ax2.grid(which='minor', linestyle='--') ax2.grid(which='major', linestyle='-') fig.subplots_adjust(hspace=0.0) fig.show() plt.close()
def test_indicator(file_name, start_date, end_date, figure_title, candlestick_width): csv_data = utils.load_data(file_name, "%Y.%m.%d %H:%M:%S") print("Sample data:") print(csv_data.head(10)) plot_data = csv_data.copy() plot_data['ADL'] = accumulation_distribution_line(plot_data) print(plot_data.tail(10)) subplot_df1 = plot_data.drop(['Volume', 'ADL'], 1).loc[start_date:end_date] subplot_df2 = plot_data['ADL'].loc[start_date:end_date] df1_tuples = utils.candlestick_tuples(subplot_df1) subplot_df2 = utils.reset_date_index(subplot_df2) # subplots fig, (ax1, ax2) = plt.subplots(2, 1, sharex='col') ax1.xaxis_date() ax1.set_title(figure_title) # for tick in ax1.get_xticklabels(): # tick.set_rotation(45) ax1.grid() fplt.candlestick_ochl(ax1, df1_tuples, width=candlestick_width, colorup='g', colordown='r') subplot_df2.plot(ax=ax2) for tick in ax2.get_xticklabels(): tick.set_rotation(45) ax2.grid(which='minor', linestyle='--') ax2.grid(which='major', linestyle='-') fig.subplots_adjust(hspace=0.0) fig.show() plt.close()
results["metrics"][name]["index"], results["metrics"][name]["values"], *args, **kwargs, label=name ) #%% DATA_DIR = "data/" N_JOBS = -1 results = dict() full_k, real_img, mask_loc, final_mask = load_data(DATA_DIR, 2, monocoil=False) final_k = np.squeeze(full_k * final_mask[np.newaxis]) square_mask = np.zeros(real_img.shape) real_img_size = real_img.shape img_size = [min(real_img.shape)] * 2 square_mask[ real_img_size[0] // 2 - img_size[0] // 2 : real_img_size[0] // 2 + img_size[0] // 2, real_img_size[1] // 2 - img_size[1] // 2 : real_img_size[1] // 2 + img_size[1] // 2, ] = 1 trajectories = sp.io.loadmat("data/NCTrajectories.mat") #%% md # Offline reconstruction #%%
for idx, setup in enumerate(setups): data, problem, solver = ( copy.deepcopy(setup["data"]), copy.deepcopy(setup["problem"]), copy.deepcopy(setup["solver"]), ) e = Experience(data, problem, solver) print(f" == {idx}/{len(setups)}: {e.hex_hash()} == ") pprint(e.id()) if not args.FORCE and e.hex_hash() in hash_list: print("already computed") continue if not args.DRY: # get data full_k, real_img, mask_loc, final_mask = load_data( DATA_DIR, **data) final_k = np.squeeze(full_k * final_mask[np.newaxis]) # create the online problem ksp, fft, lin, prox = get_operators(kspace_data=final_k, loc=mask_loc, mask=final_mask, **problem) alg_name = solver.pop("algo") online_pb = OnlineReconstructor(fft, lin, regularizer_op=prox, opt=alg_name, verbose=0) # configure metrics metrics_config = create_cartesian_metrics(online_pb, real_img,
# arguments period = 131 # exponential moving average period ctrl_ticks = 0 # minimum amount of ticks a triggerred signal must pass before buying/selling stop_loss = 10 take_profit = 10 bear_open = -20 bear_close = -80 bull_open = -50 bull_close = -20 init_budget = 10000 # initial user budget weight = 15 # volume of item bought on trade expenses = 0.01 # expenses on each trade # load data from csv file csv_data = utils.load_data('xauusd_m10_data1.csv', "%Y.%m.%d %H:%M:%S") dates = pd.to_datetime(csv_data.index.values, format="%Y.%m.%d %H:%M:%S") # apply williams %r indicator wr_data = wr.williams_r(csv_data, 14) wr_data = wr_data[['Close', '%R']] wr_data['EMA'] = ema.exponential_moving_average(csv_data['Close'], period) # opt_period, opt_bear_open, opt_bear_close, opt_bull_open, opt_bull_close = WR_strategy.optimize_strategy2(wr_data, dates, init_budget, weight, expenses) # profits, bull_buys, bull_sales, bear_buys, bear_sales, stop_loss_trades, take_profit_trades = \ # WR_strategy.wr_strategy(True, wr_data, dates, opt_period, ctrl_ticks, stop_loss, take_profit, opt_bear_open, opt_bear_close, opt_bull_open, opt_bull_close, init_budget, weight, expenses) # print("Optimal period: ", opt_period, ", bear open: ", opt_bear_open, ", bear close: ", opt_bear_close, ", bull open: ", opt_bull_open, ", bull close: ", opt_bull_close) profits, bull_buys, bull_sales, bear_buys, bear_sales, stop_loss_trades, take_profit_trades = \ WR_strategy.wr_strategy(True, wr_data, dates, period, ctrl_ticks, stop_loss, take_profit,
def run_experiment(lr=0.01, num_epochs=128, nkerns=[96, 192, 10], lambda_decay=1e-3, conv_arch=all_CNN_C, n_class=10, batch_size=128, verbose=False, filter_size=(3,3)): """ Wrapper function for testing the all convolutional networks implemented here :type lr: float :param lr: learning rate used (factor for the stochastic gradient) :type n_epochs: int :param n_epochs: maximal number of epochs to run the optimizer :type nkerns: list of ints :param nkerns: number of kernels on each layer :type batch_size: int :param batch_szie: number of examples in minibatch. :type verbose: boolean :param verbose: to print out epoch summary or not to. :type filter_size: tuple(int) :param filter_size: size of the filters. :type conv_arch: function :param verbose: Convolutional Network to run :type weight_decay: float :param weight_decay: L2 regularization parameter :type n_class: int :param n_class: Number of classes/output units of final layer (10 vs. 100) """ datasets = load_data( simple=False if n_class == 100 else True ) X_train, y_train = datasets[0] X_val, y_val = datasets[1] X_test, y_test = datasets[2] n_train_batches = X_train.get_value(borrow=True).shape[0] n_valid_batches = X_val.get_value(borrow=True).shape[0] n_test_batches = X_test.get_value(borrow=True).shape[0] n_train_batches //= batch_size n_valid_batches //= batch_size n_test_batches //= batch_size index = T.lscalar() # index to a [mini]batch x = T.tensor4('x') y = T.ivector('y') channel = 3 imsize = 32 data_size = X_train.eval().shape[0] tdata_size = X_test.eval().shape[0] vdata_size = X_val.eval().shape[0] X_train = X_train.reshape((data_size, channel, imsize, imsize)) X_test = X_test.reshape((tdata_size, channel, imsize, imsize)) X_val = X_val.reshape((vdata_size, channel, imsize, imsize)) # Building the all conv network network = all_CNN_C(x, filter_size=filter_size, n_class=n_class) # Loss and prediction calculation # Training loss function used is Categorical Cross Entropy # which computes the categorical cross-entropy between predictions and targets. train_prediction = lasagne.layers.get_output(network) train_loss = lasagne.objectives.categorical_crossentropy(train_prediction, y) train_loss = train_loss.mean() # Regularization l2_penalty = lasagne.regularization.regularize_network_params(network, lasagne.regularization.l2) train_loss += lambda_decay * l2_penalty params = lasagne.layers.get_all_params(network, trainable=True) #Updates to the parameters are defined here updates = lasagne.updates.nesterov_momentum( train_loss, params, learning_rate=lr, momentum=0.9) val_prediction = lasagne.layers.get_output(network) val_loss = errors(val_prediction, y) test_prediction = lasagne.layers.get_output(network, deterministic=True) test_loss = errors(test_prediction, y) # Training, Validation and test models are defined here train_fn = theano.function([index], train_loss, updates=updates, givens={ x: X_train[index * batch_size: (index + 1) * batch_size], y: y_train[index * batch_size: (index + 1) * batch_size] } ) val_fn = theano.function( [index], val_loss, givens={ x: X_val[index * batch_size: (index + 1) * batch_size], y: y_val[index * batch_size: (index + 1) * batch_size] } ) test_fn = theano.function( [index], test_loss, givens={ x: X_test[index * batch_size: (index + 1) * batch_size], y: y_test[index * batch_size: (index + 1) * batch_size] } ) train_nn(train_fn, val_fn, test_fn, n_train_batches, n_valid_batches, n_test_batches, num_epochs, verbose=verbose)