def train_save_model(): grade_four_shoot_info_4_with_feature = pd.read_excel( '../shootweb/data/grade_four_shoot_info_4_with_feature.xlsx') grade_four_shoot_info_6_with_feature = pd.read_excel( '../shootweb/data/grade_four_shoot_info_6_with_feature.xlsx') grade_four_shoot_info_8_with_feature = pd.read_excel( '../shootweb/data/grade_four_shoot_info_8_with_feature.xlsx') all_shoot_info = grade_four_shoot_info_8_with_feature.append( grade_four_shoot_info_6_with_feature) all_shoot_info = all_shoot_info.append( grade_four_shoot_info_4_with_feature) all_shoot_info['label'] = all_shoot_info['grade'].apply( lambda value: 1 if value == 10 else 0) all_shoot_info = all_shoot_info[all_shoot_info['move_distance'] > 60] all_feature_names = [ 'x_pos', 'y_pos', 'heart_rate', 'y_stability', 'x_average' ] all_label_name = 'label' all_shoot_features = all_shoot_info[all_feature_names].copy() all_shoot_labels = all_shoot_info[all_label_name].copy() train_x_all, test_x_all, train_y_all, test_y_all = train_test_split( all_shoot_features, all_shoot_labels, test_size=0.3, random_state=42) shoot_reg_all = RandomForestClassifier() shoot_reg_all.fit(train_x_all, train_y_all) shoot_dt_predictions_all = shoot_reg_all.predict(test_x_all) label_class_all = list(set(all_shoot_labels.values)) meu.display_model_performance_metrics( true_labels=test_y_all, predicted_labels=shoot_dt_predictions_all, classes=label_class_all) joblib.dump(shoot_reg_all, '../shootweb/data/shoot_reg_all.pkl') return show_importance(shoot_reg_all, all_feature_names)
def readFromCSV(): dataset = pd.read_csv(r'CSVs/tweets_main.csv') reviews = np.array(dataset['review']) sentiments = np.array(dataset['sentiment']) # extract data for model evaluation test_reviews = reviews[:5000] test_sentiments = sentiments[:5000] #sample_review_ids = [7626, 3533, 13010] # normalize dataset norm_test_reviews = tn.normalize_corpus(test_reviews) predicted_sentiments = [ analyze_sentiment_sentiwordnet_lexicon(review, verbose=False) for review in norm_test_reviews ] meu.display_model_performance_metrics( true_labels=test_sentiments, predicted_labels=predicted_sentiments, classes=['positive', 'negative'])
model.add(Embedding(input_dim=vocab_size, output_dim=EMBEDDING_DIM, input_length=max_len)) model.add(SpatialDropout1D(0.2)) model.add(LSTM(LSTM_DIM, dropout=0.2, recurrent_dropout=0.2)) model.add(Dense(1, activation="sigmoid")) model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"]) print(model.summary()) # Visualize model architecture from IPython.display import SVG from keras.utils.vis_utils import model_to_dot SVG(model_to_dot(model, show_shapes=True, show_layer_names=False, rankdir='TB').create(prog='dot', format='svg')) # Train the model batch_size = 100 model.fit(train_X, train_y, epochs=5, batch_size=batch_size, shuffle=True, validation_split=0.1, verbose=1) # Predict and Evaluate Model Performance pred_test = model.predict_classes(test_X) predictions = le.inverse_transform(pred_test.flatten()) meu.display_model_performance_metrics(true_labels=test_sentiments, predicted_labels=predictions, classes=['positive', 'negative'])
def get_bottleneck_features(model, input_imgs): features = model.predict(input_imgs, verbose=0) return features IMG_DIM = (150, 150) test_files = glob.glob('test_data/*') test_imgs = [ img_to_array(load_img(img, target_size=IMG_DIM)) for img in test_files ] test_imgs = np.array(test_imgs) test_labels = [fn.split('\\')[1].split('.')[0].strip() for fn in test_files] test_imgs_scaled = test_imgs.astype('float32') test_imgs_scaled /= 255 test_labels_enc = class2num_label_transformer(test_labels) print('Test dataset shape:', test_imgs.shape) print(test_labels[0:5], test_labels_enc[0:5]) predictions = tl_img_aug_cnn.predict_classes(test_imgs_scaled, verbose=0) predictions = num2class_label_transformer(predictions) meu.display_model_performance_metrics(true_labels=test_labels, predicted_labels=predictions, classes=list(set(test_labels))) print("Predicted=%s" % (predictions[0])) plt.imshow(test_imgs_scaled[0]) plt.show()
# ## Train a Model using Logistic Regression # In[6]: from sklearn.linear_model import LogisticRegression wtp_lr = LogisticRegression() wtp_lr.fit(wtp_train_SX, wtp_train_y) # ## Predict and Evaluate Model Performance # In[7]: wtp_lr_predictions = wtp_lr.predict(wtp_test_SX) meu.display_model_performance_metrics(true_labels=wtp_test_y, predicted_labels=wtp_lr_predictions, classes=['red', 'white']) # ## Train a Model using Deep Learning (MLP) # ### Encode Response class labels # In[8]: le = LabelEncoder() le.fit(wtp_train_y) # encode wine type labels wtp_train_ey = le.transform(wtp_train_y) wtp_test_ey = le.transform(wtp_test_y) # ### Build & Compile DNN Model Architecture
def plot(self, labels, predictions): meu.display_model_performance_metrics(true_labels=labels, predicted_labels=predictions, classes=list(set(labels))) import Plot_conf_matrix as pl pl.plot_confusion_matrix(labels,predictions,['8','9','12','22'], normalize=True) plt.show()
lr = LogisticRegression(penalty='l2', max_iter=100, C=1) lr_bow_predictions = meu.train_predict_model(classifier=lr, train_features= train_features, train_labels=train_sentiments, test_features=test_features, test_labels=test_sentiments) print(test_features) print(test_sentiments) print(lr_bow_predictions) -------------------------------------------------------------------------------------------------- Actual Senitments - ['negative' 'positive' 'negative' ... 'negative' 'negative' 'negative'] Predicted Sentiments - ['negative' 'positive' 'negative' ... 'positive' 'negative' 'negative'] ---------------------------------------------------------------------------------------------------- meu.display_model_performance_metrics(true_labels=test_sentiments, predicted_labels=lr_bow_predictions, classes=['positive', 'negative']) ''' Model Performance metrics: ------------------------------ Accuracy: 0.8897 Precision: 0.8899 Recall: 0.8897 F1 Score: 0.8897 Model Classification report: ------------------------------ precision recall f1-score support
base_score=0.5, objective='binary:logistic', random_state=42) xgc.fit(X_train, y_train) from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score model = LogisticRegression() model.fit(X_train, y_train) y_pred = model.predict(X_test) print(accuracy_score(y_test, y_pred)) predictions = xgc.predict(X_test) predictions[:50] class_labels = list(set(labels)) meu.display_model_performance_metrics(true_labels=y_test, predicted_labels=predictions, classes=class_labels) fig = plt.figure(figsize=(16, 12)) title = fig.suptitle("Default Feature Importances from XGBoost", fontsize=14) ax1 = fig.add_subplot(2, 2, 1) xgb.plot_importance(xgc, importance_type='weight', ax=ax1) t = ax1.set_title("Feature Importance - Feature Weight") ax2 = fig.add_subplot(2, 2, 2) xgb.plot_importance(xgc, importance_type='gain', ax=ax2) t = ax2.set_title("Feature Importance - Split Mean Gain") ax3 = fig.add_subplot(2, 2, 3) xgb.plot_importance(xgc, importance_type='cover', ax=ax3) t = ax3.set_title("Feature Importance - Sample Coverage")
# make a prediction y_pred = model.predict(stackedX) return y_pred # fit stacked model using the ensemble model = fit_stacked_model(members, train_data_iot, train_label_iot_original) # evaluate model on test set y_pred = stacked_prediction(members, model, train_labels_iot) print(y_pred) #accyracy score of stacked model stack_acc = accuracy_score(test_label_iot_original, y_pred) print('Trabsfer learning Accuracy (feature extraction): %.3f' % stack_acc) class_labels = [0, 1] meu.display_model_performance_metrics(true_labels=test_label_iot_original, predicted_labels=y_pred, classes=class_labels) _= xai.metrics_plot(test_label_iot_original, y_pred) _ = xai.roc_plot(test_label_iot_original, y_pred) d = xai.smile_imbalance(test_label_iot_original, y_pred) d[["correct", "incorrect"]].sum().plot.bar() # define ensemble model stacked_model = define_stacked_model(members) print(stacked_model) # fit stacked model on test dataset fit_integrated_stacked_model(stacked_model, train_data_iot, test_data_iot)
# prepare datasets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) # build default SVM model def_svc = SVC(random_state=42) def_svc.fit(X_train, y_train) # predict and evaluate performance def_y_pred = def_svc.predict(X_test) print('Default Model Stats:') meu.display_model_performance_metrics(true_labels=y_test, predicted_labels=def_y_pred, classes=[0, 1]) # ## Tune Model with Grid Search # In[181]: from sklearn.model_selection import GridSearchCV # setting the parameter grid grid_parameters = { 'kernel': ['linear', 'rbf'], 'gamma': [1e-3, 1e-4], 'C': [1, 10, 50, 100] }
history = model.fit(train_x_scaled, train_y, batch_size=32, epochs=10, verbose=1) # In[ ]: test_predictions = model.predict(test_x_scaled) test_predictions_labelled = [0 if x<0.1 else 1 for x in test_predictions] # In[ ]: # Display performance metrics meu.display_model_performance_metrics(true_labels=test_y, predicted_labels=test_predictions_labelled, classes=list(set(test_y))) # In[ ]: # Extract just fire images for augmentation # TODO: this is not very efficient data_df = pd.DataFrame(data) just_fire = data_df[data_df[1] ==1] just_fire_images = just_fire[0].tolist() just_fire_labels = just_fire[1].tolist() # In[ ]: