data = pd.read_csv('jaccard_neo2.csv', delimiter = ',') 
data = data.drop(columns=['Unnamed: 0','from', 'Ingredient1', 'to', 'Ingredient2', 'similarity'])
data

data.groupby('Labeling').URIFrom.count()

fig = plt.figure(figsize=(10,7))
data.groupby('Labeling').URIFrom.count().plot.bar(ylim=0)
plt.show()

banding = data.groupby('Labeling').URIFrom.count()
plt.pie(banding)
labels = [0,1]
plt.pie(banding, labels=labels, autopct='%.2f')
plt.show()

# Embedding Hasil Node2Vec
embedding_df = pd.read_csv(vectors, delimiter = ',')
embedding_df
#embedding_df.to_csv('node2vec.csv')

# Embedding Hasil RDF2Vec
embedding_df2 = pd.read_csv(vectors2, delimiter = ',') 
embedding_df2 = embedding_df2.drop(columns= ['Unnamed: 0'])
embedding_df2
#embedding_df.to_csv('rdf2vec.csv')

merge1

merge2

from collections import Counter
counter = Counter(y)
print(counter)

# summarize the new class distribution
counter = Counter(y)
print(counter)

#Import scikit-learn metrics module for accuracy calculation
# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
print("F1 Score",metrics.f1_score(y_test, y_pred))
print("Precision",metrics.precision_score(y_test, y_pred))
print("Recall",metrics.recall_score(y_test, y_pred))

cm = metrics.confusion_matrix(y_test,y_pred)
cm

#Node2Vec
RF = RandomForestClassifier()
NB = GaussianNB()
SVM = svm.SVC()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

ss = 1, 0.5, 0.33
train_size = [0.7]
clf = [RF]
#, NB, SVM, LR, GBT
for clfs in clf :
    for s in ss:
        X = merge1.loc[:, merge1.columns != 'Labeling']
        y = merge1.loc[:, merge1.columns == 'Labeling']
        y=y['Labeling'] 
        
        over = SMOTE(sampling_strategy=0.002)
        under = RandomUnderSampler(sampling_strategy=s)
        steps = [('o', over), ('u', under)]
        pipeline = Pipeline(steps=steps)
        
        X, y = pipeline.fit_resample(X, y)
        for f in train_size :
        
            X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
            clfs.fit(X_train, y_train)
            #score_test = rf.score(X_test, y_test)
            predict = clfs.predict(X_test)
            score_test1 = metrics.f1_score(y_test, predict)
            print("F1-Score Random Forest with Train size %.2f : %.3f%%" % (f, score_test1*100))
    
            score_test2 = metrics.accuracy_score(y_test, predict)
            print("Accuracy Random Forest with Train size %.2f : %.3f%%" % (f, score_test2*100))
        
            score_test3 = metrics.precision_score(y_test, predict)
            print("Precision Random Forest with Train size %.2f : %.3f%%" % (f, score_test3*100))
     
            score_test4 = metrics.recall_score(y_test, predict)
            print("Recall Random Forest with Train size %.2f : %.3f%%" % (f, score_test4*100))

#RDF2Vec
RF = RandomForestClassifier()
NB = GaussianNB()
SVM = svm.SVC()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

ss = 1, 0.5, 0.33
train_size = [0.7]
clf = [RF]
#, NB, SVM, LR, GBT
for clfs in clf :
    for s in ss:
        X = merge2.loc[:, merge2.columns != 'Labeling']
        y = merge2.loc[:, merge2.columns == 'Labeling']
        y=y['Labeling'] 
        
        over = SMOTE(sampling_strategy=0.002)
        under = RandomUnderSampler(sampling_strategy=s)
        steps = [('o', over), ('u', under)]
        pipeline = Pipeline(steps=steps)
        
        X, y = pipeline.fit_resample(X, y)
        for f in train_size :
        
            X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
            clfs.fit(X_train, y_train)
            #score_test = rf.score(X_test, y_test)
            predict = clfs.predict(X_test)
            score_test1 = metrics.f1_score(y_test, predict)
            print("F1-Score Random Forest with Train size %.2f : %.3f%%" % (f, score_test1*100))
    
            score_test2 = metrics.accuracy_score(y_test, predict)
            print("Accuracy Random Forest with Train size %.2f : %.3f%%" % (f, score_test2*100))
        
            score_test3 = metrics.precision_score(y_test, predict)
            print("Precision Random Forest with Train size %.2f : %.3f%%" % (f, score_test3*100))
     
            score_test4 = metrics.recall_score(y_test, predict)
            print("Recall Random Forest with Train size %.2f : %.3f%%" % (f, score_test4*100))

