def run_logreg(quality='high'): """ Runs a simple logistic regression model; first fits the model on the training data (70 percent of the total data) and tests on the rest of the data. Args: none Returns: none """ data = io.load_data(quality=quality) X, y, class_names = preprocessing.create_data_tensor(data) X_train, y_train, X_test, y_test = preprocessing.create_train_test_split( X, y, test_size=0.3, shuffle=True) # flatten data flattened_Xtrain = preprocessing.flatten_matrix(X_train) flattened_Xtest = preprocessing.flatten_matrix(X_test) # fit logistic regression model logreg_model = linear_model.LogisticRegression(multi_class='ovr') logreg_model.fit(flattened_Xtrain, y_train) y_predict_train = logreg_model.predict(flattened_Xtrain) y_predict = logreg_model.predict(flattened_Xtest) # print metrics and confusion plot analysis.run_analyses(y_predict_train, y_train, y_predict, y_test, class_names)
def run_svm(quality="high", ablation=False, concat=True): """ Runs a simple SVM model with a linear kernel; first fits the model on the training data (70 percent of the total data) and tests on the rest of the data. Args: None Returns: None """ data = io.load_data(quality=quality) X, y, class_names = preprocessing.create_data_tensor(data) if ablation: run_ablation_svm(X, y, class_names, quality) return X_train, y_train, X_test, y_test = preprocessing.create_train_test_split(X, y, test_size=0.3, shuffle=False) flattened_Xtrain = preprocessing.flatten_matrix(X_train) flattened_Xtest = preprocessing.flatten_matrix(X_test) if concat: X_train_400 = np.load('../data/seq_mining_features/k_2-w_2/X_train-400.npy') X_test_400 = np.load('../data/seq_mining_features/k_2-w_2/X_test-400.npy') y_train_400 = np.load('../data/seq_mining_features/k_2-w_2/y_train-400.npy') y_test_400 = np.load('../data/seq_mining_features/k_2-w_2/y_test-400.npy') print X_train_400.shape, y_train_400.shape print flattened_Xtrain.shape, y_train.shape print '-----------' print X_test_400.shape, y_test_400.shape print flattened_Xtest.shape, y_test.shape flattened_Xtrain_concatenated = np.hstack((flattened_Xtrain, X_train_400[:, 0:75])) flattened_Xtest_concatenated = np.hstack((flattened_Xtest, X_test_400[:, 0:75])) print '-----------' print flattened_Xtrain.shape, y_train.shape print flattened_Xtest.shape, y_test.shape C = 0.01 # fit svm model svm_model = svm.SVC(kernel="linear", C=C, decision_function_shape='ovr') svm_model.fit(flattened_Xtrain, y_train) y_predict_train = svm_model.predict(flattened_Xtrain) y_predict = svm_model.predict(flattened_Xtest) analysis.run_analyses(y_predict_train, y_train, y_predict, y_test, class_names, ablation=False, confusion=False) print '-----------==================-----------' svm_model = svm.SVC(kernel="linear", C=C, decision_function_shape='ovr') svm_model.fit(flattened_Xtrain_concatenated, y_train) y_predict_train = svm_model.predict(flattened_Xtrain_concatenated) y_predict = svm_model.predict(flattened_Xtest_concatenated) analysis.run_analyses(y_predict_train, y_train, y_predict, y_test, class_names, ablation=False, confusion=False) print '-----------==================-----------'
def main(): data = io.load_data(quality="low") X, y, class_names = preprocessing.create_data_tensor(data) X_train, y_train, X_test, y_test = preprocessing.create_train_test_split( X, y) X = preprocessing.scale_spatially(X) # for i in class_names: # # print i # # print class_names[i] # # print np.where(y==i) # # print np.where(y==i)[0] # # print np.where(y==i)[0].size # print class_names[i], i, np.where(y==i)[0].size # analysis.plot_signals_two_column(data[class_names[y[0]]][0][:, 0:3], # X[0, 0:3, :].T, # ['Raw X', 'Raw Y', 'Raw Z'], # ['Resampled X', 'Resampled Y', 'Resampled Z']) shop_idx = np.where(y == 3)[0] shop_idx = shop_idx[0:6] # print X[shop_idx, 0, :].shape NUM = 3 C1 = 0 C2 = 3 d1 = X[np.where(y == C1)[0][0:NUM], 2, :].T d2 = X[np.where(y == C2)[0][0:NUM], 2, :].T d1p = np.roll(d1, -1, 0) - d1 # d1p = d1p[0:d1.shape[0]-1] d1p[-1, :] = d1p[-2, :] d2p = np.roll(d2, -1, 0) - d2 d2p[-1, :] = d2p[-2, :] labels1 = [str(class_names[C1]) + ' ' + str(i) for i in xrange(NUM)] + [ str(class_names[C1]) + '\' ' + str(i) for i in xrange(NUM) ] labels2 = [str(class_names[C2]) + ' ' + str(i) for i in xrange(NUM)] + [ str(class_names[C2]) + '\' ' + str(i) for i in xrange(NUM) ] print d1.shape, d1p.shape print d2.shape, d2p.shape print np.concatenate((d1, d1p), 1).shape # analysis.plot_signals_two_column(np.concatenate((d1, d1p), 1), # np.concatenate((d2, d2p), 1), # labels1, # labels2) print class_names[4] d2 = X[np.where(y == 4)[0][0:2], 2, :].T analysis.plot_signals(d2, labels2)
def run_nn(quality='low'): """ Runs a simple neural network model; first fits the model on the training data (70 percent of the total data) and tests on the rest of the data. Args: none Returns: none """ data = io.load_data(quality=quality) X, y, class_names = preprocessing.create_data_tensor(data) X_train, y_train, X_test, y_test = preprocessing.create_train_test_split( X, y, test_size=0.3, shuffle=False) y_train_one_hot = np.zeros((y_train.shape[0], len(class_names))) for i in range(y_train.shape[0]): y_train_one_hot[i, y_train[i]] = 1 y_test_one_hot = np.zeros((y_test.shape[0], len(class_names))) for i in range(y_test.shape[0]): y_test_one_hot[i, y_test[i]] = 1 # flatten data flattened_Xtrain = preprocessing.flatten_matrix(X_train) flattened_Xtest = preprocessing.flatten_matrix(X_test) # fit neural network model HIDDEN_LAYER_SIZE = y_train_one_hot.shape[1] # HIDDEN_LAYER_SIZE = y_train_one_hot.shape[1]*2 ############ FAILED ################## # HIDDEN_LAYER_SIZE = X_train.shape[1] # ###################################### nn_model = Sequential() ####################################### MODELS ####################################### ####################################### MODEL1 ####################################### # Training Error: 0.517945411562 # Testing Error: 0.778446115288 # Epochs: 200 # nn_model.add( Dense(HIDDEN_LAYER_SIZE, input_dim=flattened_Xtrain.shape[1], init='uniform', activation="tanh")) nn_model.add(Dropout(0.2)) nn_model.add( Dense(y_train_one_hot.shape[1], init='uniform', activation="tanh")) N_EPOCHS = 200 ####################################### MODEL1 ####################################### ####################################### MODEL2 ####################################### # Training Error: 0. # Testing Error: 0. # # nn_model.add(Dense(HIDDEN_LAYER_SIZE, input_dim=flattened_Xtrain.shape[1], init='uniform', activation="tanh")) # nn_model.add(Dropout(0.2)) # nn_model.add(Dense(HIDDEN_LAYER_SIZE*10, activation="tanh", init='uniform')) # nn_model.add(Dropout(0.3)) # nn_model.add(Dense(HIDDEN_LAYER_SIZE*2, activation="tanh", init='uniform')) # nn_model.add(Dense(y_train_one_hot.shape[1], init='uniform', activation="tanh")) ####################################### MODEL2 ####################################### sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True) nn_model.compile(loss='mean_squared_error', optimizer=sgd) nn_model.fit(flattened_Xtrain, y_train_one_hot, nb_epoch=N_EPOCHS) y_predict_train = nn_model.predict_classes(flattened_Xtrain) y_predict = nn_model.predict_classes(flattened_Xtest) # y_predict_one_hot = nn_model.predict(flattened_Xtest) # print metrics and confusion plot analysis.run_analyses(y_predict_train, y_train, y_predict, y_test, class_names)
def seg_mining(use_all_signs): # Loading data data = io.load_data(quality="low") X, y, class_names = preprocessing.create_data_tensor(data) X_train, y_train, X_test, y_test = preprocessing.create_train_test_split( X, y, test_size=0.3, shuffle=False) if not use_all_signs: # TODO: change not break X_train = preprocessing.scale_spatially( X_train)[:NUM_SIGNS * EXAMPLES_PER_SIGN, :NUM_SIGNALS, :] y_train = y_train[:NUM_SIGNS * EXAMPLES_PER_SIGN] X_test = preprocessing.scale_spatially( X_test)[:NUM_SIGNS * (70 - EXAMPLES_PER_SIGN), :NUM_SIGNALS, :] y_test = y_test[:NUM_SIGNS * (70 - EXAMPLES_PER_SIGN)] else: X_train = preprocessing.scale_spatially(X_train) X_test = preprocessing.scale_spatially(X_test) # print X.shape # sys.exit() # Computing fake slopes dX_train = np.roll(X_train, -1, 2) - X_train dX_train[:, :, -1] = dX_train[:, :, -2] dX_test = np.roll(X_test, -1, 2) - X_test dX_test[:, :, -1] = dX_test[:, :, -2] combined_trends, combined_trends_interval_start, combined_trends_interval_end = create_combined_trends( dX_train) combined_trends_test, combined_trends_interval_start_test, combined_trends_interval_end_test = create_combined_trends( dX_test) # Computing trends # binary_I_idx_train = (INCREASING_THRESHOLD >= dX_train) & (dX_train > STEADY_THRESHOLD) # I_idx_train = np.where(binary_I_idx_train == 1) # binary_VI_idx_train = (VERY_INCREASING_THRESHOLD >= dX_train) & (dX_train > INCREASING_THRESHOLD) # VI_idx_train = np.where(binary_VI_idx_train == 1) # WI_idx_train = np.where(dX_train > VERY_INCREASING_THRESHOLD) # binary_D_idx_train = (-1*INCREASING_THRESHOLD <= dX_train) & (dX_train < -1*STEADY_THRESHOLD) # D_idx_train = np.where(binary_D_idx_train == 1) # binary_VD_idx_train = (-1*VERY_INCREASING_THRESHOLD <= dX_train) & (dX_train < -1*INCREASING_THRESHOLD) # VD_idx_train = np.where(binary_VD_idx_train == 1) # WD_idx_train = np.where(dX_train < -1*VERY_INCREASING_THRESHOLD) # S_idx_train = np.where(np.abs(dX_train) <= STEADY_THRESHOLD) # trends = np.zeros(dX_train.shape, dtype=np.int8) # trends[I_idx_train] = get_trend_idx_train('I') # trends[VI_idx_train] = get_trend_idx_train('VI') # trends[WI_idx_train] = get_trend_idx_train('WI') # trends[S_idx_train] = get_trend_idx_train('S') # trends[D_idx_train] = get_trend_idx_train('D') # trends[VD_idx_train] = get_trend_idx_train('VD') # trends[WD_idx_train] = get_trend_idx_train('WD') # I_idx_train = np.where(dX_train > STEADY_THRESHOLD) # S_idx_train = np.where(np.abs(dX_train) <= STEADY_THRESHOLD) # D_idx_train = np.where(dX_train < -1*STEADY_THRESHOLD) # trends = np.zeros(dX_train.shape, dtype=np.int8) # trends[I_idx_train] = get_trend_idx('I') # trends[S_idx_train] = get_trend_idx('S') # trends[D_idx_train] = get_trend_idx('D') # # print dX_train.shape, np.prod(dX_train.shape) # # print I_idx_train[0].shape, S_idx_train[0].shape, D_idx_train[0].shape # # print np.where(dX_train > STEADY_THRESHOLD) # # print np.where(trends == 0)[0].shape, np.where(trends == 1)[0].shape, np.where(trends == 2)[0].shape # # Combine trends # # Intervals are inclusive in nature # combined_trends = np.ones(trends.shape, dtype=np.int8) * get_trend_idx('useless') # combined_trends_interval_start = np.ones(trends.shape, dtype=np.int8) * get_trend_idx('useless') # combined_trends_interval_end = np.ones(trends.shape, dtype=np.int8) * get_trend_idx('useless') # for e in xrange(combined_trends.shape[0]): # for f in xrange(combined_trends.shape[1]): # combined_trend_idx = 0 # combined_trends[e,f,0] = trends[e,f,0] # combined_trends_interval_start[e,f,0] = 0 # for t in xrange(1, combined_trends.shape[2]): # if trends[e,f,t] != trends[e,f,t-1]: # # Set End time for previous trend # combined_trends_interval_end[e,f,combined_trend_idx] = t # # Start next trend # combined_trend_idx += 1 # combined_trends[e,f,combined_trend_idx] = trends[e,f,t] # combined_trends_interval_start[e,f,combined_trend_idx] = t # print trends[5, 3, :] # print combined_trends[5, 3, :] # print combined_trends_interval_start[5, 3, :] # print combined_trends_interval_end[5, 3, :] # NUM_SIGN = 3 # NUM_EXAMPLES = 70 # idx = NUM_SIGN*NUM_EXAMPLES # print trends[np.where(y==3)[0][0],3,:] # print combined_trends[np.where(y==3)[0][0],3,:] # print combined_trends_interval_start[np.where(y==3)[0][0],3,:] # print combined_trends_interval_end[np.where(y==3)[0][0],3,:] # support(combined_trends, None, 10) patterns = [None] * NUM_SIGNS pattern_counts = Counter() all_pattern_supports = [None] * NUM_SIGNS for i in xrange(NUM_SIGNS): print '' print 'For sign %d...' % i print 'Generating one patterns.....' one_patterns = generate_one_pattern(combined_trends) # support((combined_trends, combined_trends_interval_start, combined_trends_interval_end), # 'S:1-o;S:2-b;D:1-o;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1-b;D:1', # w=5, minsup=20) # sys.exit() k = 2 total_time = 0 patterns[i] = [one_patterns] all_pattern_supports[i] = [None] while True and k <= K: # generate_k_patterns print 'Generating patterns...' generation_start_time = time.time() total_time = 0 new_patterns, total_time = generate_k_patterns( patterns[i][k - 2], k, total_time) generation_end_time = time.time() print "k:", k, " -> New patterns:", len(new_patterns) print "Total time for generation: ", (generation_end_time - generation_start_time) print "Total time for comparison: ", (total_time) if len(new_patterns) == 0: break # prune_patterns print 'Pruning patterns...' combined_trends_sign = combined_trends[i * EXAMPLES_PER_SIGN:(i + 1) * EXAMPLES_PER_SIGN, :, :] combined_trends_interval_start_sign = combined_trends_interval_start[ i * EXAMPLES_PER_SIGN:(i + 1) * EXAMPLES_PER_SIGN, :, :] combined_trends_interval_end_sign = combined_trends_interval_end[ i * EXAMPLES_PER_SIGN:(i + 1) * EXAMPLES_PER_SIGN, :, :] pruned_patterns, pattern_supports = prune_patterns( (combined_trends_sign, combined_trends_interval_start_sign, combined_trends_interval_end_sign), new_patterns, MIN_SUPPORT, WINDOW_SIZE) all_pattern_supports[i].append(pattern_supports) for pattern in pattern_supports: pattern_counts[pattern] += 1 print "Pruned Patterns:", len(pruned_patterns) # increment k k += 1 # If no k patterns, break if len(pruned_patterns) == 0: break #print pruned_patterns.keys()[0] patterns[i].append(pruned_patterns) # patterns.append(new_patterns) # print "pruned patterns: " # print patterns[i] # print all_pattern_supports[i] ranked_patterns = chi_square(patterns, pattern_counts, all_pattern_supports)[:NUM_PATTERN_FEATURES] # cut some ranked_patterns out X_train_new = construct_feature_vectors(ranked_patterns, \ (combined_trends, combined_trends_interval_start, combined_trends_interval_end), EXAMPLES_PER_SIGN) X_test_new = construct_feature_vectors(ranked_patterns, \ (combined_trends_test, combined_trends_interval_start_test, combined_trends_interval_end_test), 70 - EXAMPLES_PER_SIGN) # print ranked_patterns[:NUM_PATTERN_FEATURES] # print len(ranked_patterns) # print X_train_new # print y_train svm_model = svm.SVC(C=.1, kernel="linear", decision_function_shape='ovr') svm_model.fit(X_train_new, y_train) y_predict_train = svm_model.predict(X_train_new) y_predict = svm_model.predict(X_test_new) analysis.run_analyses(y_predict_train, y_train, y_predict, y_test, class_names)
def seg_mining(use_all_signs): # Loading data data = io.load_data(quality="low") X, y, class_names = preprocessing.create_data_tensor(data) X_train, y_train, X_test, y_test = preprocessing.create_train_test_split(X, y, test_size=0.3, shuffle=False) # for class_idx in np.unique(y): # print class_names[class_idx], np.where(class_idx == y)[0].shape[0] # import sys # sys.exit(1) if not use_all_signs: # TODO: change not break X_train = preprocessing.scale_spatially(X_train)[:NUM_SIGNS * EXAMPLES_PER_SIGN,:NUM_SIGNALS,:] y_train = y_train[:NUM_SIGNS * EXAMPLES_PER_SIGN] X_test = preprocessing.scale_spatially(X_test)[:NUM_SIGNS * (70 - EXAMPLES_PER_SIGN),:NUM_SIGNALS,:] y_test = y_test[:NUM_SIGNS * (70 - EXAMPLES_PER_SIGN)] else: X_train = preprocessing.scale_spatially(X_train) X_test = preprocessing.scale_spatially(X_test) # Computing fake slopes dX_train = X_train dX_test = X_test # dX_train = np.roll(X_train, -1, 2) - X_train # dX_train[:, :, -1] = dX_train[:, :, -2] # dX_test = np.roll(X_test, -1, 2) - X_test # dX_test[:, :, -1] = dX_test[:, :, -2] combined_trends, combined_trends_interval_start, combined_trends_interval_end = sq.create_combined_trends_discritized(dX_train) combined_trends_test, combined_trends_interval_start_test, combined_trends_interval_end_test = sq.create_combined_trends_discritized(dX_test) patterns = [None] * NUM_SIGNS pattern_counts = Counter() all_pattern_supports = [None] * NUM_SIGNS threads = [] for i in xrange(NUM_SIGNS): process_sign(i, combined_trends, combined_trends_interval_start, combined_trends_interval_end, patterns, pattern_counts, all_pattern_supports) # thread = Thread(target=process_sign, args=(i, combined_trends, combined_trends_interval_start, combined_trends_interval_end, patterns, pattern_counts, all_pattern_supports)) # thread.start() # threads.append(thread) # for thread in threads: # thread.join() # process_sign(i, combined_trends, combined_trends_interval_start, combined_trends_interval_end, patterns, pattern_counts, all_pattern_supports) # for pattern_supports in all_pattern_supports[i]: # if pattern_supports is not None: # for pattern in pattern_supports: # pattern_counts[pattern] += 1 # cut some ranked_patterns out print 'Classes',len(patterns), len(all_pattern_supports) print 'Iterations',len(patterns[1]), len(all_pattern_supports[1]) # print 'patterns in iteration 1 ',len(patterns[1][0]), len(all_pattern_supports[1][0]) ranked_patterns_all = sq.chi_square(patterns, pattern_counts, all_pattern_supports) # NUM_PATTERN_FEATURES_ARRAY = [75, 100, 200, 300, 400, 500, 750, 1000, 1500] # NUM_PATTERN_FEATURES_ARRAY = [400, 500, 750, 1000, 1500, 2000, 2500] NUM_PATTERN_FEATURES_ARRAY = [NUM_PATTERN_FEATURES] for num_pattern_features in NUM_PATTERN_FEATURES_ARRAY: print '---------------------=================---------------------' ranked_patterns = ranked_patterns_all[:num_pattern_features] print len(ranked_patterns_all),'->',len(ranked_patterns) X_train_new = sq.construct_feature_vectors(ranked_patterns, \ (combined_trends, combined_trends_interval_start, combined_trends_interval_end), EXAMPLES_PER_SIGN) X_test_new = sq.construct_feature_vectors(ranked_patterns, \ (combined_trends_test, combined_trends_interval_start_test, combined_trends_interval_end_test), 70 - EXAMPLES_PER_SIGN) svm_model = svm.SVC(C=PENALTY, kernel="linear", decision_function_shape='ovr') svm_model.fit(X_train_new, y_train) y_predict_train = svm_model.predict(X_train_new) y_predict = svm_model.predict(X_test_new) # np.save('../data/seq_mining_features/X_train-%d.npy'%num_pattern_features, X_train_new) # np.save('../data/seq_mining_features/X_test-%d.npy'%num_pattern_features, X_test_new) # np.save('../data/seq_mining_features/y_train-%d.npy'%num_pattern_features, y_train) # np.save('../data/seq_mining_features/y_test-%d.npy'%num_pattern_features, y_test) analysis.run_analyses(y_predict_train, y_train, y_predict, y_test, class_names) print 'STEADY_THRESHOLD',STEADY_THRESHOLD print 'WINDOW_SIZE',WINDOW_SIZE print 'MIN_SUPPORT',MIN_SUPPORT print 'K',K print 'NUM_PATTERN_FEATURES',num_pattern_features print 'NUM_SIGNS',NUM_SIGNS print 'NUM_SIGNALS',NUM_SIGNALS print 'EXAMPLES_PER_SIGN',EXAMPLES_PER_SIGN print 'PENALTY',PENALTY print '---------------------=================---------------------'
def run_nn(quality='low'): """ Runs a simple neural network model; first fits the model on the training data (70 percent of the total data) and tests on the rest of the data. Args: none Returns: none """ data = io.load_data(quality=quality) X, y, class_names = preprocessing.create_data_tensor(data) X_train, y_train, X_test, y_test = preprocessing.create_train_test_split( X, y, test_size=0.3, shuffle=False) y_train_one_hot = np.zeros((y_train.shape[0], len(class_names))) for i in range(y_train.shape[0]): y_train_one_hot[i, y_train[i]] = 1 y_test_one_hot = np.zeros((y_test.shape[0], len(class_names))) for i in range(y_test.shape[0]): y_test_one_hot[i, y_test[i]] = 1 # flip last two axes # tensor: samples x features x time # tensor: samples x time x features X_train = np.swapaxes(X_train, 1, 2) X_test = np.swapaxes(X_test, 1, 2) print X_train.shape print y_train_one_hot.shape lstm_model = Sequential() ############################## MODEL 1 ############################## # Average Precision: 0.109463986213 # Average Recall: 0.0912280701754 # Average F1: 0.0664461045921 # Training Error: 0.852201933405 # Testing Error: 0.908771929825 # HIDDEN_LAYER = 300 # lstm_model.add(LSTM(output_dim=HIDDEN_LAYER, # input_dim=X_train.shape[2], # activation='tanh', # inner_activation='hard_sigmoid', # return_sequences=False)) # lstm_model.add(Dense(y_train_one_hot.shape[1], activation='tanh')) # lstm_model.compile(loss='mean_squared_error', optimizer='rmsprop') # lstm_model.fit(X_train, y_train_one_hot, batch_size=16, nb_epoch=10) ############################## MODEL 1 ############################## # ############################### MODEL 2 ############################## # Average Precision: 0.109463986213 # Average Recall: 0.0912280701754 # Average F1: 0.0664461045921 # Training Error: 0.852201933405 # Testing Error: 0.908771929825 HIDDEN_LAYER = 300 lstm_model.add( LSTM(output_dim=HIDDEN_LAYER, input_dim=X_train.shape[2], activation='tanh', inner_activation='hard_sigmoid', return_sequences=False)) lstm_model.add( LSTM(HIDDEN_LAYER, activation='tanh', inner_activation='hard_sigmoid', return_sequences=False)) lstm_model.add(Dense(y_train_one_hot.shape[1], activation='tanh')) lstm_model.compile(loss='mean_squared_error', optimizer='rmsprop') lstm_model.fit(X_train, y_train_one_hot, batch_size=16, nb_epoch=10) ############################## MODEL 2 ############################## # lstm_model.add(Dropout(0.5)) # lstm_model.add(Dense(95)) # lstm_model.add(Activation('softmax')) # score = model.evaluate(X_test, Y_test, batch_size=16) y_predict_train = lstm_model.predict_classes(X_train) y_predict = lstm_model.predict_classes(X_test) # y_predict_one_hot = nn_model.predict(flattened_Xtest) # print y_predict # print y_predict_one_hot # print metrics and confusion plot analysis.run_analyses(y_predict_train, y_train, y_predict, y_test, class_names, False, False) print y_predict