--- a
+++ b/intelligenes/classification.py
@@ -0,0 +1,586 @@
+# (Packages/Libraries) Matrix Manipulation
+import pandas as pd
+import numpy as np
+
+# (Packages/Libraries) Statistical Analysis & Machine Learning
+import sklearn
+from sklearn.model_selection import train_test_split, KFold, GridSearchCV
+from sklearn.pipeline import Pipeline
+from sklearn.ensemble import RandomForestClassifier, VotingClassifier
+from sklearn.svm import SVC
+from sklearn.metrics import accuracy_score, roc_auc_score, f1_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.neural_network import MLPClassifier
+import xgboost as xgb
+import shap
+import matplotlib.pyplot as plt
+
+# (Packages/Libraries) Miscellaneous
+import os
+from datetime import datetime
+import argparse
+import warnings
+from pathlib import Path
+
+warnings.filterwarnings("ignore", message = "No data for colormapping provided via 'c'. Parameters 'vmin', 'vmax' will be ignored")
+
+class DiseasePrediction:
+    
+    # Initialize DiseasePrediction Class 
+    def __init__(self: 'DiseasePrediction', cgit_file: str,
+                                            features_file: str, 
+                                            output_dir: str,
+                                            voting: str,
+                                            random_state: 42,
+                                            test_size: 0.3,
+                                            n_splits: 5,
+                                            use_rf = True,
+                                            use_svm = True,
+                                            use_xgb = True,
+                                            use_knn = True,
+                                            use_mlp = True,
+                                            use_tuning = False,
+                                            use_normalization = False,
+                                            use_igenes = True,
+                                            use_visualization = False):
+        
+
+        self.cgit_file = Path(cgit_file).stem
+        self.df = pd.read_csv(cgit_file)
+        self.features_file = features_file
+        self.output_dir = output_dir
+        self.voting = voting
+        self.random_state = random_state
+        self.test_size = test_size
+        self.n_splits = n_splits
+        self.use_rf = use_rf
+        self.use_svm = use_svm
+        self.use_xgb = use_xgb
+        self.use_knn = use_knn
+        self.use_mlp = use_mlp
+        self.use_tuning = use_tuning
+        self.use_normalization = use_normalization
+        self.use_igenes = use_igenes
+        self. use_visualization = use_visualization
+        
+        self.features = pd.read_csv(self.features_file)['Features'].values.flatten().tolist()
+        if not self.features or self.features[0] == "Features":
+            raise ValueError("Features not included.")
+        
+        self.y = self.df['Type']
+        self.X = self.df[self.features]
+        
+        self.kfold = KFold(n_splits = self.n_splits, shuffle = True, random_state = self.random_state)
+        
+        self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(self.X, self.y, test_size = self.test_size, random_state = self.random_state)
+        
+        self.classifiers = [] 
+            
+    # Random Forest Classifier 
+    def rf_classifier(self: 'DiseasePrediction'):
+        if self.use_rf:         
+            print('Random Forest...')
+            if self.use_normalization:
+                pipeline = Pipeline([('scaling', StandardScaler()), ('rf_clf', RandomForestClassifier(random_state = self.random_state))])
+            else:
+                pipeline = Pipeline([('rf_clf', RandomForestClassifier(random_state = self.random_state))])
+            
+            if self.use_tuning:
+                rf_parameters = {
+                    'rf_clf__max_features': np.arange(1, self.X_train.shape[1] + 1),
+                    'rf_clf__min_samples_split': np.arange(2, 11),
+                    'rf_clf__min_samples_leaf': np.concatenate([np.arange(1, 11), [100, 150]])  
+                }
+                
+                rf_clf = GridSearchCV(pipeline, param_grid = rf_parameters, cv = self.kfold, scoring = 'accuracy', n_jobs = -1, verbose = 0).fit(self.X_train, self.y_train)
+                rf_clf = rf_clf.best_estimator_
+            else: 
+                rf_clf = pipeline.fit(self.X_train, self.y_train)
+                
+            if self.use_igenes or self.use_visualization:
+                rf_importances = shap.TreeExplainer(rf_clf.named_steps['rf_clf']).shap_values(self.X_test)[1]
+            
+            if self.use_igenes:
+                rf_importances_extracted = np.mean(rf_importances, axis = 0)
+                rf_importances_normalized = (np.abs(rf_importances_extracted) / np.sum(np.abs(rf_importances_extracted))) * 100
+                rf_hhi = np.sum(np.square(rf_importances_normalized))
+                
+            if self.use_visualization:
+               shap.summary_plot(rf_importances, self.X_test, plot_type = "dot", show = False)
+               
+               plt.title("Random Forest Feature Importances", fontsize = 16)
+               plt.xlabel("SHAP Value", fontsize = 14)
+               plt.ylabel("Feature", fontsize = 14)
+               plt.tight_layout()
+               
+               file_name = f"{self.cgit_file}_{datetime.now().strftime('%m-%d-%Y-%I-%M-%S-%p')}_RF-SHAP.png"
+               rf_plot = os.path.join(self.output_dir, file_name)
+               
+               if not os.path.exists(self.output_dir):
+                   os.makedirs(self.output_dir)
+                   
+               plt.savefig(rf_plot)
+               plt.close()
+               
+            y_pred = rf_clf.predict(self.X_test)
+            y_proba = rf_clf.predict_proba(self.X_test)[:, 1]
+            
+            rf_accuracy = accuracy_score(self.y_test, y_pred)
+            rf_roc_auc = roc_auc_score(self.y_test, y_proba)
+            rf_f1 = f1_score(self.y_test, y_pred, average = 'weighted')
+            
+            if self.use_igenes:
+                return rf_clf, rf_accuracy, rf_roc_auc, rf_f1, rf_importances_extracted / np.max(np.abs(rf_importances_extracted)), rf_hhi, rf_importances
+            else:
+                return rf_clf, rf_accuracy, rf_roc_auc, rf_f1                  
+        
+        return None
+    
+    # Support Vector Machine Classifier 
+    def svm_classifier(self: 'DiseasePrediction'):
+        if self.use_svm:
+            print('Support Vector Machine...')
+            if self.use_normalization:
+                pipeline = Pipeline([('scaling', StandardScaler()), ('svm_clf', SVC(random_state = self.random_state, kernel = 'linear', probability = True))])
+            else:
+                pipeline = Pipeline([('svm_clf', SVC(random_state = self.random_state, kernel = 'linear', probability = True))])
+                
+            if self.use_tuning:
+                svm_parameters = {
+                    "svm_clf__kernel": ['linear'],
+                    'svm_clf__gamma': [0.001, 0.01, 0.1, 1, 10],
+                    'svm_clf__C': [0.01, 0.1, 1, 10, 50, 100, 500, 1000, 5000, 10000]
+                }
+                
+                svm_clf = GridSearchCV(pipeline, param_grid = svm_parameters, cv = self.kfold, scoring = 'accuracy', n_jobs = -1, verbose = 0).fit(self.X_train, self.y_train)
+                svm_clf = svm_clf.best_estimator_
+            else: 
+                svm_clf = pipeline.fit(self.X_train, self.y_train)
+                
+            if self.use_igenes or self.use_visualization:
+                svm_importances = shap.LinearExplainer(svm_clf.named_steps['svm_clf'], masker = shap.maskers.Independent(self.X_train)).shap_values(self.X_test)
+            
+            if self.use_igenes:
+                svm_importances_extracted = np.mean(svm_importances, axis = 0)
+                svm_importances_normalized = (np.abs(svm_importances_extracted) / np.sum(np.abs(svm_importances_extracted))) * 100
+                svm_hhi = np.sum(np.square(svm_importances_normalized))
+                
+            if self.use_visualization:
+                shap.summary_plot(svm_importances, self.X_test, plot_type = "dot", show = False)
+                
+                plt.title("Support Vector Machine Feature Importances", fontsize = 16)
+                plt.xlabel("SHAP Value", fontsize = 14)
+                plt.ylabel("Feature", fontsize = 14)
+                plt.tight_layout()
+                
+                file_name = f"{self.cgit_file}_{datetime.now().strftime('%m-%d-%Y-%I-%M-%S-%p')}_SVM-SHAP.png"
+                svm_plot = os.path.join(self.output_dir, file_name)
+                
+                if not os.path.exists(self.output_dir):
+                   os.makedirs(self.output_dir)
+                   
+                plt.savefig(svm_plot)
+                plt.close()
+            
+            y_pred = svm_clf.predict(self.X_test)
+            y_proba = svm_clf.predict_proba(self.X_test)[:, 1]
+            
+            svm_accuracy = accuracy_score(self.y_test, y_pred)
+            svm_roc_auc = roc_auc_score(self.y_test, y_proba)
+            svm_f1 = f1_score(self.y_test, y_pred, average = 'weighted')
+            
+            if self.use_igenes:
+                return svm_clf, svm_accuracy, svm_roc_auc, svm_f1, svm_importances_extracted / np.max(np.abs(svm_importances_extracted)), svm_hhi, svm_importances
+            else: 
+                return svm_clf, svm_accuracy, svm_roc_auc
+            
+        return None
+    
+    # XGBoost Classifier 
+    def xgb_classifier(self: 'DiseasePrediction'):
+        if self.use_xgb: 
+            print('XGBoost...')
+            if self.use_normalization:
+                pipeline = Pipeline([('scaling', StandardScaler()), ('xgb_clf', xgb.XGBClassifier(random_state = self.random_state, objective = "reg:squarederror"))])
+            else:
+                pipeline = Pipeline([('xgb_clf', xgb.XGBClassifier(random_state = self.random_state, objective = "binary:logistic"))])
+                
+            if self.use_tuning:
+                xgb_parameters = {
+                    "xgb_clf__n_estimators": [int(x) for x in np.linspace(100, 500, 5)],
+                    "xgb_clf__max_depth": [int(x) for x in np.linspace(3, 9, 4)],
+                    "xgb_clf__gamma": [0.01, 0.1],
+                    "xgb_clf__learning_rate": [0.001, 0.01, 0.1, 1]
+                }
+                
+                xgb_clf = GridSearchCV(pipeline, param_grid = xgb_parameters, cv = self.kfold, scoring = 'accuracy', n_jobs = -1, verbose = 0).fit(self.X_train, self.y_train)
+                xgb_clf = xgb_clf.best_estimator_
+            else: 
+                xgb_clf = pipeline.fit(self.X_train, self.y_train)
+                
+            if self.use_igenes or self.use_visualization:
+                xgb_importances = shap.TreeExplainer(xgb_clf.named_steps['xgb_clf']).shap_values(self.X_test)
+            
+            if self.use_igenes:
+                xgb_importances_extracted = np.mean(xgb_importances, axis = 0)
+                xgb_importances_normalized = (np.abs(xgb_importances_extracted) / np.sum(np.abs(xgb_importances_extracted))) * 100
+                xgb_hhi = np.sum(np.square(xgb_importances_normalized))
+                
+            if self.use_visualization:
+                shap.summary_plot(xgb_importances, self.X_test, plot_type = "dot", show = False)
+                
+                plt.title("XGBoost Feature Importances", fontsize = 16)
+                plt.xlabel("SHAP Value", fontsize = 14)
+                plt.ylabel("Feature", fontsize = 14)
+                plt.tight_layout()
+                
+                file_name = f"{self.cgit_file}_{datetime.now().strftime('%m-%d-%Y-%I-%M-%S-%p')}_XGB-SHAP.png"
+                xgb_plot = os.path.join(self.output_dir, file_name)
+                
+                if not os.path.exists(self.output_dir):
+                    os.makedirs(self.output_dir)
+                
+                plt.savefig(xgb_plot)
+                plt.close()
+                
+            y_pred = xgb_clf.predict(self.X_test)
+            y_proba = xgb_clf.predict_proba(self.X_test)[:, 1]
+            
+            xgb_accuracy = accuracy_score(self.y_test, y_pred)
+            xgb_roc_auc = roc_auc_score(self.y_test, y_proba)
+            xgb_f1 = f1_score(self.y_test, y_pred, average = 'weighted')
+            
+            if self.use_igenes:
+                return xgb_clf, xgb_accuracy, xgb_roc_auc, xgb_f1, xgb_importances_extracted / np.max(np.abs(xgb_importances_extracted)), xgb_hhi, xgb_importances
+            else: 
+                return xgb_clf, xgb_accuracy, xgb_roc_auc, xgb_f1
+            
+        return None
+    
+    # k-Nearest Neighbors Classifier
+    def knn_classifier(self: 'DiseasePrediction'):
+        if self.use_knn: 
+            print('k-Nearest Neighbors...')
+            if self.use_normalization:
+                pipeline = Pipeline([('scaling', StandardScaler()), ('knn_clf', sklearn.neighbors.KNeighborsClassifier())])
+            else:
+                pipeline = Pipeline([('knn_clf', sklearn.neighbors.KNeighborsClassifier())])
+                
+            if self.use_tuning:
+                knn_parameters = {
+                    "knn_clf__leaf_size": list(range(1, 50)),
+                    "knn_clf__n_neighbors": list(range(1, min(len(self.X_train) - 1, 30) + 1)),
+                    "knn_clf__p": [1, 2]
+                }
+                
+                knn_clf = GridSearchCV(pipeline, param_grid = knn_parameters, cv = self.kfold, scoring = 'accuracy', n_jobs = -1, verbose = 0).fit(self.X_train, self.y_train)
+                knn_clf = knn_clf.best_estimator_
+            else:
+                knn_clf = pipeline.fit(self.X_train, self.y_train)
+                
+            if self.use_igenes or self.use_visualization:
+                knn_importances = shap.KernelExplainer(knn_clf.named_steps['knn_clf'].predict, shap.sample(self.X_train, 1000)).shap_values(self.X_test)
+            
+            if self.use_igenes:
+                knn_importances_extracted = np.mean(knn_importances, axis = 0)
+                knn_importances_normalized = (np.abs(knn_importances_extracted) / np.sum(np.abs(knn_importances_extracted))) * 100
+                knn_hhi = np.sum(np.square(knn_importances_normalized))
+            
+            if self.use_visualization:
+                shap.summary_plot(knn_importances, self.X_test, plot_type = "dot", show = False)
+                
+                plt.title("k-Nearest Neighbors Feature Importances", fontsize = 16)
+                plt.xlabel("SHAP Value", fontsize = 14)
+                plt.ylabel("Feature", fontsize = 14)
+                plt.tight_layout()
+                
+                file_name = f"{self.cgit_file}_{datetime.now().strftime('%m-%d-%Y-%I-%M-%S-%p')}_kNN-SHAP.png"
+                knn_plot = os.path.join(self.output_dir, file_name)
+                
+                if not os.path.exists(self.output_dir):
+                    os.makedirs(self.output_dir)
+                    
+                plt.savefig(knn_plot)
+                plt.close()
+            
+            y_pred = knn_clf.predict(self.X_test)
+            y_proba = knn_clf.predict_proba(self.X_test)[:, 1]
+            
+            knn_accuracy = accuracy_score(self.y_test, y_pred)
+            knn_roc_auc = roc_auc_score(self.y_test, y_proba)
+            knn_f1 = f1_score(self.y_test, y_pred, average = 'weighted')
+            
+            if self.use_igenes:
+                return knn_clf, knn_accuracy, knn_roc_auc, knn_f1, knn_importances_extracted / np.max(np.abs(knn_importances_extracted)), knn_hhi, knn_importances
+            else: 
+                return knn_clf, knn_accuracy, knn_roc_auc, knn_f1
+            
+        return None
+    
+    # Multi-Layer Perceptron Classifier
+    def mlp_classifier(self: 'DiseasePrediction'):
+        if self.use_mlp:
+            print('Multi-Layer Perceptron...')
+            if self.use_normalization:
+                pipeline = Pipeline([('scaling', StandardScaler()), ('mlp_clf', MLPClassifier(random_state = self.random_state, max_iter = 3000))])
+            else:
+                pipeline = Pipeline([('mlp_clf', MLPClassifier(random_state = self.random_state, max_iter = 2000))])
+            
+            if self.use_tuning:
+                mlp_parameters = {
+                    'mlp_clf__hidden_layer_sizes': [(50, 50, 50), (50, 100, 50), (100,), (100, 100,), (100, 100, 100)],
+                    'mlp_clf__activation': ['tanh', 'relu'],
+                    'mlp_clf__solver': ['sgd', 'adam'],
+                    'mlp_clf__alpha': [0.0001, 0.001, 0.01, 0.05, 0.1],
+                    'mlp_clf__learning_rate': ['constant', 'adaptive'],
+                    'mlp_clf__learning_rate_init': [0.001, 0.01, 0.1],
+                    'mlp_clf__momentum': [0.1, 0.2, 0.5, 0.9],
+                }
+                
+                mlp_clf = GridSearchCV(pipeline, param_grid = mlp_parameters, cv = self.kfold, scoring = 'accuracy', n_jobs = -1, verbose = 0).fit(self.X_train, self.y_train)
+                mlp_clf = mlp_clf.best_estimator_
+            else:
+                mlp_clf = pipeline.fit(self.X_train, self.y_train)
+                
+            if self.use_igenes or self.use_visualization:
+                mlp_importances =  shap.KernelExplainer(mlp_clf.named_steps['mlp_clf'].predict, shap.sample(self.X_train, 1000)).shap_values(self.X_test)
+                
+            if self.use_igenes:
+                mlp_importances_extracted = np.mean(mlp_importances, axis = 0)
+                mlp_importances_normalized = (np.abs(mlp_importances_extracted) / np.sum(np.abs(mlp_importances_extracted))) * 100
+                mlp_hhi = np.sum(np.square(mlp_importances_normalized))
+                
+            if self.use_visualization:
+                shap.summary_plot(mlp_importances, self.X_test, plot_type = "dot", show = False)
+                
+                plt.title("Multi-Layer Perceptron Feature Importances", fontsize = 16)
+                plt.xlabel("SHAP Value", fontsize = 14)
+                plt.ylabel("Feature", fontsize = 14)
+                plt.tight_layout()
+                
+                file_name = f"{self.cgit_file}_{datetime.now().strftime('%m-%d-%Y-%I-%M-%S-%p')}_MLP-SHAP.png"
+                mlp_plot = os.path.join(self.output_dir, file_name)
+                
+                if not os.path.exists(self.output_dir):
+                    os.makedirs(self.output_dir)
+                    
+                plt.savefig(mlp_plot)
+                plt.close()
+                
+            y_pred = mlp_clf.predict(self.X_test)
+            y_proba = mlp_clf.predict_proba(self.X_test)[:, 1]
+            
+            mlp_accuracy = accuracy_score(self.y_test, y_pred)
+            mlp_roc_auc = roc_auc_score(self.y_test, y_proba)
+            mlp_f1 = f1_score(self.y_test, y_pred, average = 'weighted')           
+            
+            if self.use_igenes:
+                return mlp_clf, mlp_accuracy, mlp_roc_auc, mlp_f1, mlp_importances_extracted / np.max(np.abs(mlp_importances_extracted)), mlp_hhi, mlp_importances
+            else:
+                return mlp_clf, mlp_accuracy, mlp_roc_auc, mlp_f1
+            
+        return None
+    
+    # Voting Classifier
+    def voting_classifier(self: 'DiseasePrediction'):
+        if self.classifiers:
+            print('Voting Classifier...')
+            voting_clf = VotingClassifier(estimators = [(clf[0], clf[1]["Classifier"]) for clf in self.classifiers], voting = self.voting).fit(self.X_train, self.y_train)
+            
+            y_pred = voting_clf.predict(self.X_test)
+            y_proba = voting_clf.predict_proba(self.X_test)[:, 1]
+            
+            voting_accuracy = accuracy_score(self.y_test, y_pred) 
+            voting_roc_auc = roc_auc_score(self.y_test, y_proba) 
+            voting_f1 = f1_score(self.y_test, y_pred, average = 'weighted')
+            
+            return voting_clf, voting_accuracy, voting_roc_auc, voting_f1
+        
+        return None
+    
+    # Execute Classifiers
+    def execute_classifiers(self: 'DiseasePrediction'):
+        classifiers = [
+            ("Random Forest", self.rf_classifier),
+            ("Support Vector Machine", self.svm_classifier),
+            ("XGBoost", self.xgb_classifier),
+            ("k-Nearest Neighbors", self.knn_classifier),
+            ("Multi-Layer Perceptron", self.mlp_classifier)
+        ]
+
+        self.classifiers = []
+        for name, classifier in classifiers:
+            metrics_tuple = classifier()
+            if metrics_tuple is not None:
+                clf, accuracy, roc_auc, f1, *rest = metrics_tuple
+
+                classifier_info = {
+                    "Classifier": clf,
+                    "Accuracy": accuracy,
+                    "ROC-AUC": roc_auc,
+                    "F1": f1
+                }
+
+                if len(rest) == 2:
+                    classifier_info["Importances"] = rest[0]
+                    classifier_info["HHI"] = rest[1]
+                elif len(rest) == 3:
+                    classifier_info["Importances"] = rest[0]
+                    classifier_info["HHI"] = rest[1]
+                    classifier_info["SHAP Values"] = rest[2]
+
+                self.classifiers.append((name, classifier_info))
+                
+        voting_metrics_tuple = self.voting_classifier()
+        if voting_metrics_tuple:
+            voting_clf, voting_accuracy, voting_roc_auc, voting_f1 = voting_metrics_tuple
+            self.classifiers.append(("Voting Classifier", {
+                "Classifier": voting_clf,
+                "Accuracy": voting_accuracy,
+                "ROC-AUC": voting_roc_auc,
+                "F1": voting_f1
+            }))
+            
+    # Generate Classifier Metrics
+    def classifier_metrics(self: 'DiseasePrediction'):   
+        if hasattr(self, 'classifiers') and self.classifiers:
+            metrics_df = pd.DataFrame({
+                'Classifier': [clf[0] for clf in self.classifiers],
+                'Accuracy': [clf[1]['Accuracy'] for clf in self.classifiers],
+                'ROC-AUC': [clf[1]['ROC-AUC'] for clf in self.classifiers],
+                'F1': [clf[1]['F1'] for clf in self.classifiers]
+            })
+        
+            return metrics_df
+    
+    # Generate I-Genes Profile
+    def igenes_scores(self: 'DiseasePrediction'):
+        if self.use_igenes:
+            print('Generating I-Genes Scores...')
+
+            if self.classifiers:
+                normalized_importances = []
+                herfindahl_hirschman_indices = []
+                SHAP_values = []
+
+                for name, metrics in self.classifiers:
+                    if name != "Voting Classifier":
+                        if "Importances" in metrics:
+                            normalized_importances.append(metrics["Importances"])
+                            herfindahl_hirschman_indices.append(metrics["HHI"])
+                        if "SHAP Values" in metrics:
+                            SHAP_values.append(metrics["SHAP Values"])
+
+                if not normalized_importances or not herfindahl_hirschman_indices or not SHAP_values:
+                    return
+
+                num_classifiers = len(self.classifiers)
+                hhi_weights = (np.array(herfindahl_hirschman_indices) / np.sum(herfindahl_hirschman_indices))
+                initial_weights = (1 / (num_classifiers))
+                final_weights = (initial_weights + (initial_weights * hhi_weights))
+                                
+                igenes_scores = np.zeros_like(normalized_importances[0])
+                for weight, importance in zip(final_weights, normalized_importances):
+                    igenes_scores += weight * np.abs(importance)
+                
+                case_control_predictions = ['Cases' if importances > 0 else 'Controls' if importances < 0 else 'Cases' for importances in np.sum(normalized_importances, axis = 0)]
+                
+                igenes_df = pd.DataFrame({
+                    'Feature': self.X_train.columns,
+                    'I-Genes Score': np.round(igenes_scores, 4),
+                    'Prediction': case_control_predictions,  
+                })
+                
+                feature_expression = []
+                for i, prediction in enumerate(case_control_predictions):
+                    if prediction in ['Cases', 'Controls']:
+                        SHAP_normalized = [SHAP / np.max(np.abs(SHAP)) for SHAP in SHAP_values]
+                        aggregated_shap = np.sum([SHAP[:, i] for SHAP in SHAP_normalized], axis = 0)
+                    
+                        relevant_shap_samples = aggregated_shap > 0 if prediction == 'Positive' else aggregated_shap < 0
+                        if len(relevant_shap_samples) != len(self.X_test):
+                            raise ValueError("Length of SHAP samples does not match the number of rows in X_train.")
+
+                        feature_average = self.X_test.iloc[relevant_shap_samples, i].mean()
+                        overall_average = self.X_test.iloc[:, i].mean()
+
+                        if feature_average > overall_average:
+                            feature_expression.append('Overexpression')
+                        elif feature_average < overall_average:
+                            feature_expression.append('Underexpression')
+                        else:
+                            feature_expression.append('Inconclusive')
+                    else:
+                        feature_expression.append('Not Applicable')
+
+                igenes_df['Expression'] = feature_expression
+                igenes_df['I-Genes Rankings'] = igenes_df['I-Genes Score'].rank(ascending = False).astype(int)
+                igenes_df = igenes_df.sort_values(by = 'I-Genes Rankings')
+
+                return igenes_df
+    
+# Execute DiseasePrediction Class
+def main():
+    print("IntelliGenes Disease Prediction and I-Genes Scores...")
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-i', '--cgit_file', required = True)
+    parser.add_argument('-f', '--features_file', required = True)
+    parser.add_argument('-o', '--output_dir', required = True)
+    parser.add_argument('--voting', type = str, default = 'soft')
+    parser.add_argument('--random_state', type = int, default = 42)
+    parser.add_argument('--test_size', type = float, default = 0.3)
+    parser.add_argument('--n_splits', type = int, default = 5)
+    parser.add_argument('--no_rf', action = 'store_true')
+    parser.add_argument('--no_svm', action = 'store_true')
+    parser.add_argument('--no_xgb', action = 'store_true')
+    parser.add_argument('--no_knn', action = 'store_true')
+    parser.add_argument('--no_mlp', action = 'store_true')
+    parser.add_argument('--tune', action = 'store_true')
+    parser.add_argument('--normalize', action = 'store_true')
+    parser.add_argument('--no_igenes', action = 'store_true')
+    parser.add_argument('--no_visualizations', action = 'store_true')
+
+    args = parser.parse_args()
+
+    pipeline = DiseasePrediction(cgit_file = args.cgit_file,
+                                features_file = args.features_file,
+                                output_dir = args.output_dir,
+                                voting = args.voting,
+                                random_state = args.random_state,
+                                test_size = args.test_size,
+                                n_splits = args.n_splits,
+                                use_rf = not args.no_rf,
+                                use_svm = not args.no_svm,
+                                use_xgb = not args.no_xgb,
+                                use_knn = not args.no_knn,
+                                use_mlp = not args.no_mlp,
+                                use_tuning = args.tune,
+                                use_normalization = args.normalize,
+                                use_igenes = not args.no_igenes,
+                                use_visualization = not args.no_visualizations)
+    
+    pipeline.execute_classifiers()
+    metrics_df = pipeline.classifier_metrics()
+    igenes_df = pipeline.igenes_scores()
+    
+    if not os.path.exists(args.output_dir):
+        os.makedirs(args.output_dir)
+    
+    file_name = Path(args.cgit_file).stem
+    metrics_name = f"{file_name}_{datetime.now().strftime('%m-%d-%Y-%I-%M-%S-%p')}_Classifier-Metrics.csv"
+    metrics_file = os.path.join(args.output_dir, metrics_name)
+    
+    metrics_df.to_csv(metrics_file, index = False)
+    print("\n Clasifier Metrics:", metrics_file, "\n")
+    
+    if args.no_igenes is False: 
+        igenes_name = f"{file_name}_{datetime.now().strftime('%m-%d-%Y-%I-%M-%S-%p')}_I-Genes-Score.csv"
+        igenes_file = os.path.join(args.output_dir, igenes_name)
+        
+        igenes_df.to_csv(igenes_file, index = False)
+        print("\n I-Genes Scores:", igenes_file, "\n")
+                       
+if __name__ == '__main__':
+    main()