def train(self, X, Y, save_directory, batch_size=32, number_of_batches=None, window_size=256, learning_rate_val=0.05, nepoch_val=5000, decay=0.9, track_loss=False, first_index=0, save_distance=100): x_windows, y_end_values, N_batches, last_index = segment_signal(X, window_size, overlap=0.25, start_index=0) y_windows, y_end_values, N_batches, last_index = segment_signal(Y, window_size, overlap=0.25, start_index=0) window_indexes = np.random.permutation(N_batches) # randomly select windows # first mini_batch_dim are training - 70% x_train = x_windows[window_indexes[0:batch_size], :] y_train = y_windows[window_indexes[0:batch_size], :] # last windows are testing - 30% -> implement on cross_validation # testing_X_batch = X[window_indexes[mini_batch_dim:int(mini_batch_dim + mini_batch_dim * (0.3 / 0.7))], :] # testing_Y_batch = Y[window_indexes[mini_batch_dim:int(mini_batch_dim + mini_batch_dim * (0.3 / 0.7))], :] if track_loss: plt.ion() print("Start Processing") t1 = time.time() self.train_with_sgd(x_train, y_train, nepoch_val, decay, track_loss, save_directory, 0, save_distance=save_distance) print("Dataset trained in: ~%d seconds" % int(time.time() - t1)) self.save(save_directory, self.get_file_tag(-5, -5))
def train_signals(self, X, Y, signal2model, decay=0.9, track_loss=False, X_test=None, Y_test=None, use_random=True): hidden_dim = self.E.shape[0] signal_dim = self.E.shape[1] self.current_learning_rate = signal2model.learning_rate_val X_windows, y_end_values, N_batches, last_index = segment_signal(X, signal2model.window_size, overlap=0.33, start_index=0) Y_windows, y_end_values, N_batches, last_index = segment_signal(Y, signal2model.window_size, overlap=0.33, start_index=0) if use_random: window_indexes = np.random.permutation(N_batches) # randomly select windows else: window_indexes = list(range(N_batches)) # first n_windows are training x_train = X_windows[window_indexes[0:signal2model.batch_size], :] y_train = Y_windows[window_indexes[0:signal2model.batch_size], :] x_test = [] y_test = [] if (X_test is None) and (Y_test is None): # the rest are for testing x_test = X_windows[window_indexes[signal2model.batch_size:], :] y_test = Y_windows[window_indexes[signal2model.batch_size:], :] else: x_test, none1, none2, none3 = segment_signal(X, signal2model.window_size, overlap=0.25, start_index=0) y_test, none1, none2, none3 = segment_signal(Y, signal2model.window_size, overlap=0.25, start_index=0) self.save_test_data(self.get_file_tag(-1, -1), signal2model.signal_directory, [x_test, y_test]) x_test = [] y_test = [] X_windows = [] Y_windows =[] if track_loss: plt.show() plt.ion() print("Starting Processing") try: t1 = time.time() self.train_with_msgd(x_train, y_train, signal2model.number_of_epochs, decay, track_loss, signal2model.signal_directory, 0, save_distance=signal2model.save_interval) print("Dataset trained in: ~%d seconds" % int(time.time() - t1)) except: print("Error has occured in dataset: ", end=sys.exc_info()[0]) self.save(signal2model.signal_directory, self.get_file_tag(-5, -5))
def train_block(signals, signal2model, signal_indexes, n_for_each): model = GRU.LibPhys_GRU(signal_dim=signal2model.signal_dim, hidden_dim=signal2model.hidden_dim, signal_name=signal2model.signal_name, n_windows=signal2model.mini_batch_size) model.save(signal2model.signal_directory, model.get_file_tag(-1, -1)) x_train = [] y_train = [] for i in signal_indexes: X_windows, y_end_values, n_windows, last_index = segment_signal( signals[0][i], signal2model.window_size, overlap=0.33) Y_windows, y_end_values, n_windows, last_index = segment_signal( signals[1][i], signal2model.window_size, overlap=0.33) window_indexes = np.random.permutation( n_windows) # randomly select windows if len(x_train) == 0: x_train = X_windows[window_indexes[0:n_for_each], :] y_train = Y_windows[window_indexes[0:n_for_each], :] else: x_train = np.append(x_train, X_windows[window_indexes[0:n_for_each], :], axis=0) y_train = np.append(y_train, Y_windows[window_indexes[0:n_for_each], :], axis=0) x_test = X_windows[window_indexes[n_windows:], :] y_test = Y_windows[window_indexes[n_windows:], :] model.save_test_data(model.get_file_tag(-5, -5), signal2model.signal_directory, [x_test, y_test]) x_test = [] y_test = [] X_windows = [] Y_windows = [] t1 = time.time() model.train_with_msgd(x_train, y_train, signal2model.number_of_epochs, 0.9, track_loss=False, save_directory=signal2model.signal_directory, save_distance=signal2model.save_interval) print("Dataset trained in: ~%d seconds" % int(time.time() - t1)) model.save(signal2model.signal_directory, model.get_file_tag(-5, -5))
def generate_predicted_signal_2(self, full_signal, W, N=None): # LETS DO THIS!!! E, V, U, W, b, c = self.E, self.V, self.U, self.W, self.b, self.c if N is None: N = len(full_signal) x = theano.shared(segment_signal(full_signal, W, 0)) def forward_prop_step(x_t, s_t1_prev, s_t2_prev, s_t3_prev, index_prev): # Word embedding layer x_e = E[:, x_t] # hello_world_op = printing.Print('hello world') # GRU Layer 1 z_t1 = T.nnet.hard_sigmoid(U[0].dot(x_e) + W[0].dot(s_t1_prev) + b[0]) r_t1 = T.nnet.hard_sigmoid(U[1].dot(x_e) + W[1].dot(s_t1_prev) + b[1]) c_t1 = T.tanh(U[2].dot(x_e) + W[2].dot(s_t1_prev * r_t1) + b[2]) s_t1 = (T.ones_like(z_t1) - z_t1) * c_t1 + z_t1 * s_t1_prev # GRU Layer 2 z_t2 = T.nnet.hard_sigmoid(U[3].dot(s_t1) + W[3].dot(s_t2_prev) + b[3]) r_t2 = T.nnet.hard_sigmoid(U[4].dot(s_t1) + W[4].dot(s_t2_prev) + b[4]) c_t2 = T.tanh(U[5].dot(s_t1) + W[5].dot(s_t2_prev * r_t2) + b[5]) s_t2 = (T.ones_like(z_t2) - z_t2) * c_t2 + z_t2 * s_t2_prev # GRU Layer 3 z_t3 = T.nnet.hard_sigmoid(U[6].dot(s_t2) + W[6].dot(s_t3_prev) + b[6]) r_t3 = T.nnet.hard_sigmoid(U[7].dot(s_t2) + W[7].dot(s_t3_prev) + b[7]) c_t3 = T.tanh(U[8].dot(s_t2) + W[8].dot(s_t3_prev * r_t3) + b[8]) s_t3 = (T.ones_like(z_t3) - z_t3) * c_t3 + z_t3 * s_t3_prev # Final output calculation # Theano's softmax returns a matrix with one row, we only need the row o_t = T.nnet.softmax(V.dot(s_t3) + c)[0] return [o_t, s_t1, s_t2, s_t3, printed_x] [o, printed_x ], updates = theano.scan(forward_prop_step, sequences=x, truncate_gradient=self.bptt_truncate, outputs_info=[ None, dict(initial=T.zeros(self.hidden_dim)), dict(initial=T.zeros(self.hidden_dim)), dict(initial=T.zeros(self.hidden_dim)), dict(initial=T.zeros(self.hidden_dim)) ]) return T.argmax(o, axis=1)
def train(self, X, Y, save_directory, batch_size, number_of_batches, window_size, learning_rate_val, nepoch_val, decay, track_loss, first_index, save_distance): x_windows, y_end_values, N_batches, last_index = segment_signal(X, window_size, overlap=0.33, start_index=0) y_windows, y_end_values, N_batches, last_index = segment_signal(Y, window_size, overlap=0.33, start_index=0) window_indexes = np.random.permutation(N_batches) # randomly select windows # first n_windows are training x_train = x_windows[window_indexes[0:batch_size], :] y_train = y_windows[window_indexes[0:batch_size], :] if track_loss: plt.ion() print("Start Processing") t1 = time.time() self.train_with_msgd(x_train, y_train, nepoch_val, decay, track_loss, save_directory, 0, save_distance=save_distance) print("Dataset trained in: ~%d seconds" % int(time.time() - t1)) self.save(save_directory, self.get_file_tag(-5, -5))
def get_signals(n_samples, window_size=1024, train_ratio=0.67, overlap=0.5): # Gets training and testing segments files = sorted( glob.iglob(os.path.join(DATASET_DIRECTORY + '/*', '*_[1-2]m.mat'), recursive=True)) signals_train = [] signals_test = [] labels_train = [] labels_test = [] n_windows = int(n_samples / (window_size * overlap)) train_windows = int(n_windows * train_ratio) test_windows = int(n_windows * (1 - train_ratio)) for filename in files: # print(filename) original_signal = np.array( loadmat(os.path.join( DATASET_DIRECTORY, filename))['val'][0][:n_samples]) # 160000:160000+n_samples # print(original_signal.shape) # Signal Scaling #centered = original_signal - np.mean(original_signal) #original_signal = (original_signal - np.mean(original_signal)) / (np.max(original_signal) - np.min(original_signal)) original_signal = remove_noise(original_signal) original_signal = normalize(original_signal) original_signal = segment_signal(original_signal, window_size, overlap=overlap)[0] # print("Orig:", original_signal.shape) # print(train_windows, test_windows) # exit() train_signal = original_signal[:train_windows] test_signal = original_signal[train_windows:] signals_train.append(train_signal) signals_test.append(test_signal) labels_train.append( [filename.split('/')[-2] for i in range(train_windows)]) labels_test.append( [filename.split('/')[-2] for i in range(test_windows)]) return np.array(signals_train), np.array(signals_test), np.array( labels_train), np.array(labels_test)
return np.array(signals) # Read one signal sig = np.array( loadmat(os.path.join(DATASET_DIRECTORY, 'f1y01m.mat'))['val'][0][:70000]) # Normalize #sig = (sig - np.mean(sig)) / np.std(sig) sig = (np.max(sig) - sig) / (np.max(sig) - np.min(sig)) print(sig) #plt.plot(sig[0]) #plt.show() #exit() x = segment_signal(sig, 1024)[0].astype(np.float32) #x = segment_matrix(sig, 1024)[0].astype(np.float32) print(x.shape) model = Autoencoder() model.fit(x, n_epochs=200, save=False) pred = model.reconstruct(x)[0] #lr = model.get_adapt_lr() #np.save('/home/bento/lr.npy', lr) lr = np.load('/home/bento/lr.npy') #lr = (np.max(lr) - lr)/(np.max(lr) - np.min(lr)) #costs = model.get_cost_vector() #np.save('/home/bento/costs.npy', costs) costs = np.log(np.load('/home/bento/costs.npy'))
def train_block(signals_train, signals_test, signal2model, signal_indexes=None, n_for_each=16, overlap=0.33, random_training=True, start_index=0, track_loss=False, loss_interval=1, train_ratio=1): """ This method embraces several datasets (or one) according to a number of records for each :param signals: - list - a list containing two int vectors: signal - input vector X, used for the input; :param signal2model: - Signal2Model object - object containing the information about the model, for more info check Biosignals.utils.functions.signal2model :param signal_indexes: - list - a list containing the indexes of the "signals" variable to be trained. If None is given, all signals will be used. :param n_for_each: - int - number of windows from each signal to be inserted in the model training :param overlap: - float - value in the interval [0,1] that corresponds to the overlapping ratio of windows :param random_training: - boolean - value that if True random windows will be inserted in the training :param start_index: - int - value from which the windows will be selected :param track_loss: - boolean - value to plot loss as the model is trained :return: trained model """ if signal_indexes is None: signal_indexes = range(len(signals_train)) #self.save(signal2model.signal_directory, self.get_file_tag(-1, -1)) x_train = [] y_train = [] for i in signal_indexes: # Creation of the Time Windows from the dataset if n_for_each == 1: if len(x_train) == 0: x_train = signals_train[i][:signal2model.window_size] y_train = signals_test[i][ 1:signal2model.window_size + 1] # for next signal without noise, [1:window_size + 1] else: x_train = np.vstack( (x_train, signals_train[i][:signal2model.window_size])) y_train = np.vstack( (y_train, signals_test[i][1:signal2model.window_size + 1])) else: X_windows, y_end_values, n_windows, last_index = segment_signal( signals_train[i][:-1], signal2model.window_size, overlap=overlap, start_index=start_index) Y_windows, y_end_values, n_windows, last_index = segment_signal( signals_test[i][1:], signal2model.window_size, overlap=overlap, start_index=start_index) n_for_each = n_for_each if n_for_each < np.shape( X_windows)[0] else np.shape(X_windows)[0] n_for_each = n_for_each if n_for_each % signal2model.mini_batch_size == 0 \ else signal2model.mini_batch_size * int(n_for_each / signal2model.mini_batch_size) last_training_index = int(n_windows * train_ratio) # List of the windows to be inserted in the dataset if random_training: window_indexes = np.random.permutation( last_training_index) # randomly select windows else: window_indexes = list(range( (n_windows))) # first windows are selected # Insertion of the windows of this signal in the general dataset if len(x_train) == 0: # First is for train data x_train = X_windows[window_indexes[0:n_for_each], :] y_train = Y_windows[window_indexes[0:n_for_each], :] print("x_train shape:", x_train.shape) # # The rest is for test data # x_test = X_windows[last_training_index:, :] # y_test = Y_windows[last_training_index:, :] else: print("len != 0") x_train = np.append(x_train, X_windows[window_indexes[0:n_for_each], :], axis=0) y_train = np.append(y_train, Y_windows[window_indexes[0:n_for_each], :], axis=0) # x_test = np.append(x_train, X_windows[window_indexes[n_for_each:], :], axis=0) # y_test = np.append(x_train, Y_windows[window_indexes[n_for_each:], :], axis=0) # Save test data # self.save_test_data(signal2model.signal_directory, [x_test, y_test]) # Start time recording # Start training model model = LibphysMBGRU.LibphysMBGRU( signal2model ) #signal2model, ModelType.CROSS_MBSGD, params)) -> for LibphysGRU t1 = time.time() model.start_time = time.time() returned = model.train_model(x_train, y_train, signal2model, track_loss, loss_interval) print("Dataset trained in: ~%d seconds" % int(time.time() - t1)) # Model last training is then saved if returned: model.save(signal2model.signal_directory, model.get_file_tag(-5, -5)) return True else: return False
def process_error_by_prediction(filename): signals_models = db.signal_models signals_tests = db.signal_tests def load_model(model_info, N_Windows): model = GRU.LibPhys_GRU(model_info.Sd, hidden_dim=model_info.Hd, signal_name=model_info.dataset_name, n_windows=N_Windows) model.load(signal_name=model_info.dataset_name, filetag=model.get_file_tag(model_info.DS, model_info.t), dir_name=model_info.directory) return model def get_models(signal_models, N_Windows=None, index=None): models = [] if index is None: for model_info in signals_models: models.append(load_model(model_info,N_Windows)) else: model_info = signals_models[index] models.append(load_model(model_info,N_Windows)) return models signals = get_signals_tests(signals_tests, signals_models[0].Sd) W = 256 N_Windows = 20000 for m in range(len(signals_models)): models = [] models = get_models(signals_models, N_Windows, index=m) predicted_signals = list(range(len(signals_tests))) model_errors = list(range(len(signals_tests))) predicted_signals_ = list(range(len(signals_tests))) model_errors_ = list(range(len(signals_tests))) print("\nProcessing Model " + signals_models[m].name + ":") for s in range(len(signals)): print("\tProcessing Signal " + signals_tests[s].name + ";") signal = signals[s] if model_errors[s].__class__ is int: model_errors[s] = [] model_errors_[s] = [] predicted_signals_[s] = [] predicted_signals[s] = [] [segmented, y, N_Windows, last_index] = segment_signal(signal, W, 0, N_Windows) [x, e] = models[0].predict_class(segmented, y) predicted_signals[s].append(x[0,:]) predicted_signals_[s].append(x[-1, :]) model_errors[s].append(e[0,:]) model_errors_[s].append(e[-1, :]) limit = last_index + (N_Windows + W) print("processing...", end =" ") while limit < signals_tests[s].size: print(str(limit) + " of " + str(signals_tests[s].size), end="_") [segmented, y, N_Windows, last_index] = segment_signal(signal, W, 0, N_Windows, start_index=last_index) [x, e] = models[0].predict_class(segmented, y) predicted_signals[s][-1] = np.append(predicted_signals[s][-1], x[0,:]) predicted_signals[s][-1] = np.append(predicted_signals_[s][-1], x[-1, :]) model_errors[s][-1] = np.append(model_errors[s][-1], e[-1, :]) model_errors_[s][-1] = np.append(model_errors_[s][-1], e[-1, :]) # print(np.shape(predicted_signals[s][-1])) limit = last_index + (N_Windows + W) np.savez(filename + str(m) +".npz", predicted_signals=predicted_signals, model_errors=model_errors, predicted_signals_=predicted_signals, model_errors_=model_errors, signals_models=signals_models, signals_tests=signals_tests) print(filename + ".npz has been saved")
def calculate_loss_tensor(filename, Total_Windows, W, signals_models, signals=None, noisy_index=None): n_windows = Total_Windows if Total_Windows / 256 > 1: ratio = round(Total_Windows / 256) else: ratio = 1 n_windows = 250 windows = np.arange(int(Total_Windows / n_windows)) N_Windows = len(windows) N_Signals = len(signals_models) Total_Windows = int(N_Windows * n_windows) loss_tensor = np.zeros((N_Signals, N_Signals, Total_Windows)) N_Signals = len(signals_models) X_matrix = np.zeros((N_Signals, Total_Windows, W)) Y_matrix = np.zeros((N_Signals, Total_Windows, W)) i = 0 indexes = signals_models #[np.random.permutation(len(signals_models))] for model_info in indexes: if signals is None: # [x_test, y_test] = load_test_data("GRU_" + model_info.dataset_name, + "["+str(model_info.Sd)+"."+str(model_info.Hd)+".-1.-1.-1]" # , model_info.directory) [x_test, y_test] = load_test_data(model_info.dataset_name, model_info.directory) X_matrix[i, :, :], Y_matrix[i, :, :] = randomize_batch( x_test, y_test, Total_Windows) else: signals = get_signals_tests(db.ecg_noisy_signals[noisy_index - 1], index=i, noisy_index=noisy_index, peak_into_data=False) signal_test = segment_signal(signals[0][i], 256, 0.33) X_matrix[i, :, :], Y_matrix[i, :, :] = randomize_batch( signal_test[0], signal_test[1], Total_Windows) i += 1 print("Loading model...") model_info = signals_models[0] model = GRU.LibPhys_GRU(model_info.Sd, hidden_dim=model_info.Hd, signal_name=model_info.dataset_name, n_windows=n_windows) for m in range(len(signals_models)): model_info = signals_models[m] model.signal_name = model_info.dataset_name model.load(signal_name=model_info.name, filetag=model.get_file_tag(model_info.DS, model_info.t), dir_name=model_info.directory) print("Processing " + model_info.name) for s in range(N_Signals): print("Calculating loss for " + signals_models[s].name, end=';\n ') for w in windows: index = w * n_windows x_test = X_matrix[s, index:index + n_windows, :] y_test = Y_matrix[s, index:index + n_windows, :] loss_tensor[m, s, index:index + n_windows] = np.asarray( model.calculate_loss_vector(x_test, y_test)) np.savez(filename + ".npz", loss_tensor=loss_tensor, signals_models_=indexes, signals_models=signals_models) return loss_tensor, indexes
return models N_Windows = 2048 signal_ecg = get_signals_tests(signals_tests, signals_models[0].Sd, index=7)[0][0] signal_resp = get_signals_tests(signals_tests, signals_models[0].Sd, index=27)[0][0] # predicted_signals = list(range(len(signals_tests))) # model_errors = list(range(len(signals_tests))) fi = np.random.randint(0, 50000) W = 256 [ecg_segments_, y_ecg, _a, end_index] = segment_signal(signal_ecg, W, 0, N_Windows, start_index=fi) [resp_segments, y_resp, _a, end_index] = segment_signal(signal_resp, W, 0, N_Windows, start_index=fi) model = get_models(signals_models, index=0, N_Windows=N_Windows)[0] # [pred_signal_ecg,error] = model.predict_class(ecg_segments, y) [pred_signal_ecg, e_ecg] = model.predict_class(np.asarray(ecg_segments_, dtype=int), np.asarray(y_ecg, dtype=int)) [pred_signal_resp, e_resp] = model.predict_class(resp_segments, y_resp) print(e_ecg)
if history[-1] == "eeg": i = signal_info[2] else: X_train, Y_train = get_signals(signals_models[0]['Sd'], signal_info[1], peak_into_data=False) else: X_train, Y_train = get_signals(signals_models[0]['Sd'], signal_info[1], peak_into_data=False) history.append(signal_info[0]) N = len(X_train[i]) [X_segment_matrix, N_windows] = segment_signal(X_train[i], W) [Y_segment_matrix, N_windows] = segment_signal(Y_train[i], W) X_segment_matrix = np.reshape( X_segment_matrix, (1, np.shape(X_segment_matrix)[0], np.shape(X_segment_matrix)[1])) Y_segment_matrix = np.reshape( Y_segment_matrix, (1, np.shape(Y_segment_matrix)[0], np.shape(Y_segment_matrix)[1])) if len(X_loss_window_tensor) == 0: X_loss_window_tensor = X_segment_matrix Y_loss_window_tensor = Y_segment_matrix else: X_loss_window_tensor = np.append(X_loss_window_tensor, X_segment_matrix,
# Read one signal sig = np.array( loadmat(os.path.join(DATASET_DIRECTORY, 'f1y02m.mat'))['val'][0][:]) # lower bound to ignore artifacts for i in range(len(sig)): if sig[i] < 14670: sig[i] = 14670 # Normalize #sig = (sig - np.mean(sig)) / np.std(sig) x = (sig - np.min(sig)) / (np.max(sig) - np.min(sig)) * 2 - 1 #x = x[:35000] #x[810] += 1 x = segment_signal(x, 1024)[0] # print(x.shape) # plt.plot(x[0]) # plt.show() # print(x.shape) # plt.plot(x[1]) # plt.show() # exit() # peaks = peaks(sig, tol=0.65)#segment_signal(sig, 1024)[0].astype(np.float32) #print(peaks) # Put red circles on peaks # plt.plot(sig) # plt.title("Detected Peaks")
# colors = ['r', 'g', 'b', 'c', 'p'] # plt.plot(x, X_train[0][0:Z+1], label="RAW") # for m_index in range(len(signals_models)): # plt.plot(x, pred_signals[m_index,:], colors[m_index], label=signals_models[m_index]["s_name"]) # # plt.legend() # plt.draw() # plt.figure(B) # # for m_index in range(len(signals_models)): # plt.plot(x, errors[m_index, :], colors[m_index], label=signals_models[m_index]["s_name"]) # # plt.legend() # plt.show() segments_1 = segment_signal(errors[0, :], 256, 0) segments_2 = segment_signal(errors[1, :], 256, 0) segments_3 = segment_signal(errors[2, :], 256, 0) segments_4 = segment_signal(errors[3, :], 256, 0) stds_1 = np.std(segments_1[0], axis=1) stds_2 = np.std(segments_2[0], axis=1) stds_3 = np.std(segments_3[0], axis=1) stds_4 = np.std(segments_4[0], axis=1) stds = np.vstack((stds_1, stds_2, stds_3, stds_4)) loss = np.min(stds) plot_confusion_matrix def print_confusion(Mod, Sig, loss_tensor, signals_models, signals_tests):
def train_block(self, signals, signal2model, signal_indexes=None, n_for_each=12, overlap=0.33, random_training=True, start_index=0, track_loss=None, loss_interval=1): """ This method embraces several datasets (or one) according to a number of records for each :param signals: - list - a list containing two int vectors: signal - input vector X, used for the input; :param signal2model: - Signal2Model object - object containing the information about the model, for more info check Biosignals.utils.functions.signal2model :param signal_indexes: - list - a list containing the indexes of the "signals" variable to be trained. If None is given, all signals will be used. :param n_for_each: - int - number of windows from each signal to be inserted in the model training :param overlap: - float - value in the interval [0,1] that corresponds to the overlapping ratio of windows :param random_training: - boolean - value that if True random windows will be inserted in the training :param start_index: - int - value from which the windows will be selected :param track_loss: - boolean - value to plot loss as the model is trained :return: trained model """ if signal_indexes is None: signal_indexes = range(len(signals)) self.save(signal2model.signal_directory, self.get_file_tag(-1, -1)) n_for_each = int(n_for_each) x_train = [] y_train = [] for i in signal_indexes: # Creation of the Time Windows from the dataset X_windows, y_end_values, n_windows, last_index = segment_signal(signals[i][:-1], signal2model.window_size, overlap=overlap, start_index=start_index) Y_windows, y_end_values, n_windows, last_index = segment_signal(signals[i][1:], signal2model.window_size, overlap=overlap, start_index=start_index) last_training_index = int(n_windows * 0.33) # List of the windows to be inserted in the dataset if random_training: window_indexes = np.random.permutation(last_training_index) # randomly select windows else: window_indexes = list(range((n_windows))) # first windows are selected # Insertion of the windows of this signal in the general dataset if len(x_train) == 0: # First is for train data x_train = X_windows[window_indexes[0:n_for_each], :] y_train = Y_windows[window_indexes[0:n_for_each], :] # The rest is for test data x_test = X_windows[last_training_index:, :] y_test = Y_windows[last_training_index:, :] else: x_train = np.append(x_train, X_windows[window_indexes[0:n_for_each], :], axis=0) y_train = np.append(y_train, Y_windows[window_indexes[0:n_for_each], :], axis=0) x_test = np.append(x_train, X_windows[window_indexes[n_for_each:], :], axis=0) y_test = np.append(x_train, Y_windows[window_indexes[n_for_each:], :], axis=0) # Save test data self.save_test_data(signal2model.signal_directory, [x_test, y_test]) # Start time recording self.start_time = time.time() t1 = time.time() # Start training model self.train_model(x_train, y_train, signal2model, track_loss, loss_interval) print("Dataset trained in: ~%d seconds" % int(time.time() - t1)) # Model last training is then saved self.save(signal2model.signal_directory, self.get_file_tag(-5, -5))