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[ ]:
