Feature_Selection_AI.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "3uBPxRUGXxpA",
        "zfQlN_rjX5vP",
        "GNPwmb3FZlvS",
        "-nSYCiX9Zthv",
        "-uP7xCHXaCGj",
        "N3RD9DDIaMfv",
        "IDJNf272ajMj"
      ],
      "authorship_tag": "ABX9TyOB3kG1eYFCzATJMl81NSrt",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ahmedhesham47/Bayesian-Network-for-Predicting-ICB-Response/blob/main/Feature_Selection_AI.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Importing Packages**"
      ],
      "metadata": {
        "id": "3uBPxRUGXxpA"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pz8K-XP8XvqC",
        "outputId": "92629148-3e36-4b1e-c042-892a425b8f2d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib as plt\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import train_test_split\n",
        "import pandas as pd\n",
        "from sklearn.ensemble import GradientBoostingClassifier\n",
        "from sklearn.feature_selection import RFE\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.feature_selection import SelectFromModel\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy.stats import ttest_ind\n",
        "from statsmodels.stats.multitest import multipletests\n",
        "from sklearn.feature_selection import f_classif\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.metrics import accuracy_score, f1_score, roc_auc_score\n",
        "from sklearn.pipeline import make_pipeline\n",
        "from itertools import combinations\n",
        "from functools import reduce\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "import itertools\n",
        "from scipy import stats\n",
        "from sklearn.svm import SVC"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Helper Functions**"
      ],
      "metadata": {
        "id": "T4saq0oVYN8v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def GeneExpressionPreprocessing(mRNAFile, DropList, GeneColumnName, Need_Transpose=True, Percent_To_FilterOut=20):\n",
        "  for i in DropList: # Dropping columns\n",
        "    mRNAFile = mRNAFile.drop(i, axis=1, errors='ignore')\n",
        "  if Need_Transpose == True: # transpose the file such that genes are columns and samples are rows\n",
        "    mRNAFile = mRNAFile.set_index(GeneColumnName)\n",
        "    mRNAFile = mRNAFile.T\n",
        "    mRNAFile = mRNAFile.rename_axis('Sample', axis=1)\n",
        "  # Filter out genes which are zeroes in certain percentage from the data.\n",
        "  filtered_data = mRNAFile.loc[:, (mRNAFile == 0).mean() * 100 <= Percent_To_FilterOut]\n",
        "  return filtered_data"
      ],
      "metadata": {
        "id": "GZf4_fR5YW1f"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def merge_on_common_column(dataframes, merge_column):\n",
        "    merged_df = dataframes[0]\n",
        "    for df in dataframes[1:]:\n",
        "        merged_df = pd.merge(merged_df, df, on=merge_column)\n",
        "    return merged_df"
      ],
      "metadata": {
        "id": "QVrDzD86Yd4O"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def merge_dataframes(dataframeslist, commoncolumn):\n",
        "  return reduce(lambda left, right: pd.merge(left, right, on=commoncolumn, how='inner'), dataframeslist)"
      ],
      "metadata": {
        "id": "5RlDoTGCYnKg"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def Best_Combinations(merged):\n",
        "  column_names = merged.columns\n",
        "  column_combinations = combinations(column_names, 6)\n",
        "  intersections = {}\n",
        "  # Compute the intersection for each combination\n",
        "  for combination in column_combinations:\n",
        "      # Drop NaN values and find the intersections from that particular combination\n",
        "      intersected_genes = set(merged[combination[0]].dropna()) & set(merged[combination[1]].dropna()) & \\\n",
        "                          set(merged[combination[2]].dropna()) & set(merged[combination[3]].dropna()) & \\\n",
        "                          set(merged[combination[4]].dropna())\n",
        "      intersections[combination] = intersected_genes\n",
        "  intersections_summary = {combo: len(genes) for combo, genes in intersections.items()} # this is not needed, it can only be used to see what each combination produced\n",
        "  max_combination = max(intersections, key=lambda x: len(intersections[x])) # the combination leading to the maximum number of genes\n",
        "  max_genes = intersections[max_combination] # the genes themselves\n",
        "  Final_Selected_Genes = list(max_genes) # making sures they are in a list\n",
        "  return Final_Selected_Genes"
      ],
      "metadata": {
        "id": "hTz2cakpYp5B"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_merged_df(rf, fdr, cor, sfm, gb, rfe):\n",
        "  #fdr.rename(columns={'Feature': 'Gene'}, inplace=True)\n",
        "\n",
        "  rf_top_genes = rf['Feature']\n",
        "\n",
        "  sfm_selected_genes = sfm['Feature']\n",
        "\n",
        "  correlation_top_genes = cor['Feature']\n",
        "\n",
        "  gb_top_genes = gb['Feature']\n",
        "\n",
        "  fdr_top_genes = fdr['Feature']\n",
        "\n",
        "  rfe_selected_genes = rfe['Feature']\n",
        "\n",
        "  all_genes = set(rf_top_genes) | set(sfm_selected_genes) | set(correlation_top_genes) | set(gb_top_genes) | set(fdr_top_genes) | set(rfe_selected_genes)\n",
        "  all_genes_list = list(all_genes)\n",
        "  # In sets, the \"|\" means union, so we get all the genes from all the feature selection methods\n",
        "\n",
        "  col = ['Random_Forest', 'Select_From_Model', 'Gene_Response_Correlation', 'Gradient_Boosting', 'Fisher_Discriminant_Ratio', 'Recursive_Feature_Elimination']\n",
        "  merged_df = pd.DataFrame(index=all_genes_list, columns=col) # this is an empty dataframe with rows as ALL the genes and columns as the feature selection methods\n",
        "\n",
        "  # We will now fill the dataframe with either a value (name of the gene) or NaN, which means the gene was not selected via this feature selection method\n",
        "  # For example...\n",
        "  # Random_Forest     Select_From_Model\"\n",
        "  # TP53              NaN\n",
        "  # And so on...\n",
        "\n",
        "  merged_df.loc[rf_top_genes, \"Random_Forest\"] = rf_top_genes.values\n",
        "  merged_df.loc[sfm_selected_genes, \"Select_From_Model\"] = sfm_selected_genes.values\n",
        "  merged_df.loc[correlation_top_genes, \"Gene_Response_Correlation\"] = correlation_top_genes.values\n",
        "  merged_df.loc[gb_top_genes, \"Gradient_Boosting\"] = gb_top_genes.values\n",
        "  merged_df.loc[fdr_top_genes, \"Fisher_Discriminant_Ratio\"] = fdr_top_genes.values\n",
        "  merged_df.loc[rfe_selected_genes, \"Recursive_Feature_Elimination\"] = rfe_selected_genes.values\n",
        "  return merged_df"
      ],
      "metadata": {
        "id": "IliUm0_ZYtIv"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Importing Files**"
      ],
      "metadata": {
        "id": "KRkcNqtJX2U1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "clinical_patient = pd.read_csv('/content/drive/MyDrive/Machine Learning Project/data_clinical_patient.txt', sep='\\t')\n",
        "clinical_sample = pd.read_csv('/content/drive/MyDrive/Machine Learning Project/data_clinical_sample.txt', sep='\\t')\n",
        "data_mrna = pd.read_csv('/content/drive/MyDrive/Machine Learning Project/data_mrna_seq_tpm.txt', sep='\\t')\n",
        "clinical_patient = clinical_patient.iloc[4:]\n",
        "clinical_sample = clinical_sample.iloc[4:]"
      ],
      "metadata": {
        "id": "0U_UOEdPX47f"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Pre-processing**"
      ],
      "metadata": {
        "id": "zfQlN_rjX5vP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "merged_clinical = merge_on_common_column([clinical_sample, clinical_patient], '#Patient Identifier')\n",
        "\n",
        "labels = merged_clinical[['Sample Identifier', 'Best Radiographic Response (RECIST 1.1)']]\n",
        "response_mapping = {\n",
        "    'Complete Response': 1,\n",
        "    'Partial Response': 1,\n",
        "    'Stable Disease': 0,\n",
        "    'Progressive Disease': 0\n",
        "}\n",
        "labels['Best Radiographic Response (RECIST 1.1)'] = labels['Best Radiographic Response (RECIST 1.1)'].map(response_mapping)\n",
        "labels = labels.dropna(subset = ['Best Radiographic Response (RECIST 1.1)', 'Sample Identifier'])\n",
        "labels = labels.rename(columns={'Best Radiographic Response (RECIST 1.1)': 'ICB Response'})\n",
        "labels['ICB Response'] = labels['ICB Response'].astype('category')\n",
        "filter_ids = labels['Sample Identifier']\n",
        "\n",
        "GeneExpressionData = GeneExpressionPreprocessing(data_mrna, ['Entrez_Gene_Id'], 'Hugo_Symbol')\n",
        "GeneExpressionData = GeneExpressionData.reset_index()\n",
        "GeneExpressionData = GeneExpressionData.rename(columns={'index': 'Sample Identifier'})\n",
        "GeneExpressionData = GeneExpressionData[GeneExpressionData['Sample Identifier'].isin(filter_ids)]"
      ],
      "metadata": {
        "id": "QnThy_iQX7L1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "GeneExpressionData"
      ],
      "metadata": {
        "id": "0hOmdKaaZZr4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Feature Selection**"
      ],
      "metadata": {
        "id": "BN4_WBM0X7xP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Random Forest**"
      ],
      "metadata": {
        "id": "GNPwmb3FZlvS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def feature_selection_with_rf(df, label_df, commoncolumn='Sample Identifier', labelID ='ICB Response', n_feature=1000, n_estimators=100, random_state=42):\n",
        "    merged_df = pd.merge(df, label_df, on=commoncolumn)\n",
        "    X = merged_df.drop(columns=[commoncolumn, labelID])\n",
        "    y = merged_df[labelID]\n",
        "    rf = RandomForestClassifier(n_estimators=n_estimators, random_state=random_state)\n",
        "    rf.fit(X, y)\n",
        "    rf_importances = rf.feature_importances_\n",
        "    rf_importances_df = pd.DataFrame({\n",
        "        'Feature': X.columns,\n",
        "        'Importance': rf_importances\n",
        "    })\n",
        "    rf_importances_df = rf_importances_df.sort_values(by='Importance', ascending=False)\n",
        "    rf_importances_df = rf_importances_df.head(n_feature)\n",
        "    rf_importances_df = rf_importances_df[rf_importances_df['Importance'] > 0]\n",
        "    return rf_importances_df"
      ],
      "metadata": {
        "id": "ywNVaJgQX9Yi"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rf_Expression = feature_selection_with_rf(GeneExpressionData, labels, 'Sample Identifier', 'ICB Response', n_estimators=1000)\n",
        "rf_Expression"
      ],
      "metadata": {
        "id": "NCaXCQb4Zh9Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Recursive Feature Elimination**"
      ],
      "metadata": {
        "id": "-nSYCiX9Zthv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def recursive_feature_elimination(df, labels_df, commoncolumn='Sample Identifier', labelID ='ICB Response', n_features_to_select=1000, step=100):\n",
        "    merged_df = pd.merge(df, labels_df, on=commoncolumn)\n",
        "    X = merged_df.drop([commoncolumn, labelID], axis=1)\n",
        "    y = merged_df[labelID]\n",
        "    scaler = StandardScaler()\n",
        "    X_scaled = scaler.fit_transform(X)\n",
        "    logreg = LogisticRegression()\n",
        "    rfe = RFE(estimator=logreg, n_features_to_select=n_features_to_select, step=step)\n",
        "    rfe.fit(X_scaled, y)\n",
        "    selected_features = pd.DataFrame({'Feature': X.columns,\n",
        "                                      'Selected': rfe.support_,\n",
        "                                      'Ranking': rfe.ranking_})\n",
        "    s = selected_features.sort_values(by='Ranking', ascending=True)\n",
        "\n",
        "    # Selecting genes with ranking = 1, that is the top n_features_to_select genes\n",
        "    s = s[s['Ranking'] == 1]\n",
        "    return s"
      ],
      "metadata": {
        "id": "iiwoPjuXZxgA"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rfe_Expression = recursive_feature_elimination(GeneExpressionData, labels, 'Sample Identifier', 'ICB Response', step=50)\n",
        "rfe_Expression"
      ],
      "metadata": {
        "id": "HK7sJQ9BZzh4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **SelectFromModel**"
      ],
      "metadata": {
        "id": "-uP7xCHXaCGj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def select_from_model(df, labels_df, commoncolumn='Sample Identifier', labelID ='ICB Response'):\n",
        "# Selecting features using Logistic Regression and SelectFromModel\n",
        "  merged_df = pd.merge(df, labels_df, on=commoncolumn)\n",
        "  X = merged_df.drop([commoncolumn, labelID], axis=1)\n",
        "  y = merged_df[labelID]\n",
        "  log_reg = LogisticRegression()\n",
        "  select_model = SelectFromModel(log_reg)\n",
        "  select_model.fit(X, y)\n",
        "  selection_status = select_model.get_support()\n",
        "  SelectFromModel_genes_df = pd.DataFrame({\n",
        "      'Feature': X.columns,\n",
        "      'Selected': selection_status\n",
        "  })\n",
        "  SelectFromModel_genes_df['Selected'] = SelectFromModel_genes_df['Selected'].astype(int)\n",
        "  SelectFromModel_genes_df = SelectFromModel_genes_df[SelectFromModel_genes_df['Selected'] == 1]\n",
        "\n",
        "  return SelectFromModel_genes_df"
      ],
      "metadata": {
        "id": "KtEAUdIiaENF"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sfm_Expression = select_from_model(GeneExpressionData, labels, 'Sample Identifier', 'ICB Response')\n",
        "sfm_Expression"
      ],
      "metadata": {
        "id": "dut44Bd8aGAq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Correlation**"
      ],
      "metadata": {
        "id": "N3RD9DDIaMfv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def correlation(df, labels_df, threshold=0.2, commoncolumn='Sample Identifier', labelID ='ICB Response', is_df_categorical=True):\n",
        "  merged_df = pd.merge(df, labels_df, on=commoncolumn)\n",
        "  X = merged_df.drop([commoncolumn, labelID], axis=1)\n",
        "  y = merged_df[labelID]\n",
        "\n",
        "  # Was producing an error because Pearson correlation (calculated by corr function) cannot correlate categoricals to floats\n",
        "  # So we added an else condition to handle the case where the data is not categorical to be calculated via point biserial method\n",
        "  if is_df_categorical:\n",
        "    correlation_values = X.apply(lambda gene: gene.corr(y))\n",
        "  else:\n",
        "    correlation_values = X.apply(lambda gene: stats.pointbiserialr(gene, y).correlation)\n",
        "\n",
        "\n",
        "  gene_correlation = pd.DataFrame({\n",
        "      'Feature': correlation_values.index,\n",
        "      'Correlation': correlation_values\n",
        "  })\n",
        "\n",
        "  gene_correlation = gene_correlation.sort_values(by='Correlation', key=abs, ascending=False)\n",
        "\n",
        "  selected_genes = gene_correlation[abs(gene_correlation['Correlation']) > threshold]\n",
        "\n",
        "  return selected_genes"
      ],
      "metadata": {
        "id": "_Cy3iRk1aYVQ"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Expression_correlation = correlation(GeneExpressionData, labels, 0.2, commoncolumn='Sample Identifier', labelID ='ICB Response')\n",
        "Expression_correlation"
      ],
      "metadata": {
        "id": "oNf-5_06aajQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Gradient Boost**"
      ],
      "metadata": {
        "id": "IDJNf272ajMj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def gradient_boosting(df, labels_df, commoncolumn='Sample Identifier', labelID ='ICB Response', nofeatures=1000, n_estimator = 100, random_state=42):\n",
        "  merged_df = pd.merge(df, labels_df, on=commoncolumn)\n",
        "  X = merged_df.drop([commoncolumn, labelID], axis=1)\n",
        "  y = merged_df[labelID]\n",
        "  gb_classifier = GradientBoostingClassifier(n_estimators=n_estimator, random_state=random_state)\n",
        "\n",
        "  gb_classifier.fit(X, y)\n",
        "\n",
        "  feature_importances_gb = gb_classifier.feature_importances_\n",
        "\n",
        "  gene_importances_gb = pd.DataFrame({\n",
        "      'Feature': X.columns,\n",
        "      'Importance': feature_importances_gb\n",
        "  })\n",
        "\n",
        "  sorted_gene_importances_gb = gene_importances_gb.sort_values(by='Importance', ascending=False)\n",
        "  sorted_gene_importances_gb = sorted_gene_importances_gb.head(nofeatures)\n",
        "  sorted_gene_importances_gb = sorted_gene_importances_gb[sorted_gene_importances_gb['Importance'] > 0]\n",
        "  return sorted_gene_importances_gb"
      ],
      "metadata": {
        "id": "HckCNJZQamDm"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "gb_Expression = gradient_boosting(GeneExpressionData, labels, commoncolumn='Sample Identifier', labelID ='ICB Response')\n",
        "gb_Expression"
      ],
      "metadata": {
        "id": "2A9r08zHaogJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Fischer's Discriminant Ratio (FDR)**"
      ],
      "metadata": {
        "id": "FZBaGB7qbGfA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fdr(df, labels_df, commoncolumn='Sample Identifier', n_feature=1000, labelID ='ICB Response'):\n",
        "  merged_df = pd.merge(df, labels_df, on=commoncolumn)\n",
        "  X = merged_df.drop([commoncolumn, labelID], axis=1)\n",
        "  y = merged_df[labelID]\n",
        "\n",
        "  f_scores, _ = f_classif(X, y)\n",
        "\n",
        "  fdr_df = pd.DataFrame({'Feature': X.columns, 'Fisher_Score': f_scores})\n",
        "\n",
        "  fdr_df = fdr_df.sort_values(by='Fisher_Score', ascending=False)\n",
        "\n",
        "  fdr_df = fdr_df.head(n_feature)\n",
        "\n",
        "  return fdr_df"
      ],
      "metadata": {
        "id": "v61_laGvbMAn"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fdr_Expression = fdr(GeneExpressionData, labels, commoncolumn='Sample Identifier', labelID ='ICB Response')\n",
        "fdr_Expression"
      ],
      "metadata": {
        "id": "qflsr3GMbOe3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Intersection Selection Methods**"
      ],
      "metadata": {
        "id": "toY5MvmfbgOY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Code only made to visualize the resulting dataframe, but it will not be used later\n",
        "\n",
        "fisher_selected = set(fdr_Expression['Feature']) #if we want SNP, we should make it fdr_SNP instead and so on\n",
        "\n",
        "gradient_boosting_selected = set(gb_Expression['Feature'])\n",
        "\n",
        "correlation_selected = set(Expression_correlation['Feature'])\n",
        "\n",
        "sfm_selected = set(sfm_Expression['Feature'])\n",
        "\n",
        "random_forest_selected = set(rf_Expression['Feature'])\n",
        "\n",
        "rfe_selected = set(rfe_Expression['Feature'])\n",
        "\n",
        "all_genes = set.union(fisher_selected, gradient_boosting_selected, correlation_selected, sfm_selected, random_forest_selected, rfe_selected)\n",
        "\n",
        "all_genes_list = list(all_genes)\n",
        "\n",
        "final_df = pd.DataFrame(index=all_genes_list, columns=[\"Fisher\", \"Gradient Boosting\", \"Correlation\", \"Select From Model\", \"Random Forest\", \"Recursive Feature Elimination\"])\n",
        "\n",
        "final_df[\"Fisher\"] = final_df.index.isin(fisher_selected).astype(int)\n",
        "final_df[\"Gradient Boosting\"] = final_df.index.isin(gradient_boosting_selected).astype(int)\n",
        "final_df[\"Correlation\"] = final_df.index.isin(correlation_selected).astype(int)\n",
        "final_df[\"Select From Model\"] = final_df.index.isin(sfm_selected).astype(int)\n",
        "final_df[\"Random Forest\"] = final_df.index.isin(random_forest_selected).astype(int)\n",
        "final_df[\"Recursive Feature Elimination\"] = final_df.index.isin(rfe_selected).astype(int)\n",
        "final_df"
      ],
      "metadata": {
        "id": "1Hd_mT7mbkGr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Merged_Expression = get_merged_df(rf_Expression, fdr_Expression, Expression_correlation, sfm_Expression, gb_Expression, rfe_Expression)\n",
        "Merged_Expression"
      ],
      "metadata": {
        "id": "BZNWf0kzbsrt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Best_Expression_Genes = Best_Combinations(Merged_Expression)\n",
        "len(Best_Expression_Genes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mQ15bc1qbxz4",
        "outputId": "4abfa420-fe81-4dcb-e27b-348e5631ba43"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "18"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "best_genes_expression = pd.DataFrame(Best_Expression_Genes, columns=['Gene_Name'])\n",
        "best_genes_expression.to_csv('Best Expression Genes.tsv', sep='\\t', index=False)\n",
        "filtered_Expression_Data = GeneExpressionData[['Sample Identifier'] + Best_Expression_Genes]\n",
        "filtered_Expression_Data.to_csv('Filtered Expression Genes.tsv', sep='\\t', index=False)"
      ],
      "metadata": {
        "id": "mPEWvWY9cDjg"
      },
      "execution_count": 38,
      "outputs": []
    }
  ]
}