sspa_walkthrough_local.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "80f98e82",
      "metadata": {
        "id": "80f98e82"
      },
      "source": [
        "# sspa tutorial: Single sample pathway analysis in Python\n",
        "This is the local tutorial notebook for the ssPA package."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "vXepmAdP8UAX",
      "metadata": {
        "id": "vXepmAdP8UAX"
      },
      "source": [
        "### Installing and importing required packages\n",
        "Please run all the cells in this section to ensure the following cells run smoothly"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "jjWnq7pe1DkE",
      "metadata": {
        "id": "jjWnq7pe1DkE"
      },
      "source": [
        "Install sspa"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "558f2667",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "558f2667",
        "outputId": "7a5bf57f-e445-4a50-888f-9e3133ef2195"
      },
      "outputs": [],
      "source": [
        "!pip install sspa"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "B_tuxMO81GT9",
      "metadata": {
        "id": "B_tuxMO81GT9"
      },
      "source": [
        "Import requried python packages"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a7354b9b",
      "metadata": {
        "id": "a7354b9b"
      },
      "outputs": [],
      "source": [
        "import sspa\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.decomposition import PCA\n",
        "import plotly.express as px\n",
        "import plotly.graph_objects as go\n",
        "import plotly.offline as pyo\n",
        "pyo.init_notebook_mode()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6f176214",
      "metadata": {
        "id": "6f176214"
      },
      "source": [
        "## Load and process metabolomics data"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4c1f00f4",
      "metadata": {
        "id": "4c1f00f4"
      },
      "source": [
        "Pre-processing example COVID mass spectrometry dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5baf2662",
      "metadata": {
        "id": "5baf2662"
      },
      "outputs": [],
      "source": [
        "covid_data = sspa.load_example_data(omicstype=\"metabolomics\", processed=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "13bce8b3",
      "metadata": {
        "id": "13bce8b3"
      },
      "outputs": [],
      "source": [
        "# Keep only metabolites (exclude metadata columns)\n",
        "covid_values = covid_data.iloc[:, :-2]\n",
        "# Remove features with too many na values\n",
        "data_filt = covid_values.loc[:, covid_values.isin([' ', np.nan, 0]).mean() < 0.5]\n",
        "\n",
        "# PQN normalisation\n",
        "met_median = data_filt.median(axis=0, skipna=True)  # median value for each metabolite\n",
        "scale_mat = data_filt.divide(met_median, axis=1)  # scale the matrix by the metabolite median\n",
        "samp_median = scale_mat.median(axis=1, skipna=True)  # median value for each sample\n",
        "norm_mat = data_filt.divide(samp_median, axis=0)  # scale by sample median\n",
        "\n",
        "# Impute using the median\n",
        "imputed_mat = norm_mat.fillna(norm_mat.median())\n",
        "# Log transform the data\n",
        "log2_mat = np.log2(imputed_mat)\n",
        "# Standardise the data\n",
        "processed_data = pd.DataFrame(StandardScaler().fit_transform(log2_mat), columns=imputed_mat.columns, index=imputed_mat.index)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1c9fa4ce",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 400
        },
        "id": "1c9fa4ce",
        "outputId": "d22d006f-2627-4299-f01e-fb627c8660f6"
      },
      "outputs": [],
      "source": [
        "processed_data.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "j_NQF-XfX8BF",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j_NQF-XfX8BF",
        "outputId": "3ba70b90-d949-4d4a-c3f5-e7d3461b2a2c"
      },
      "outputs": [],
      "source": [
        "covid_data['Group'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a0188612",
      "metadata": {
        "id": "a0188612"
      },
      "source": [
        "OPTIONAL: Save the processed data to .csv format"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5qZXupAoYDNE",
      "metadata": {
        "id": "5qZXupAoYDNE"
      },
      "outputs": [],
      "source": [
        "processed_data.to_csv(\"example_covid_data_processed.csv\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8331e3b3",
      "metadata": {
        "id": "8331e3b3"
      },
      "source": [
        "Alternatively, to load the pre-processed dataset, set the argument \"processed\" to True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ac5ee804",
      "metadata": {
        "id": "ac5ee804"
      },
      "outputs": [],
      "source": [
        "covid_data_processed = sspa.load_example_data(omicstype=\"metabolomics\", processed=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1e529143",
      "metadata": {
        "id": "1e529143"
      },
      "source": [
        "### Loading your own dataset\n",
        "\n",
        "The easiest way to load your own metabolomics dataset to use with sspa is to use the pandas.read_csv() function to read in the CSV file. You can also read in sample metadata as part of the same file, or as a separate file, as long as all metadata is in the form of pandas Series/DataFrame columns. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5f52a0d5",
      "metadata": {
        "id": "5f52a0d5"
      },
      "outputs": [],
      "source": [
        "# my_metabolomics_data = pd.read_csv(\"path/to/inputdata.csv\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "60b304f8",
      "metadata": {
        "id": "60b304f8"
      },
      "source": [
        "## Identifier harmonisation (optional)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fgXfNWNpDDse",
      "metadata": {
        "id": "fgXfNWNpDDse"
      },
      "source": [
        "To map compounds in the metabolomics data to those in pathways, we must ensure the metabolite IDs in the data match those in the pathway database used. \n",
        "\n",
        "The MetaboAnalyst (Pang et al., 2021) ID conversion tool can convert to and from many input formats including compound names, HMDB ID, KEGG ID, PubChem, ChEBI, and METLIN. In this protocol we will be using the sspa.identifier_conversion() functions to retrieve the compound mapping from the MetaboAnalyst API, but this can also be done using the GUI (https://www.metaboanalyst.ca/MetaboAnalyst/upload/ConvertView.xhtml). \n",
        "\n",
        "This step can take several minutes depending on how many identifiers you wish to convert. \n",
        "\n",
        "\n",
        "The output ID can be any of 'HMDB', 'PubChem', 'ChEBI', 'KEGG', 'METLIN', or 'SMILES'. \n",
        "\n",
        "First we will create a compound ID conversion table using the sspa.identifier_conversion(input_id_type, identifier_list) function. This function takes two arguments, the first is the input identifier type (see Table 4 of the protocol for possible inputs), and a list of compound names/identifiers. The example COVID metabolomics data has compound names as identifiers, so we will specify the ‘input_type’ argument as ‘name’. \n",
        "\n",
        "**CRITICAL**: It is highly recommended to check that the input identifiers (‘identifier_list’) are clean and do not contain anomalies such as semicolons ‘;’ which may result in spurious matches or errors in the identifier conversion module. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47f2edea",
      "metadata": {
        "id": "47f2edea"
      },
      "source": [
        "Use the identifier_conversion function to get identifier mappings. Change the input_type argument to the type of compound identifier you are converting from. This step may take a few minutes to complete."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2bfbc3c5",
      "metadata": {
        "id": "2bfbc3c5"
      },
      "outputs": [],
      "source": [
        "compound_names = processed_data.columns.tolist()\n",
        "conversion_table = sspa.identifier_conversion(input_type=\"name\", compound_list=compound_names)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9377d7ac",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 468
        },
        "id": "9377d7ac",
        "outputId": "d6d150f7-bea3-41f6-e30c-712ac985922d"
      },
      "outputs": [],
      "source": [
        "conversion_table"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "578bb89e",
      "metadata": {
        "id": "578bb89e"
      },
      "source": [
        "Count how many identifiers have matches"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1093d76f",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1093d76f",
        "outputId": "2f2c6f1c-a218-4056-efd8-23f28d7a1972"
      },
      "outputs": [],
      "source": [
        "conversion_table[\"Comment\"].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "iLCVYIEx_zFy",
      "metadata": {
        "id": "iLCVYIEx_zFy"
      },
      "source": [
        "OPTIONAL: export conversion table as a .csv file, manually update missing identifiers and re-upload the conversion table to proceed with the ID mapping step\n",
        "\n",
        "**Only run the following two cells if you wish to manually edit the ID matching results**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "VEAqYQJS_xlp",
      "metadata": {
        "id": "VEAqYQJS_xlp"
      },
      "outputs": [],
      "source": [
        "conversion_table.to_csv(\"conversion_table.csv\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "eVoY2jIFADCq",
      "metadata": {
        "id": "eVoY2jIFADCq"
      },
      "outputs": [],
      "source": [
        "conversion_table = pd.read_csv(\"conversion_table.csv\", index_col=0)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "VoNYlincCvef",
      "metadata": {
        "id": "VoNYlincCvef"
      },
      "source": [
        "We can then use the sspa.map_identifiers(conversion_table, output_id_type, data_matrix) function to convert the identifiers in our dataset. We must specify three arguments to the function: the conversion table generated in the previous step, the output ID type, and the matrix containing the metabolomics data. This function will return the metabolomics data matrix with mapped identifiers."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f5ac4d6a",
      "metadata": {
        "id": "f5ac4d6a"
      },
      "outputs": [],
      "source": [
        "processed_data_mapped = sspa.map_identifiers(conversion_table, output_id_type=\"ChEBI\", matrix=processed_data)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5afcb237",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 606
        },
        "id": "5afcb237",
        "outputId": "8f6a50fb-d0a2-46f0-b8ec-f3a844ce446a"
      },
      "outputs": [],
      "source": [
        "processed_data_mapped"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6520b3c4",
      "metadata": {
        "id": "6520b3c4"
      },
      "source": [
        "## Importing pathways"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "894da329",
      "metadata": {
        "id": "894da329"
      },
      "source": [
        "Sspa comes with pre-loaded versions of Reactome (all supported organisms) release 78 (2022) and KEGG (human) release 98 (2022). It also allows users to easily download the latest version of KEGG and Reactome (all supported organisms). Users can also provide their own pathway files, as long as they are in GMT format. \n",
        "\n",
        "The sspa package has several functions for processing data for different databases. These are:\n",
        "-\tProcess_reactome(organism, infile=None, download_latest=False, filepath=None)\n",
        "-\tProcess_kegg(organism, infile=None, download_latest=False, filepath=None)\n",
        "-\tProcess_gmt(infile) - load files in GMT format, ending in .gmt or .csv extension\n",
        "\n",
        "For KEGG and Reactome, you will need to specify the organism code/name in the function call. KEGG 3-letter organism codes e.g. “hsa”, “mmu”, can be found at http://rest.kegg.jp/list/organism. Reactome organism names e.g. “Homo sapiens”, “Mus musculus”, can be found at https://reactome.org/content/schema/objects/Species. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c6b23687",
      "metadata": {
        "id": "c6b23687"
      },
      "source": [
        "### Using pre-loaded pathway databases"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b647dfd2",
      "metadata": {
        "id": "b647dfd2"
      },
      "source": [
        "Import the pre-loaded Reactome metabolic pathways (Release 78)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ae872e22",
      "metadata": {
        "id": "ae872e22"
      },
      "outputs": [],
      "source": [
        "# We will import the metabolite pathways from the Reactome database\n",
        "# We must specify one of the Reactome organism names\n",
        "# This returns a GMT format pandas DataFrame containing the pathway information\n",
        "reactome_pathways  = sspa.process_reactome(organism=\"Homo sapiens\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bf493ed2",
      "metadata": {
        "id": "bf493ed2"
      },
      "outputs": [],
      "source": [
        "kegg_human_pathways  = sspa.process_kegg(organism=\"hsa\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5aee5d68",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        },
        "id": "5aee5d68",
        "outputId": "02190123-54b2-4e41-9c13-925daee2596f"
      },
      "outputs": [],
      "source": [
        "reactome_pathways.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "602221f3",
      "metadata": {
        "id": "602221f3"
      },
      "outputs": [],
      "source": [
        "kegg_human_pathways.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "299e2e51",
      "metadata": {
        "id": "299e2e51"
      },
      "source": [
        "### Specifying your own pathways (in GMT format)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "85d6fd25",
      "metadata": {},
      "source": [
        "Here we load the latest release of WikiPathways by saving the .GMT file from the WikiPathways website and processing it usign the sspa process_gmt function. \n",
        "\n",
        "NOTE: A list of current WikiPathways GMT files and urls can be found [here](https://wikipathways-data.wmcloud.org/current/gmt/)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4749bd24",
      "metadata": {
        "id": "4749bd24"
      },
      "outputs": [],
      "source": [
        "import urllib.request\n",
        "\n",
        "wikipathways_url = \"https://wikipathways-data.wmcloud.org/current/gmt/wikipathways-20220910-gmt-Mus_musculus.gmt\"\n",
        "\n",
        "urllib.request.urlretrieve(wikipathways_url, \"wikipathways-20220910-gmt-Homo_sapiens.gmt\")\n",
        "\n",
        "# load the GMT file using sspa\n",
        "custom_pathways = sspa.process_gmt(\"wikipathways-20220910-gmt-Homo_sapiens.gmt\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fdad3679",
      "metadata": {
        "id": "fdad3679"
      },
      "outputs": [],
      "source": [
        "custom_pathways"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2693ff70",
      "metadata": {
        "id": "2693ff70"
      },
      "source": [
        "## Downloading latest versions of KEGG and Reactome databases and MetExplore pathway networks"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8e00d3e7",
      "metadata": {
        "id": "8e00d3e7"
      },
      "source": [
        "### Download latest KEGG pathways"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9cb1970d",
      "metadata": {
        "id": "9cb1970d"
      },
      "outputs": [],
      "source": [
        "kegg_mouse_latest = sspa.process_kegg(\"mmu\", download_latest=True, filepath=\".\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2bff5527",
      "metadata": {
        "id": "2bff5527"
      },
      "source": [
        "### Download latest Reactome pathways"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "30b4753e",
      "metadata": {
        "id": "30b4753e"
      },
      "outputs": [],
      "source": [
        "# download Reactome latest\n",
        "reactome_mouse_latest = sspa.process_reactome(\"Mus musculus\", download_latest=True, filepath=\".\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "KV8VuNjWI8xd",
      "metadata": {
        "id": "KV8VuNjWI8xd"
      },
      "source": [
        "### Download latest metabolic network pathways from MetExplore\n",
        "\n",
        "The possible identifier types are:\n",
        "\n",
        "\n",
        "*   \"chebi\"\n",
        "*   \"kegg\"\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Kmzteo7rI9PX",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kmzteo7rI9PX",
        "outputId": "4b656699-3086-46dd-97a2-5f01ca6d41e2"
      },
      "outputs": [],
      "source": [
        "ihuman = sspa.MetExplorePaths(model='6422', id_type=\"chebi\", filepath=None)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ICxmtI9nJFc1",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ICxmtI9nJFc1",
        "outputId": "4b1ebb20-fcb6-4d56-abb6-94d3dcb55815"
      },
      "outputs": [],
      "source": [
        "print(ihuman.nMetab, \"total metabolites in the metabolic network\")\n",
        "print(ihuman.nMappedID, \"metabolites with ChEBI identifiers\")\n",
        "coverage = int(ihuman.nMappedID)/int(ihuman.nMetab)*100\n",
        "print(\"the coverage of metabolites in term of ChEBI identifiers for the network is\", round(coverage,1),\"%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "uLJ39MN8JE7y",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "uLJ39MN8JE7y",
        "outputId": "293a3964-7c21-4869-d263-9f2aaab769cf"
      },
      "outputs": [],
      "source": [
        "ihuman.pathways.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ffc4b480",
      "metadata": {
        "id": "ffc4b480"
      },
      "source": [
        "Read in a .gmt file (here we use the latest Reactome pathways downloaded in the cell above)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2cf95abd",
      "metadata": {
        "id": "2cf95abd"
      },
      "outputs": [],
      "source": [
        "reactome_mouse_latest_read = sspa.process_gmt(\"./Reactome_Mus_musculus_pathways_compounds_R79.gmt\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e4f895f0",
      "metadata": {
        "id": "e4f895f0"
      },
      "outputs": [],
      "source": [
        "reactome_mouse_latest_read"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "rA8kb4DtQkku",
      "metadata": {
        "id": "rA8kb4DtQkku"
      },
      "source": [
        "## Checking ID mappings\n",
        "Check how many of the mapped compound identifiers are in the pathway database (i.e. annotated to a pathway):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Dvy1CoHLQJLG",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dvy1CoHLQJLG",
        "outputId": "04eccac5-2df1-45bd-e927-e0fb325336c7"
      },
      "outputs": [],
      "source": [
        "## if using Reactome database as the pathway database\n",
        "# count all compounds in the dataset\n",
        "print(len(compound_names), \"compounds in the dataset\")\n",
        "\n",
        "# find how many input compound names in the dataset had a matching ChEBI ID\n",
        "chebi_matches = conversion_table[(conversion_table[\"Comment\"] == \"1\") & (conversion_table[\"ChEBI\"].isnull()==False)][\"ChEBI\"]\n",
        "print(len(chebi_matches), \"compounds from the dataset that have ChEBI IDs\")\n",
        "\n",
        "# count all unique compounds in the Reactome database\n",
        "all_reactome_cpds = set(sum(sspa.utils.pathwaydf_to_dict(reactome_pathways).values(), []))\n",
        "print(len(all_reactome_cpds), \"total unique compounds in Reactome\")\n",
        "\n",
        "# find the intesect between all reactome compounds and all ChEBI IDs annotated to the dataset\n",
        "mapped_annotated_cpds = set(processed_data_mapped.columns) & all_reactome_cpds\n",
        "print(len(mapped_annotated_cpds), \"compounds present in both the dataset and Reactome pathways\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "mCspudfs3GI5",
      "metadata": {
        "id": "mCspudfs3GI5"
      },
      "outputs": [],
      "source": [
        "## if using the metabolite network ihuman1.10 as the pathway database\n",
        "# count all compounds in the dataset\n",
        "print(len(compound_names), \"compounds in the dataset\")\n",
        "\n",
        "# find how many input compound names in the dataset had a matching ChEBI ID\n",
        "chebi_matches = conversion_table[(conversion_table[\"Comment\"] == \"1\") & (conversion_table[\"ChEBI\"].isnull()==False)][\"ChEBI\"]\n",
        "print(len(chebi_matches), \"compounds from the dataset that have ChEBI IDs\")\n",
        "\n",
        "# get the total number of metabolites in the network\n",
        "print(ihuman.nMetab, \"total compounds in the metabolic network\")\n",
        "\n",
        "# get the total number of metabolites with ChEBI in the network\n",
        "print(ihuman.nChEBI, \"total compounds with ChEBI identifiers in the metabolic network\")\n",
        "\n",
        "# count all unique ChEBI in the metabolic network\n",
        "all_ihuman_ChEBI = set(sum(sspa.utils.pathwaydf_to_dict(ihuman.pathways).values(), []))\n",
        "print(len(all_ihuman_ChEBI), \"total unique ChEBI identifiers in metabolic network\")\n",
        "\n",
        "# find the intesect between all network compounds and all ChEBI IDs annotated to the dataset\n",
        "mapped_annotated_cpds = set(processed_data_mapped.columns) & all_ihuman_ChEBI\n",
        "print(len(mapped_annotated_cpds), \"compounds present in both the dataset and network pathways\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "oOtQA67GBjbT",
      "metadata": {
        "id": "oOtQA67GBjbT"
      },
      "source": [
        "Visualise this in barchart form:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "kBK6tIgJQRb4",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 293
        },
        "id": "kBK6tIgJQRb4",
        "outputId": "f0c2f3ec-ca52-46c3-9df5-3dbd6567bec9"
      },
      "outputs": [],
      "source": [
        "sns.set_context('notebook')\n",
        "sns.set_style('ticks')\n",
        "sns.barplot(y=[len(compound_names), len(chebi_matches), len(mapped_annotated_cpds)], x=['Original', 'Mapping to CHEBI', 'Annotated to Reactome'])\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "zeu_xrHKBl2R",
      "metadata": {
        "id": "zeu_xrHKBl2R"
      },
      "source": [
        "Or funnel plot..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "z2yHCaLA_PBw",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "z2yHCaLA_PBw",
        "outputId": "6cbb53e1-6326-4cce-e533-473922d2f363"
      },
      "outputs": [],
      "source": [
        "data = dict(count=[len(compound_names), len(chebi_matches), len(mapped_annotated_cpds)],\n",
        "            label=['Original', 'Mapping to CHEBI', 'Annotated to Reactome'])\n",
        "\n",
        "fig = px.funnel(data, x='count', y='label')\n",
        "fig.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "C_8zUNbxQo-n",
      "metadata": {
        "id": "C_8zUNbxQo-n"
      },
      "source": [
        "Here we plot an interactive heatmap that shows which compounds have mapped to pathway database IDs, and those that are present in pathways. Hover over the plot or **zoom in** to see the compound names."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "O_0PapUeQWk4",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "O_0PapUeQWk4",
        "outputId": "60083279-a947-4c2a-ae49-de15c1dc585a"
      },
      "outputs": [],
      "source": [
        "import plotly.io as pio\n",
        "pio.renderers.default = \"notebook\"\n",
        "\n",
        "df = pd.DataFrame(compound_names, columns=['Original_ID'])\n",
        "df[\"Matched_ID\"] = df['Original_ID'].map(dict(zip(conversion_table[\"Query\"], conversion_table[\"ChEBI\"])))\n",
        "df[\"In_pathway\"] = [i if i in mapped_annotated_cpds else \"NA\" for i in df[\"Matched_ID\"] ]\n",
        "df = df.replace({\"NA\":0})\n",
        "df[df != 0] = 1\n",
        "df = df.astype(\"float\")\n",
        "df.index = compound_names\n",
        "\n",
        "fig = px.bar(df)\n",
        "fig.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "L2dyVpI4-Pcm",
      "metadata": {
        "id": "L2dyVpI4-Pcm"
      },
      "source": [
        "How many pathways contain at least two mapped compounds?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "vtOA9WAXXxbi",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vtOA9WAXXxbi",
        "outputId": "146751ad-3c5c-4265-b957-c7cf160ffc03"
      },
      "outputs": [],
      "source": [
        "# convert the pathway dataframe to dictionary - for faster calculations\n",
        "# replace reactome_pathways with the variable containing the pathway dataframe being used\n",
        "pathways_dict = sspa.utils.pathwaydf_to_dict(reactome_pathways)\n",
        "\n",
        "# How many pathways contain at least two mapped compounds?\n",
        "pathways_present = {k: v for k, v in pathways_dict.items() if len([i for i in processed_data_mapped.columns if i in v]) > 1}\n",
        "print(len(pathways_present))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6dc5de34",
      "metadata": {
        "id": "6dc5de34"
      },
      "source": [
        "## Conventional pathway analysis methods"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7b026712",
      "metadata": {
        "id": "7b026712"
      },
      "source": [
        "### ORA"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3dad2396",
      "metadata": {
        "id": "3dad2396"
      },
      "source": [
        "1. Identify the background set to be used. By default, sspa uses all the compounds annotated in the input metabolomics data (i.e. all the column identifiers) as the background set. Alternatively, the sspa_ora() class allows the user to specify a custom background set of compounds to be used. This must be passed to the class using the argument ‘custom_background’ (see step 2) in the form of a python list, containing compound identifiers specific to the pathway database used. \n",
        "\n",
        "2. Initiate an object of the sspa_ora class with the required parameters. The class parameters are the processed metabolomics DataFrame with identifiers corresponding to those in the pathway database to be used (processed_data_mapped), a pandas Series containing the sample metadata (covid_data[\"Group\"]), pathway database, the cutoff alpha threshold for differential abundance analysis, and an optional custom background set. Here we are using $a$ = 0.05 to select differentially abundant metabolites, and all the metabolites in the processed abundance matrix as the background set (default).  This step will also perform differential abundance analysis using t-tests. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1f8e74bb",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1f8e74bb",
        "outputId": "976f747c-cef1-4ae1-8d7d-7e28a3515e51"
      },
      "outputs": [],
      "source": [
        "# initiate an ORA object \n",
        "ora = sspa.sspa_ora(processed_data_mapped, covid_data[\"Group\"], reactome_pathways, 0.05, custom_background=None)\n",
        "\n",
        "# perform ORA \n",
        "ora_res = ora.over_representation_analysis()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "DIXHEWNfyc4y",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DIXHEWNfyc4y",
        "outputId": "7c1dc656-2e6a-46d5-b5ec-9aa339fb399b"
      },
      "outputs": [],
      "source": [
        "ora.DA_molecules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0Sjgpghyybo4",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 166
        },
        "id": "0Sjgpghyybo4",
        "outputId": "30b899fc-ea81-4902-bff4-8c317ee76a57"
      },
      "outputs": [],
      "source": [
        "ora.ttest_res.sort_values(by=\"P-value\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "CEX3gQdUymph",
      "metadata": {
        "id": "CEX3gQdUymph"
      },
      "source": [
        "Now we can examine the table containing the ORA results:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "X7Fc5O2Gye-5",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "id": "X7Fc5O2Gye-5",
        "outputId": "374f63ea-a3db-4935-8aa1-094491d37e1c"
      },
      "outputs": [],
      "source": [
        "ora_res"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e3279493",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "id": "e3279493",
        "outputId": "f75cdf04-2d27-4426-881c-58267f8383de"
      },
      "outputs": [],
      "source": [
        "ora_res.sort_values(by=\"P-value\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8a619dd6",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 394
        },
        "id": "8a619dd6",
        "outputId": "658aebae-1ce4-4a5a-eb36-f6bb0d5bc261"
      },
      "outputs": [],
      "source": [
        "top_20_pathways = ora_res.sort_values(by=\"P-value\").iloc[0:20, :]\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.barplot(data=top_20_pathways, y=\"Pathway_name\", x=\"P-value\", orient=\"h\", palette=\"magma\")\n",
        "plt.axvline(0.05, c=\"black\")\n",
        "# plt.savefig(\"ORA_top_20.png\", dpi=300, bbox_inches=\"tight\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "95d60c02",
      "metadata": {
        "id": "95d60c02"
      },
      "source": [
        "### GSEA\n",
        "GSEA is a popular method for pathway analysis in the transcriptomics community (Subramanian et al., 2005). The sspa package has a wrapper function to allow users to use the R-based fast implementation of GSEA, fGSEA (Korotkevich, Sukhov and Sergushichev, 2019). The sspa function sspa_fgsea uses the signal-to-noise ratio as the metabolite ranking metric for GSEA. We encourage users to read about various ranking metrics available (Zyla et al., 2017) and experiment with the fGSEA package if they wish to use other ranking metrics. \n",
        "\n",
        "Run gsea using the sspa_fgsea() function. This function requires the processed metabolomics data, a pandas series containing the sample metadata, and the pathways DataFrame as input. The ranking metric used is the signal-to-noise ratio. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "10ba0cbb",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "10ba0cbb",
        "outputId": "2d32ebae-a6f6-4fec-eca2-b8a392b883ed"
      },
      "outputs": [],
      "source": [
        "gsea_res = sspa.sspa_fgsea(processed_data_mapped, covid_data['Group'], reactome_pathways)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "57343795",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 554
        },
        "id": "57343795",
        "outputId": "7dfc07fe-3ead-433c-8982-17b83cf1c5f1"
      },
      "outputs": [],
      "source": [
        "gsea_res.sort_values(by=\"P-value\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "oAknbOhq7dsV",
      "metadata": {
        "id": "oAknbOhq7dsV"
      },
      "source": [
        "Plot the GSEA results - GSEA provides us with an enrichment score which can be positive or negative, this is highlighted using the bar colour. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1587d5c6",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 388
        },
        "id": "1587d5c6",
        "outputId": "da9f70bd-1e06-4584-b054-1c9061ceb8cf"
      },
      "outputs": [],
      "source": [
        "from matplotlib.lines import Line2D\n",
        "\n",
        "top_20_pathways_gsea = gsea_res.sort_values(by=\"P-value\").iloc[0:20, :]\n",
        "plt.figure(figsize=(8, 6))\n",
        "\n",
        "# set bar colour based on normalised enrichment score sign\n",
        "bar_color = ['tab:red' if float(i) < 0 else 'tab:blue' for i in top_20_pathways_gsea['NES']]\n",
        "sns.barplot(data=top_20_pathways_gsea, y=\"Pathway_name\", x=\"P-value\", orient=\"h\", palette=bar_color)\n",
        "plt.axvline(0.05, c=\"black\")\n",
        "\n",
        "# add legend\n",
        "custom_lines = [Line2D([0], [0], color='tab:red', lw=4),\n",
        "                Line2D([0], [0], color='tab:blue', lw=4)]\n",
        "plt.legend(handles=custom_lines, labels=['Positive enrichment score', 'Negative enrichment score'])\n",
        "plt.show()\n",
        "\n",
        "# plt.savefig(\"GSEA_top_20.png\", dpi=300, bbox_inches=\"tight\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6362b966",
      "metadata": {
        "id": "6362b966"
      },
      "source": [
        "## Single-sample pathway analysis methods"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "35aabf16",
      "metadata": {
        "id": "35aabf16"
      },
      "source": [
        "Using kPCA method"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9646c473",
      "metadata": {
        "id": "9646c473"
      },
      "outputs": [],
      "source": [
        "kpca_scores = sspa.sspa_kpca(processed_data_mapped, reactome_pathways)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6d028953",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 623
        },
        "id": "6d028953",
        "outputId": "8f8922e9-6d16-4890-aae4-07840ab69b8f"
      },
      "outputs": [],
      "source": [
        "# Inspect the pathway score matrix\n",
        "kpca_scores"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0647321d",
      "metadata": {
        "id": "0647321d"
      },
      "source": [
        "### Visualise single-sample pathway analysis results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "Hxdjd2Lk6aPo",
      "metadata": {
        "id": "Hxdjd2Lk6aPo"
      },
      "source": [
        "Pathway-based PCA plot"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "12d617b5",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 407
        },
        "id": "12d617b5",
        "outputId": "31f89525-ce75-499d-d729-acb8b44569c3"
      },
      "outputs": [],
      "source": [
        "# Pathway-based PCA plot\n",
        "\n",
        "# Normalise kPCA scores\n",
        "kpca_scores_norm = pd.DataFrame(StandardScaler().fit_transform(kpca_scores))\n",
        "\n",
        "# Perform two component PCA using sklearn\n",
        "pca = PCA(n_components=2)\n",
        "pca_res = pca.fit_transform(kpca_scores_norm)\n",
        "\n",
        "# determine the variance explained by the first 2 components\n",
        "pca.explained_variance_ratio_\n",
        "\n",
        "# Plot the first two components as a scatterplot\n",
        "plt.style.use(\"default\")\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)\n",
        "sns.scatterplot(x=pca_res[:, 0 ], y=pca_res[:, 1], hue=covid_data[\"Group\"], ax=ax1, s=50, alpha=0.5)\n",
        "sns.scatterplot(x=pca_res[:, 0 ], y=pca_res[:, 1], hue=covid_data[\"WHO_status\"], ax=ax2, s=50, alpha=0.5)\n",
        "\n",
        "# Set axis labels \n",
        "ax1.set_xlabel('PC1 (' + str(round(pca.explained_variance_ratio_[0]*100,2)) + '%)')\n",
        "ax1.set_ylabel('PC2 (' + str(round(pca.explained_variance_ratio_[1]*100,2)) + '%)')\n",
        "ax2.set_xlabel('PC1 (' + str(round(pca.explained_variance_ratio_[0]*100,2)) + '%)')\n",
        "ax2.set_ylabel('PC2 (' + str(round(pca.explained_variance_ratio_[1]*100,2)) + '%)')\n",
        "\n",
        "plt.tight_layout()\n",
        "# plt.savefig(\".kpca_pca_plots.png\", dpi=350, bbox_inches=\"tight\")\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "wNowN7D36dQX",
      "metadata": {
        "id": "wNowN7D36dQX"
      },
      "source": [
        "PCA loadings based on pathways - hover over datapoints to see the pathway name associated with the loading"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "rx9GW6R66gNv",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 617
        },
        "id": "rx9GW6R66gNv",
        "outputId": "155f79af-6e90-42b2-d826-75844fb3eb92"
      },
      "outputs": [],
      "source": [
        "# get the loadings of the pathway-based PCA\n",
        "loadings = pd.DataFrame(pca.components_.T* np.sqrt(pca.explained_variance_)*10,columns=['PC1','PC2'], index=kpca_scores.columns)\n",
        "\n",
        "# add pathway names to the loadings dataframe\n",
        "loadings['Pathway'] = loadings.index.map(dict(zip(reactome_pathways.index, reactome_pathways['Pathway_name'])))\n",
        "\n",
        "# subset top 10 loadings for visual clarity\n",
        "loadings_top_10 = loadings.sort_values(by='PC1').iloc[0:10, :]\n",
        "\n",
        "# Plot the first two components as a scatterplot\n",
        "fig = px.scatter(x=pca_res[:, 0 ], y=pca_res[:, 1], color=covid_data[\"Group\"], labels={'x':'PC1', 'y':'PC2'})\n",
        "\n",
        "# Plot lines to origin representing the loadings\n",
        "for i in range(0, loadings_top_10.shape[0]):\n",
        "  fig.add_trace(go.Scatter(x=[0, loadings_top_10.iloc[i, :]['PC1']], y=[0, loadings_top_10.iloc[i, :]['PC2']],\n",
        "                           line_color='black', marker_size=0, text=loadings_top_10.iloc[i, :]['Pathway']))\n",
        "\n",
        "fig.update_layout(width=600, height=600, yaxis_range=[-10, 10], xaxis_range=[-15, 15], showlegend=False)\n",
        "\n",
        "fig.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8Nitac257iNP",
      "metadata": {
        "id": "8Nitac257iNP"
      },
      "source": [
        "Use pathway scores to plot a hierarchical clustering heatmap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "55a36fa0",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "55a36fa0",
        "outputId": "01a2e547-157d-4747-a280-04dbf75e2732"
      },
      "outputs": [],
      "source": [
        "# Plot a heatmap using the pathway scores\n",
        "g = sns.clustermap(kpca_scores_norm.T,\n",
        "               cmap=\"RdBu_r\",\n",
        "               z_score=1,\n",
        "              col_colors = [\"tab:red\" if i == \"COVID19 \" else \"tab:green\" for i in covid_data[\"Group\"]],\n",
        "              xticklabels=False,\n",
        "              yticklabels=False)\n",
        "g.ax_heatmap.set_xlabel(\"Samples\")\n",
        "g.ax_heatmap.set_ylabel(\"Pathways\")\n",
        "\n",
        "# plt.savefig(\"kpca_heatmap.png\", dpi=350, bbox_inches=\"tight\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2cdd086e",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 585
        },
        "id": "2cdd086e",
        "outputId": "ac9bbd97-7e0b-4f9b-c233-4a5fb1468820"
      },
      "outputs": [],
      "source": [
        "# Plot pathway scores from two pathways against each other\n",
        "P1 = \"R-HSA-392499\"\n",
        "P2 = \"R-HSA-425397\"\n",
        "plt.style.use(\"default\")\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6), sharex=True, sharey=True)\n",
        "sns.scatterplot(x=kpca_scores.loc[:, P1], y=kpca_scores.loc[:, P2], hue=covid_data[\"Group\"], ax=ax1, s=100, alpha=0.5)\n",
        "sns.scatterplot(x=kpca_scores.loc[:, P1], y=kpca_scores.loc[:, P2], hue=covid_data[\"WHO_status\"], ax=ax2, s=100, alpha=0.5)\n",
        "# Set axis labels \n",
        "ax1.set_xlabel(P1 + \" - \" + reactome_pathways.loc[P1][\"Pathway_name\"])\n",
        "ax1.set_ylabel(P2 + \" - \" + reactome_pathways.loc[P2][\"Pathway_name\"])\n",
        "ax2.set_xlabel(P1 + \" - \" + reactome_pathways.loc[P1][\"Pathway_name\"])\n",
        "ax2.set_ylabel(P2 + \" - \" + reactome_pathways.loc[P2][\"Pathway_name\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6d8e0734",
      "metadata": {
        "id": "6d8e0734"
      },
      "source": [
        "### Additional sspa methods"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f26a7990",
      "metadata": {
        "id": "f26a7990"
      },
      "source": [
        "Using ssClustPA method"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6b5ebd60",
      "metadata": {
        "id": "6b5ebd60"
      },
      "outputs": [],
      "source": [
        "ssclustpa_res = sspa.sspa_cluster(processed_data_mapped, reactome_pathways)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f766ac82",
      "metadata": {
        "id": "f766ac82"
      },
      "outputs": [],
      "source": [
        "ssclustpa_res.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "63b2f732",
      "metadata": {
        "id": "63b2f732"
      },
      "source": [
        "Using z-score method"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a315ee76",
      "metadata": {
        "id": "a315ee76"
      },
      "outputs": [],
      "source": [
        "zscore_res = sspa.sspa_zscore(processed_data_mapped, reactome_pathways)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2e621bd6",
      "metadata": {
        "id": "2e621bd6"
      },
      "outputs": [],
      "source": [
        "zscore_res.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "311d7f9f",
      "metadata": {
        "id": "311d7f9f"
      },
      "source": [
        "Using SVD (PLAGE) method"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "148eb8dd",
      "metadata": {
        "id": "148eb8dd"
      },
      "outputs": [],
      "source": [
        "svd_res = sspa.sspa_svd(processed_data_mapped, reactome_pathways)\n",
        "svd_res.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "20047e0d",
      "metadata": {
        "id": "20047e0d"
      },
      "source": [
        "Using GSVA (Hanzelmann et al)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f140e2f9",
      "metadata": {
        "id": "f140e2f9"
      },
      "outputs": [],
      "source": [
        "gsva_res = sspa.sspa_gsva(processed_data_mapped, reactome_pathways)\n",
        "gsva_res.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "OnRMHBcqd_jl",
      "metadata": {
        "id": "OnRMHBcqd_jl"
      },
      "source": [
        "Using ssGSEA (Barbie et al)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7fz2fpy-d-3W",
      "metadata": {
        "id": "7fz2fpy-d-3W"
      },
      "outputs": [],
      "source": [
        "ssgsea_res = sspa.sspa_ssGSEA(processed_data_mapped, reactome_pathways)\n",
        "ssgsea_res.head()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3.10.4 ('py10')",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.4"
    },
    "vscode": {
      "interpreter": {
        "hash": "c3eb9a8bb45b8718f93eee5631f3f6397d0951cd9e56adb2080c5db4d467cb19"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}