Update src/bin/target_family_classifier.py

src/bin/target_family_classifier.py

@@ -4,27 +4,18 @@ Created on Mon Jun  8 09:32:26 2020
 
 @author: Muammer
 """
-import os 
-script_dir = os.path.dirname(os.path.abspath(__file__))
-
+import os
 import numpy as np
-from sklearn.model_selection import cross_validate
-from sklearn.model_selection import cross_val_predict
-from sklearn.metrics import matthews_corrcoef
-from sklearn.metrics import classification_report
-from sklearn.multiclass import OneVsRestClassifier
-from sklearn import linear_model
-from sklearn.metrics import f1_score
-from sklearn.metrics import confusion_matrix
 from sklearn.model_selection import train_test_split
-import pandas as pd 
-from numpy import save
-from sklearn.metrics import precision_recall_fscore_support
+from sklearn import linear_model
+from sklearn.metrics import (
+    f1_score, accuracy_score, confusion_matrix, classification_report, matthews_corrcoef
+)
+from sklearn.multiclass import OneVsRestClassifier
+import pandas as pd
 from tqdm import tqdm
-from sklearn.metrics import accuracy_score
 import math
 
-
 representation_name = ""
 representation_path = ""
 dataset = "nc"
@@ -33,68 +24,40 @@ detailed_output = False
 def convert_dataframe_to_multi_col(representation_dataframe):
     entry = pd.DataFrame(representation_dataframe['Entry'])
     vector = pd.DataFrame(list(representation_dataframe['Vector']))
-    multi_col_representation_vector = pd.merge(left=entry,right=vector,left_index=True, right_index=True)
+    multi_col_representation_vector = pd.merge(left=entry, right=vector, left_index=True, right_index=True)
     return multi_col_representation_vector
 
 def class_based_scores(c_report, c_matrix):
     c_report = pd.DataFrame(c_report).transpose()
-    #print(c_report)
     c_report = c_report.drop(['precision', 'recall'], axis=1)
     c_report = c_report.drop(labels=['accuracy', 'macro avg', 'weighted avg'], axis=0)
+    
     cm = c_matrix.astype('float') / c_matrix.sum(axis=1)[:, np.newaxis]
-    #print(c_report)
     accuracy = cm.diagonal()
-    
-    #print(accuracy)
-    #if len(accuracy) == 6:
-     #   accuracy = np.delete(accuracy, 5)
-
     accuracy = pd.Series(accuracy, index=c_report.index)
     c_report['accuracy'] = accuracy
     
     total = c_report['support'].sum()
-    #print(total)
     num_classes = np.shape(c_matrix)[0]
     mcc = np.zeros(shape=(num_classes,), dtype='float32')
-    weights = np.sum(c_matrix, axis=0)/np.sum(c_matrix)
-    total_tp = 0
-    total_fp = 0
-    total_fn = 0
-    total_tn = 0
 
     for j in range(num_classes):
         tp = np.sum(c_matrix[j, j])
         fp = np.sum(c_matrix[j, np.concatenate((np.arange(0, j), np.arange(j+1, num_classes)))])
         fn = np.sum(c_matrix[np.concatenate((np.arange(0, j), np.arange(j+1, num_classes))), j])
         tn = int(total - tp - fp - fn)
-        total_tp = total_tp + tp
-        total_fp = total_fp + fp
-        total_fn = total_fn + fn
-        total_tn = total_tn + tn
-        #print(tp,fp,fn,tn)
-        mcc[j] = ((tp*tn)-(fp*fn))/math.sqrt((tp+fp)*(tp+fn)*(tn+fp)*(tn+fn))
-    #print(mcc)
-    #if len(mcc) == 6:
-     #   mcc = np.delete(mcc, 5)
-
+        mcc[j] = ((tp * tn) - (fp * fn)) / math.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn))
+    
     mcc = pd.Series(mcc, index=c_report.index)
     c_report['mcc'] = mcc
-    #c_report.to_excel('../results/resultss_class_based_'+dataset+'.xlsx')
-    #print(c_report)
-    return c_report, total_tp, total_fp, total_fn, total_tn
-
 
+    return c_report
 
 def score_protein_rep(dataset):
-#def score_protein_rep(pkl_data_path):
-
-    vecsize = 0
-    #protein_list = pd.read_csv('../data/auxilary_input/entry_class.csv')
     protein_list = pd.read_csv(os.path.join(script_dir, '../data/preprocess/entry_class_nn.csv'))
     dataframe = pd.read_csv(representation_path)
-    #dataframe = convert_dataframe_to_multi_col(dataframe)    
-    #dataframe = pd.read_pickle(pkl_data_path)
-    vecsize = dataframe.shape[1]-1    
+    vecsize = dataframe.shape[1] - 1
+
     x = np.empty([0, vecsize])
     xemp = np.zeros((1, vecsize), dtype=float)
     y = []
@@ -104,125 +67,82 @@ def score_protein_rep(dataset):
     for index, row in tqdm(protein_list.iterrows(), total=len(protein_list)):
         pdrow = dataframe.loc[dataframe['Entry'] == row['Entry']]
         if len(pdrow) != 0:
-            a = pdrow.loc[ : , pdrow.columns != 'Entry']
+            a = pdrow.loc[:, pdrow.columns != 'Entry']
             a = np.array(a)
-            a.shape = (1,vecsize)
+            a.shape = (1, vecsize)
             x = np.append(x, a, axis=0)
             y.append(row['Class'])
         else:
             ne.append(index)
-            x = np.append(x, xemp, axis=0,)
+            x = np.append(x, xemp, axis=0)
             y.append(0.0)
-            #print(index)
 
     x = x.astype(np.float64)
     y = np.array(y)
     y = y.astype(np.float64)
-    #print(len(y))
-    scoring = ['precision_weighted', 'recall_weighted', 'f1_weighted', 'accuracy']
+
     target_names = ['Enzyme', 'Membrane receptor', 'Transcription factor', 'Ion channel', 'Other']
     labels = [1.0, 11.0, 12.0, 1005.0, 2000.0]
-    
+
     f1 = []
     accuracy = []
     mcc = []
-    f1_perclass = []
-    ac_perclass = []
-    mcc_perclass = []
-    sup_perclass = []
     report_list = []
-    train_index = pd.read_csv(os.path.join(script_dir, '../data/preprocess/indexes/'+dataset+'_trainindex.csv'))
+
+    train_index = pd.read_csv(os.path.join(script_dir, '../data/preprocess/indexes/' + dataset + '_trainindex.csv'))
     test_index = pd.read_csv(os.path.join(script_dir, '../data/preprocess/indexes/testindex_family.csv'))
-    train_index = train_index.dropna(axis=1) 
+    train_index = train_index.dropna(axis=1)
     test_index = test_index.dropna(axis=1)
-    #print(train_index)
-    #for index in ne:
-       
 
-    conf = pd.DataFrame()
+    conf_matrices = []
 
     print('Producing protein family predictions...\n')
-    for i in tqdm(range(10)): 
-        clf = linear_model.SGDClassifier(class_weight="balanced", loss="log", penalty="elasticnet", max_iter=1000, tol=1e-3,random_state=i,n_jobs=-1)
-        clf2 = OneVsRestClassifier(clf,n_jobs=-1)
-        #print(test_index)
+    for i in tqdm(range(10)):
+        clf = linear_model.SGDClassifier(class_weight="balanced", loss="log", penalty="elasticnet", max_iter=1000, tol=1e-3, random_state=i, n_jobs=-1)
+        clf2 = OneVsRestClassifier(clf, n_jobs=-1)
+
         train_indexx = train_index.iloc[i].astype(int)
         test_indexx = test_index.iloc[i].astype(int)
-        #print(train_indexx)
-        #train_indexx.drop(labels=ne)
-        #print(type(train_indexx))
-        for index in ne:
-            
-            train_indexx = train_indexx[train_indexx!=index]
-            test_indexx = test_indexx[test_indexx!=index]
-            
 
+        for index in ne:
+            train_indexx = train_indexx[train_indexx != index]
+            test_indexx = test_indexx[test_indexx != index]
 
         train_X, test_X = x[train_indexx], x[test_indexx]
         train_y, test_y = y[train_indexx], y[test_indexx]
 
-        clf2.fit(train_X, train_y)    
-            
-        #print(train_X)
+        clf2.fit(train_X, train_y)
         y_pred = clf2.predict(test_X)
-           
-        #y_pred = cross_val_predict(clf2, x, y, cv=10, n_jobs=-1)
-        #mcc.append(matthews_corrcoef(test_y, y_pred, sample_weight = test_y))
+
         f1_ = f1_score(test_y, y_pred, average='weighted')
         f1.append(f1_)
+
         ac = accuracy_score(test_y, y_pred)
         accuracy.append(ac)
+
         c_report = classification_report(test_y, y_pred, target_names=target_names, output_dict=True)
         c_matrix = confusion_matrix(test_y, y_pred, labels=labels)
+        conf_matrices.append(c_matrix)
 
-        conf = conf.append(pd.DataFrame(c_matrix, columns=['Enzymes', 'Membrane receptor', 'Transcription factor', 'Ion channel', 'Other']), ignore_index=True) 
-        class_report, tp, fp, fn, tn = class_based_scores(c_report, c_matrix)
-        
-        #print(total_tp)
-        mcc.append(((tp*tn)-(fp*fn))/math.sqrt((tp+fp)*(tp+fn)*(tn+fp)*(tn+fn)))
-
+        class_report = class_based_scores(c_report, c_matrix)
+        mcc_score = matthews_corrcoef(test_y, y_pred)
+        mcc.append(mcc_score)
         
-        f1_perclass.append(class_report['f1-score'])
-        ac_perclass.append(class_report['accuracy'])
-        mcc_perclass.append(class_report['mcc'])
-        sup_perclass.append(class_report['support'])
         report_list.append(class_report)
-    
-    if detailed_output:
-        conf.to_csv(os.path.join(script_dir, '../results/Drug_target_protein_family_classification_confusion_'+dataset+'_'+representation_name+'.csv'), index=None)
-
-    f1_perclass = pd.concat(f1_perclass, axis=1)
-    ac_perclass = pd.concat(ac_perclass, axis=1)
-    mcc_perclass = pd.concat(mcc_perclass, axis=1)
-    sup_perclass = pd.concat(sup_perclass, axis=1)
-    
-    report_list = pd.concat(report_list, axis=1)
-    report_list.to_csv(os,path,join(script_dir, '../results/Drug_target_protein_family_classification_class_based_results_'+dataset+'_'+representation_name+'.csv'))
-    
-    report = pd.DataFrame()    
-    f1mean = np.mean(f1, axis=0)
-    #print(f1mean)
-    f1mean = f1mean.round(decimals=5)
-    f1std = np.std(f1).round(decimals=5)
-    acmean = np.mean(accuracy, axis=0).round(decimals=5)
-    acstd = np.std(accuracy).round(decimals=5)
-    mccmean = np.mean(mcc, axis=0).round(decimals=5)
-    mccstd = np.std(mcc).round(decimals=5)
-    labels = ['Average Score', 'Standard Deviation']
-    report['Protein Family'] = labels
-    report['F1_score'] = [f1mean, f1std]
-    report['Accuracy'] = [acmean, acstd]
-    report['MCC'] = [mccmean, mccstd]
-
-    report.to_csv(os.path.join(script_dir, '../results/Drug_target_protein_family_classification_mean_results_'+dataset+'_'+representation_name+'.csv',index=False))
-    #report.to_csv('scores_general.csv')
-    #print(report)   
-    if detailed_output:
-        save('../results/Drug_target_protein_family_classification_f1_'+dataset+'_'+representation_name+'.npy', f1)
-        save('../results/Drug_target_protein_family_classification_accuracy_'+dataset+'_'+representation_name+'.npy', accuracy)
-        save('../results/Drug_target_protein_family_classification_mcc_'+dataset+'_'+representation_name+'.npy', mcc) 
-        save('../results/Drug_target_protein_family_classification_class_based_f1_'+dataset+'_'+representation_name+'.npy', f1_perclass)
-        save('../results/Drug_target_protein_family_classification_class_based_accuracy_'+dataset+'_'+representation_name+'.npy', ac_perclass)
-        save('../results/Drug_target_protein_family_classification_class_based_mcc_'+dataset+'_'+representation_name+'.npy', mcc_perclass) 
-        save('../results/Drug_target_protein_family_classification_class_based_support_'+dataset+'_'+representation_name+'.npy', sup_perclass) 
 
+    f1_perclass = pd.concat([r['f1-score'] for r in report_list], axis=1)
+    ac_perclass = pd.concat([r['accuracy'] for r in report_list], axis=1)
+    mcc_perclass = pd.concat([r['mcc'] for r in report_list], axis=1)
+
+    results = {
+        "f1": f1,
+        "accuracy": accuracy,
+        "mcc": mcc,
+        "confusion_matrices": conf_matrices,
+        "class_reports": report_list,
+        "f1_per_class": f1_perclass,
+        "accuracy_per_class": ac_perclass,
+        "mcc_per_class": mcc_perclass
+    }
+
+    return results