X = merge1.loc[:, merge1.columns != 'Labeling']
y = merge1.loc[:, merge1.columns == 'Labeling']
y=y['Labeling'] 
        
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)

#Node2Vec
RF = RandomForestClassifier()
NB = GaussianNB()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

ss = 1, 0.5, 0.33
train_size = [0.8, 0.75, 0.7, 0.6]
clf = [RF]
kfold = KFold(n_splits=5, shuffle=True, random_state=42)

#, NB, SVM, LR, GBT
for clfs in clf :
    for f in train_size :
            
        X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
        clfs.fit(X_train, y_train)
        #score_test = rf.score(X_test, y_test)
        predict = clfs.predict(X_test)
        score_test = metrics.f1_score(y_test, predict)
        print(cross_val_score(clfs, X, y, cv=kfold, scoring="f1"))

#Node2Vec
RF = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 80, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='gini')
NB = GaussianNB()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

ss = 1, 0.5, 0.33
train_size = [0.8, 0.75, 0.7, 0.6]
clf = [RF]
kfold = KFold(n_splits=5, shuffle=True, random_state=42)

#, NB, SVM, LR, GBT
for clfs in clf :
    for f in train_size :
            
        X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
        clfs.fit(X_train, y_train)
        #score_test = rf.score(X_test, y_test)
        predict = clfs.predict(X_test)
        score_test = metrics.f1_score(y_test, predict)
        print(cross_val_score(clfs, X, y, cv=kfold, scoring="f1"))

X = merge2.loc[:, merge2.columns != 'Labeling']
y = merge2.loc[:, merge2.columns == 'Labeling']
y=y['Labeling'] 
        
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)

#RDF2Vec
RF = RandomForestClassifier()
NB = GaussianNB()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

ss = 1, 0.5, 0.33
train_size = [0.8, 0.75, 0.7, 0.6]
clf = [RF]
kfold = KFold(n_splits=5, shuffle=True, random_state=42)

#, NB, SVM, LR, GBT
for clfs in clf :
    for f in train_size :
            
        X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
        clfs.fit(X_train, y_train)
        #score_test = rf.score(X_test, y_test)
        predict = clfs.predict(X_test)
        score_test = metrics.f1_score(y_test, predict)
        print(cross_val_score(clfs, X, y, cv=kfold, scoring="f1"))

#RDF2Vec
RF = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 90, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='entropy')
NB = GaussianNB()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

ss = 1, 0.5, 0.33
train_size = [0.8, 0.75, 0.7, 0.6]
clf = [RF]
kfold = KFold(n_splits=5, shuffle=True, random_state=42)

#, NB, SVM, LR, GBT
for clfs in clf :
    for f in train_size :
            
        X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
        clfs.fit(X_train, y_train)
        #score_test = rf.score(X_test, y_test)
        predict = clfs.predict(X_test)
        score_test = metrics.f1_score(y_test, predict)
        print(cross_val_score(clfs, X, y, cv=kfold, scoring="f1"))

kFold = 5
print(cross_val_score(RF, X, y, cv=kfold, scoring="accuracy"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="accuracy").mean())
print(cross_val_score(RF, X, y, cv=kfold, scoring="precision"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="precision").mean())
print(cross_val_score(RF, X, y, cv=kfold, scoring="recall"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="recall").mean())
print(cross_val_score(RF, X, y, cv=kfold, scoring="f1"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="f1").mean())

print(cross_val_score(RF, X, y, cv=kfold, scoring="accuracy"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="accuracy").mean())
print(cross_val_score(RF, X, y, cv=kfold, scoring="precision"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="precision").mean())
print(cross_val_score(RF, X, y, cv=kfold, scoring="recall"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="recall").mean())
print(cross_val_score(RF, X, y, cv=kfold, scoring="f1"))
print(cross_val_score(RF, X, y, cv=kfold, scoring="f1").mean())

