File size: 5,814 Bytes
0a6a1d7 c7a9443 0a6a1d7 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 |
# developer: Taoshidev
# Copyright © 2023 Taoshi, LLC
import numpy as np
import tensorflow
from numpy import ndarray
import xgboost as xgb
class BaseMiningModel:
def __init__(self, features):
self.neurons = [[50,0]]
self.features = features
self.loaded_model = None
self.window_size = 100
self.model_dir = None
self.batch_size = 16
self.learning_rate = 0.01
def set_neurons(self, neurons):
self.neurons = neurons
return self
def set_window_size(self, window_size):
self.window_size = window_size
return self
def set_model_dir(self, model, stream_id=None):
if model is None and stream_id is not None:
# self.model_dir = f'mining_models/{stream_id}.keras'
self.model_dir = f'./mining_models/{stream_id}.model'
elif model is not None:
self.model_dir = model
else:
raise Exception("stream_id is not provided to define model")
return self
def set_batch_size(self, batch_size):
self.batch_size = batch_size
return self
def set_learning_rate(self, learning_rate):
self.learning_rate = learning_rate
return self
def load_model(self):
# self.loaded_model = tensorflow.keras.models.load_model(self.model_dir)
self.loaded_model = xgb.Booster()
self.loaded_model.load_model(self.model_dir)
return self
def train(self, data: ndarray)#, epochs: int = 100):
try:
model = tensorflow.keras.models.load_model(self.model_dir)
except OSError:
model = None
output_sequence_length = 100
if model is None:
model = xgb.XGBRegressor(random_state = 1)
# model = tensorflow.keras.models.Sequential()
# if len(self.neurons) > 1:
# model.add(tensorflow.keras.layers.LSTM(self.neurons[0][0],
# input_shape=(self.window_size, self.features),
# return_sequences=True))
# for ind, stack in enumerate(self.neurons[1:]):
# return_sequences = True
# if ind+1 == len(self.neurons)-1:
# return_sequences = False
# model.add(tensorflow.keras.layers.Dropout(stack[1]))
# model.add(tensorflow.keras.layers.LSTM(stack[0], return_sequences=return_sequences))
# else:
# model.add(tensorflow.keras.layers.LSTM(self.neurons[0][0],
# input_shape=(self.window_size, self.features)))
# model.add(tensorflow.keras.layers.Dense(1))
# optimizer = tensorflow.keras.optimizers.Adam(learning_rate=self.learning_rate)
# model.compile(optimizer=optimizer, loss='mean_squared_error')
# X_train, Y_train = [], []
# X_train_data = data
# Y_train_data = data.T[0].T
# for i in range(len(Y_train_data) - output_sequence_length - self.window_size):
# target_sequence = Y_train_data[i+self.window_size+output_sequence_length:i+self.window_size+output_sequence_length+1]
# Y_train.append(target_sequence)
# for i in range(len(X_train_data) - output_sequence_length - self.window_size):
# input_sequence = X_train_data[i:i+self.window_size]
# X_train.append(input_sequence)
# X_train = np.array(X_train)
# Y_train = np.array(Y_train)
# X_train = tensorflow.convert_to_tensor(np.array(X_train, dtype=np.float32))
# Y_train = tensorflow.convert_to_tensor(np.array(Y_train, dtype=np.float32))
X_train, Y_train = [], []
target = data[:, 0] # First column for the target
# X_train = data[:, 1:] # All other columns for features
#for i in range(len(data) - self.window_size):
# input_sequence = data[i:i + self.window_size]
# target_value = data[i + self.window_size]
# X_train.append(input_sequence)
# Y_train.append(target_value)
for i in range(len(data) - 1):
input_sequence = data[i]
target_value = target[i+1]
X_train.append(input_sequence)
Y_train.append(target_value)
X_train = np.array(X_train)
Y_train = np.array(Y_train)
X_train = tensorflow.convert_to_tensor(np.array(X_train, dtype=np.float32))
Y_train = tensorflow.convert_to_tensor(np.array(Y_train, dtype=np.float32))
# early_stopping = tensorflow.keras.callbacks.EarlyStopping(monitor="loss", patience=10,
# restore_best_weights=True)
model.fit(X_train, Y_train)#, epochs=epochs, batch_size=self.batch_size, callbacks=[early_stopping])
model.save_model(self.model_dir)
def predict(self, data: ndarray):
predictions = []
window_data = data[-1:]
# window_data = window_data.reshape(1, 1, self.features)
dtest = xgb.DMatrix(window_data)
predicted_value = self.loaded_model.predict(dtest)
predictions.append(predicted_value)
return predictions
@staticmethod
def base_model_dataset(samples):
min_cutoff = 0
cutoff_close = samples.tolist()[1][min_cutoff:]
cutoff_high = samples.tolist()[2][min_cutoff:]
cutoff_low = samples.tolist()[3][min_cutoff:]
cutoff_volume = samples.tolist()[4][min_cutoff:]
return np.array([cutoff_close,
cutoff_high,
cutoff_low,
cutoff_volume]).T |