# Node2Vec
X = merge1.loc[:, merge1.columns != 'Labeling']
y = merge1.loc[:, merge1.columns == 'Labeling']
y=y['Labeling'] 
        
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)
# Membandingkan Decision Tree dengan berbagai train size
RF = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 80, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='gini')
NB = GaussianNB()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

train_size = [0.7]
rforest = [RF, NB, LR, GBT]
for rf in rforest :
  for f in train_size :
        
    X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
    rf.fit(X_train, y_train)
    #score_test = rf.score(X_test, y_test)
    predict = rf.predict(X_test)
    score_test1 = metrics.f1_score(y_test, predict)
    if rf == RF: print("F1-Score Random Forest with Train size %.2f : %.3f%%" % (f, score_test1*100))
    if rf == NB: print("F1-Score NB with Train size %.2f : %.3f%%" % (f, score_test1*100))
    if rf == LR: print("F1-Score LR with Train size %.2f : %.3f%%" % (f, score_test1*100))
    if rf == GBT: print("F1-Score GBT with Train size %.2f : %.3f%%" % (f, score_test1*100))
    
    score_test2 = metrics.accuracy_score(y_test, predict)
    if rf == RF: print("Accuracy Random Forest with Train size %.2f : %.3f%%" % (f, score_test2*100))
    if rf == NB: print("Accuracy NB with Train size %.2f : %.3f%%" % (f, score_test2*100))
    if rf == LR: print("Accuracy LR with Train size %.2f : %.3f%%" % (f, score_test2*100))
    if rf == GBT: print("Accuracy GBT with Train size %.2f : %.3f%%" % (f, score_test2*100))
        
    score_test3 = metrics.precision_score(y_test, predict)
    if rf == RF: print("Precision Random Forest with Train size %.2f : %.3f%%" % (f, score_test3*100))
    if rf == NB: print("Precision NB with Train size %.2f : %.3f%%" % (f, score_test3*100))
    if rf == LR: print("Precision LR with Train size %.2f : %.3f%%" % (f, score_test3*100))
    if rf == GBT: print("Precision GBT with Train size %.2f : %.3f%%" % (f, score_test3*100))
     
    score_test4 = metrics.recall_score(y_test, predict)
    if rf == RF: print("Recall Random Forest with Train size %.2f : %.3f%%" % (f, score_test4*100))
    if rf == NB: print("Recall NB with Train size %.2f : %.3f%%" % (f, score_test4*100))
    if rf == LR: print("Recall LR with Train size %.2f : %.3f%%" % (f, score_test4*100))
    if rf == GBT: print("Recall GBT with Train size %.2f : %.3f%%" % (f, score_test4*100))

rf_auc1 = roc_auc_score(y_test,rf_probs1)
nb_auc1 = roc_auc_score(y_test,nb_probs1)
lr_auc1 = roc_auc_score(y_test,lr_probs1)
gbt_auc1 = roc_auc_score(y_test,gbt_probs1)
print('Random Forest = %.3f' % (rf_auc1))
print('Naive Bayes = %.3f' % (nb_auc1))
print('Logistic Regressio = %.3f' % (lr_auc1))
print('Gradient Boosting = %.3f' % (gbt_auc1))

plt.plot(rf_rpr1, rf_tpr1, marker= '.', label = 'Random Forest (AUROC = %0.3f)' % rf_auc1)
plt.plot(nb_rpr1, nb_tpr1, marker= '.', label = 'Naive Bayes (AUROC = %0.3f)' % nb_auc1)
plt.plot(lr_rpr1, lr_tpr1, marker= '.', label = 'Logistic Regression (AUROC = %0.3f)' % lr_auc1)
plt.plot(gbt_rpr1, gbt_tpr1, marker= '.', label = 'Gaussian BT (AUROC = %0.3f)' % gbt_auc1)
plt.title('ROC Plot')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend()
plt.show()

# RDF2Vec
X = merge2.loc[:, merge2.columns != 'Labeling']
y = merge2.loc[:, merge2.columns == 'Labeling']
y=y['Labeling'] 
        
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)
# Membandingkan Decision Tree dengan berbagai train size
RF = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 90, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='entropy')
NB = GaussianNB()
LR = linear_model.LogisticRegression()
GBT = ensemble.GradientBoostingClassifier()

train_size = [0.7]
rforest = [RF, NB, LR, GBT]
for rf in rforest :
  for f in train_size :
        
    X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=f, random_state=42)
    
    rf.fit(X_train, y_train)
    #score_test = rf.score(X_test, y_test)
    predict = rf.predict(X_test)
    score_test1 = metrics.f1_score(y_test, predict)
    if rf == RF: print("F1-Score Random Forest with Train size %.2f : %.3f%%" % (f, score_test1*100))
    if rf == NB: print("F1-Score NB with Train size %.2f : %.3f%%" % (f, score_test1*100))
    if rf == LR: print("F1-Score LR with Train size %.2f : %.3f%%" % (f, score_test1*100))
    if rf == GBT: print("F1-Score GBT with Train size %.2f : %.3f%%" % (f, score_test1*100))
    
    score_test2 = metrics.accuracy_score(y_test, predict)
    if rf == RF: print("Accuracy Random Forest with Train size %.2f : %.3f%%" % (f, score_test2*100))
    if rf == NB: print("Accuracy NB with Train size %.2f : %.3f%%" % (f, score_test2*100))
    if rf == LR: print("Accuracy LR with Train size %.2f : %.3f%%" % (f, score_test2*100))
    if rf == GBT: print("Accuracy GBT with Train size %.2f : %.3f%%" % (f, score_test2*100))
        
    score_test3 = metrics.precision_score(y_test, predict)
    if rf == RF: print("Precision Random Forest with Train size %.2f : %.3f%%" % (f, score_test3*100))
    if rf == NB: print("Precision NB with Train size %.2f : %.3f%%" % (f, score_test3*100))
    if rf == LR: print("Precision LR with Train size %.2f : %.3f%%" % (f, score_test3*100))
    if rf == GBT: print("Precision GBT with Train size %.2f : %.3f%%" % (f, score_test3*100))
     
    score_test4 = metrics.recall_score(y_test, predict)
    if rf == RF: print("Recall Random Forest with Train size %.2f : %.3f%%" % (f, score_test4*100))
    if rf == NB: print("Recall NB with Train size %.2f : %.3f%%" % (f, score_test4*100))
    if rf == LR: print("Recall LR with Train size %.2f : %.3f%%" % (f, score_test4*100))
    if rf == GBT: print("Recall GBT with Train size %.2f : %.3f%%" % (f, score_test4*100))

rf_auc2 = roc_auc_score(y_test,rf_probs2)
nb_auc2 = roc_auc_score(y_test,nb_probs2)
lr_auc2 = roc_auc_score(y_test,lr_probs2)
gbt_auc2 = roc_auc_score(y_test,gbt_probs2)
print('Random Forest = %.3f' % (rf_auc2))
print('Naive Bayes = %.3f' % (nb_auc2))
print('Logistic Regressio = %.3f' % (lr_auc2))
print('Gradient Boosting = %.3f' % (gbt_auc2))

plt.plot(rf_rpr2, rf_tpr2, marker= '.', label = 'Random Forest (AUROC = %0.3f)' % rf_auc2)
plt.plot(nb_rpr2, nb_tpr2, marker= '.', label = 'Naive Bayes (AUROC = %0.3f)' % nb_auc2)
plt.plot(lr_rpr2, lr_tpr2, marker= '.', label = 'Logistic Regression (AUROC = %0.3f)' % lr_auc2)
plt.plot(gbt_rpr2, gbt_tpr2, marker= '.', label = 'Gaussian BT (AUROC = %0.3f)' % gbt_auc2)
plt.title('ROC Plot')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend()
plt.show()

plt.figure(figsize=(12, 8))
plt.plot(rf_rpr1, rf_tpr1, marker= '.', label = 'Random Forest - Node2Vec (AUROC = %0.3f)' % rf_auc1)
plt.plot(nb_rpr1, nb_tpr1, marker= '.', label = 'Naive Bayes - Node2Vec (AUROC = %0.3f)' % nb_auc1)
plt.plot(lr_rpr1, lr_tpr1, marker= '.', label = 'Logistic Regression - Node2Vec (AUROC = %0.3f)' % lr_auc1)
plt.plot(gbt_rpr1, gbt_tpr1, marker= '.', label = 'Gaussian BC - Node2Vec (AUROC = %0.3f)' % gbt_auc1)
plt.plot(rf_rpr2, rf_tpr2, marker= '.', label = 'Random Forest - RDF2Vec (AUROC = %0.3f)' % rf_auc2)
plt.plot(nb_rpr2, nb_tpr2, marker= '.', label = 'Naive Bayes - RDF2Vec (AUROC = %0.3f)' % nb_auc2)
plt.plot(lr_rpr2, lr_tpr2, marker= '.', label = 'Logistic Regression - RDF2Vec (AUROC = %0.3f)' % lr_auc2)
plt.plot(gbt_rpr2, gbt_tpr2, marker= '.', label = 'Gaussian BC - RDF2Vec (AUROC = %0.3f)' % gbt_auc2)
plt.title('ROC Plot')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend()
plt.show()

grid_search.fit(X_train, y_train)
grid_search.best_params_

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

import numpy as np
from sklearn.model_selection import KFold

X = merge1.loc[:, merge1.columns != 'Labeling']
y = merge1.loc[:, merge1.columns == 'Labeling']
y=y['Labeling'] 
    
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)
        
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

rf = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 80, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='gini')
rf.fit(X_train, y_train)
            
predict = rf.predict(X_test)

from sklearn.model_selection import cross_val_score
score_test = metrics.f1_score(y_test, predict)
print(cross_val_score(RF, X, y, cv=kfold, scoring="f1").mean())

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

import numpy as np
from sklearn.model_selection import KFold

X = merge2.loc[:, merge2.columns != 'Labeling']
y = merge2.loc[:, merge2.columns == 'Labeling']
y=y['Labeling'] 
    
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)
        
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

rf = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 80, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='gini')
rf.fit(X_train, y_train)
            
predict = rf.predict(X_test)

from sklearn.model_selection import cross_val_score
print(cross_val_score(rf, X, y, cv=kfold, scoring="f1").mean())

grid_search.fit(X_train, y_train)
grid_search.best_params_

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

X = merge1.loc[:, merge1.columns != 'Labeling']
y = merge1.loc[:, merge1.columns == 'Labeling']
y=y['Labeling'] 
    
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)
        
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

rf = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 90, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='entropy')
rf.fit(X_train, y_train)
            
predict = rf.predict(X_test)

from sklearn.model_selection import cross_val_score
print(cross_val_score(rf, X, y, cv=kfold, scoring="f1").mean())

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

X = merge2.loc[:, merge2.columns != 'Labeling']
y = merge2.loc[:, merge2.columns == 'Labeling']
y=y['Labeling'] 
    
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)
        
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)

kfold = KFold(n_splits=5, shuffle=True, random_state=42)

rf = RandomForestClassifier(n_jobs = -1,  
                           max_depth = 90, min_samples_leaf = 1,
                           min_samples_split = 2, n_estimators = 1000, criterion='entropy')
rf.fit(X_train, y_train)
            
predict = rf.predict(X_test)

from sklearn.model_selection import cross_val_score
print(cross_val_score(rf, X, y, cv=kfold, scoring="f1").mean())

#Node2Vec
RF = RandomForestClassifier()


X = merge1.loc[:, merge1.columns != 'Labeling']
y = merge1.loc[:, merge1.columns == 'Labeling']
y=y['Labeling'] 
        
over = SMOTE(sampling_strategy=0.002)
under = RandomUnderSampler(sampling_strategy=1)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
        
X, y = pipeline.fit_resample(X, y)

from collections import Counter
counter = Counter(y)
print(counter)
        
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.75, random_state=42)
    
RF.fit(X_train, y_train)
#score_test = rf.score(X_test, y_test)
predict = RF.predict(X_test)
score_test1 = metrics.f1_score(y_test, predict)
score_test2 = metrics.precision_score(y_test, predict)
score_test3 = metrics.recall_score(y_test, predict)
score_test4 = metrics.accuracy_score(y_test, predict)
print(score_test1)
print(score_test2)
print(score_test3)
print(score_test4)