BIDS_03_DimensionReduction_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aim to complete as much of this tutorial on your own *before* coming to the practical session.\n",
    "\n",
    "Use the practical session to get help for any aspect you do not understand or were unable to complete."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dimensionality Reduction 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Learning objectives\n",
    "1. Apply MDS to different data sets and interpret the outputs using the popular python library [sklearn](https://scikit-learn.org/stable/)\n",
    "2. Learn how to visualise the model outputs\n",
    "3. Interpret the results and compare them with PCA\n",
    "\n",
    "Optional learning objective (view the video online about NNMF before you start)\n",
    "\n",
    "4. Apply NNMF to different data sets, visualise and interpret the output and compare them with PCA and MDS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import specific packages and functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.decomposition import NMF, PCA\n",
    "from sklearn.metrics import DistanceMetric\n",
    "from sklearn.manifold import MDS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load in dataset\n",
    "Read in the omics datasets using the pandas [read_excel()](https://pandas.pydata.org/docs/reference/api/pandas.read_excel.html) function. For this example we will be using a urine metabolomics data from a diabetes cohort. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diabetes_urine_metab = pd.read_excel(\"../Data-main/diabetes_metabolomics_urine.xlsx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diabetes_urine_metab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see there are several covariates in the first columns: Age, Gender, BMI, ETH, and T2D (diabetes status). To obtain just the metabolite relative abundance data, we can use `diabetes_urine_metab.iloc[:, 6:]`. This takes all rows of the data, and all columns after the 6th column."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multidimensional Scaling (MDS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Multidimensional scaling](https://scikit-learn.org/0.24/modules/manifold.html#multidimensional-scaling) (MDS) seeks a low-dimensional representation of the data in which the distances respect well the distances in the original high-dimensional space. MDS (both metric and non-metric) can be performed using the [sklearn.MDS()](https://scikit-learn.org/stable/modules/generated/sklearn.manifold.MDS.html) function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some algorithms make use of a random process, e.g. to initialise weights it select initial starting points from a random number generator. This means that each time you use the algorithm, the answer might be slightly (sometimes this is unnoticeable) different. Also, this may mean the output you get is different from your neighbour.\n",
    "\n",
    "How do you get the same answer each time (as long as you do not change any other parameters)? You can set the random state to a specific number.\n",
    "\n",
    "Random number generators use the computer time and other factors to start at a random place in a huge sequence of random numbers. By setting the ```random_state``` property of an algorithm you will ensure it will start at a standard place. You can pick any positive integer for this. If you look at the documentation of [PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html?highlight=pca#sklearn.decomposition.PCA) and [MDS](https://scikit-learn.org/stable/modules/generated/sklearn.manifold.MDS.html) you will see both of these methods have this argument as input, with a default value, however using other default parameters PCA will give the same output whereas the output from MDS might change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# enter your CID here, or date of birth, or another number of your choosing to use as random state\n",
    "CID = 0 # do not add the leading 0\n",
    "\n",
    "# remember to check the documentation of each algorithm if setting the random_state is needed\n",
    "# for this tutorial and all upcoming tutorials..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metric MDS\n",
    "Set the `metric` parameter to True to perform metric MDS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding = MDS(n_components=2, metric=True, random_state=CID)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the `fit_transform` function to the MDS object to transform the data. By default metric MDS uses Euclidean distances in the sklearn implementation we are using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_euclidean = embedding.fit_transform(diabetes_urine_metab.iloc[:, 6:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualise the first two MDS components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_style(\"ticks\")\n",
    "sns.set_context(\"notebook\")\n",
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "p = sns.scatterplot(x=embedding_euclidean[:, 0], y=embedding_euclidean[:, 1], hue=diabetes_urine_metab[\"T2D\"])\n",
    "\n",
    "p.set_xlabel(\"Dim 1\")\n",
    "p.set_ylabel(\"Dim 2\")\n",
    "plt.title(\"Metric MDS\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dissimilarity metrics\n",
    "We can use different metrics to compute the dissimilarity matrix for metric MDS. The default option used in the MDS function is Euclidean distance. We can otherwise specify `dissimilarity = \"precomputed\"`. Here we provide a dissimilarity matrix we have already computed. \n",
    "\n",
    "We can compute the dissimilarity matrix using [various metrics](https://scikit-learn.org/0.24/modules/generated/sklearn.neighbors.DistanceMetric.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running MDS on a precomputed Manhattan distance dissimilarity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute manhattan distances on the data\n",
    "manhattan_dist = DistanceMetric.get_metric('manhattan').pairwise(diabetes_urine_metab.iloc[:, 6:])\n",
    "\n",
    "# perform metric MDS with the manhattan distances\n",
    "embedding_manhattan = MDS(n_components=2, metric=True, dissimilarity=\"precomputed\")\n",
    "MDS_manhattan = embedding_manhattan.fit_transform(manhattan_dist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### and Minkowski distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "minkowski_dist = DistanceMetric.get_metric('minkowski').pairwise(diabetes_urine_metab.iloc[:, 6:])\n",
    "\n",
    "embedding_minkowski = MDS(n_components=2, metric=True, dissimilarity=\"precomputed\")\n",
    "MDS_minkowski = embedding_minkowski.fit_transform(minkowski_dist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compare the results obtained using metric MDS with different dissimilarity metrics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))\n",
    "\n",
    "sns.scatterplot(x=embedding_euclidean[:, 0], y=embedding_euclidean[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax1)\n",
    "ax1.set_title(\"Euclidean\")\n",
    "\n",
    "sns.scatterplot(x=MDS_manhattan[:, 0], y=MDS_manhattan[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax2)\n",
    "ax2.set_title(\"Manhattan\")\n",
    "\n",
    "sns.scatterplot(x=MDS_minkowski[:, 0], y=MDS_minkowski[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax3)\n",
    "ax3.set_title(\"Minkowski\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using previous code examples, compute another similarity metric based on the metabolomics data (full list [here](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.DistanceMetric.html)), try to do this without help from generative AI first. If you need help from generative AI ask it to explain each line of the code so you understand the steps.\n",
    "\n",
    "Then visualise the first two components using a scatterplot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code here...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-metric MDS\n",
    "To compute non-metric MDS, set the parameter `metric=False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_nonmetric = MDS(n_components=2, metric=False)\n",
    "diabetes_urine_metab_transformed_nMDS = embedding_nonmetric.fit_transform(diabetes_urine_metab.iloc[:, 6:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualise the first two non-metric MDS components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_style(\"ticks\")\n",
    "sns.set_context(\"notebook\")\n",
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "p = sns.scatterplot(x=diabetes_urine_metab_transformed_nMDS[:, 0],\n",
    " y=diabetes_urine_metab_transformed_nMDS[:, 1], \n",
    " hue=diabetes_urine_metab[\"T2D\"])\n",
    "\n",
    "p.set_xlabel(\"Dim 1\")\n",
    "p.set_ylabel(\"Dim 2\")\n",
    "plt.title(\"Non-metric MDS\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How does MDS compare with PCA?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using what you have learnt from the previous tutorial on PCA, scale the input metabolomics data, apply PCA and project the metabolomics data into the latent space, and visualise the data using a scatterplot. Colour the datapoints by Type 2 diabetes status \"T2D\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import scaler\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# scale the data\n",
    "diabetes_urine_metab_scaled = StandardScaler().fit_transform(diabetes_urine_metab.iloc[:, 6:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perform PCA and project the data\n",
    "pca_res = PCA(n_components=2).fit_transform(diabetes_urine_metab_scaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot two components of the projected data on a scatter plot\n",
    "sns.set_style(\"ticks\")\n",
    "sns.set_context(\"notebook\")\n",
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "p = sns.scatterplot(x=pca_res[:, 0], y=pca_res[:, 1], hue=diabetes_urine_metab[\"T2D\"])\n",
    "\n",
    "p.set_xlabel(\"PC1\")\n",
    "p.set_ylabel(\"PC2\")\n",
    "\n",
    "plt.title(\"PCA\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n",
    "\n",
    "sns.scatterplot(x=pca_res[:, 0], y=pca_res[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax1)\n",
    "ax1.set_title(\"PCA\")\n",
    "\n",
    "sns.scatterplot(x=embedding_euclidean[:, 0], y=embedding_euclidean[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax2)\n",
    "ax2.set_title(\"MDS (metric)\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How similar are these projections?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your turn\n",
    "Choose one of the other omics datasets in the `Data` folder and perform MDS on it. Visualise the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import dataset\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform MDS\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualise the results\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optional materials\n",
    "Please view the [YouTube video](https://youtu.be/Aq8LcirHc20) online about NNMF before you start this part of the tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Non-negative Matrix Factorisation (NMF)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the [sklearn.NMF() function](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.NMF.html) to perform non-negative matrix factorisation on the dataset. We will initialise the model with five components, and use the \"random\" initialiser.\n",
    "\n",
    "The input matrix $X$ (the metabolomics dataset without covariates/metadata) will be factorised into the matrices $W$ (weights / projected data) and $H$ (hidden factorization / principal components)\n",
    "\n",
    "$X \\approx HW$\n",
    "\n",
    "Note: the original publication uses a different formula and it assumes that the data (V instead of X) was transposed (each row are variables and each column is a sample) compared to here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate the NMF model\n",
    "# here we will select 5 components\n",
    "model = NMF(n_components=5, init='random', random_state=CID)\n",
    "\n",
    "# set X as the input omics data matrix\n",
    "X = diabetes_urine_metab.iloc[:, 6:]\n",
    "\n",
    "# the hidden components matrix H is obtained by projecting the original data\n",
    "H = model.fit_transform(X)\n",
    "\n",
    "# the weights matrix W is obtained by using the .components_ attribute\n",
    "W = model.components_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If you get a warning, take a look in the documentation on what this is and how to add it as an input to the function)\n",
    "\n",
    "Let's look a the shape of the resulting matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "W.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should be able to approximately reconstruct the original matrix $V$ by calculating the product of $W$ and $H$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# obtain the dot product of the matrices W and H\n",
    "V_approx = pd.DataFrame(np.dot(W, H))\n",
    "\n",
    "# This is the same shape as the original matrix V\n",
    "V_approx.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compare the two matrices V and V_approx by eye:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V_approx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also estimate the reconstruction error using the Frobenius norm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.reconstruction_err_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does the reconstruction error change as you vary `n_components`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpreting NMF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $H$ matrix contains the loadings or principal components, summarising the importance of each feature (metabolites in this case) in the new components, of which we have selected 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add metabolite names to the matrix H to help interpretation\n",
    "H_df = pd.DataFrame(H.T, columns=range(1, H.shape[0]+1), index=V.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we sort each column, we can determine the most important metabolites driving each component (1-5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for each component, print out the top 5 features driving that component\n",
    "for col in H_df:\n",
    "    print(\"Component: \"+ str(col))\n",
    "    print(H_df[col].sort_values(ascending=False)[0:5].index.tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualise the first (not top) 20 metabolites in the metabolomics data, alongside their contribution to the 5 latent factors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "plt.imshow(H_df.iloc[0:20, :], cmap=\"viridis\")\n",
    "plt.yticks(range(len(H_df.iloc[0:20, :].index)), H_df.iloc[0:20, :].index)\n",
    "plt.xticks(range(0, 5), [1, 2, 3, 4, 5])\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualise the first two components of the NMF projected data ($W$) using a scatterplot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_style(\"ticks\")\n",
    "sns.set_context(\"notebook\")\n",
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "p = sns.scatterplot(x=W[:, 0], y=W[:, 1], hue=diabetes_urine_metab[\"T2D\"])\n",
    "\n",
    "p.set_xlabel(\"Dim 1\")\n",
    "p.set_ylabel(\"Dim 2\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also plot a heatmap using the NMF projected data $W$, which clusters the samples based on T2D status using the five latent factors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.clustermap(W.T,\n",
    "col_colors=[\"tab:orange\" if i == 1 else \"tab:blue\" for i in diabetes_urine_metab[\"T2D\"]],\n",
    "row_colors=sns.color_palette(\"tab10\"),\n",
    "xticklabels=False)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How do NMF and MDS compare with PCA?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using what you have learnt from the previous tutorial on PCA, scale the input metabolomics data, apply PCA and project the metabolomics data into the latent space, and visualise the data using a scatterplot. Colour the datapoints by Type 2 diabetes status \"T2D\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import scaler\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# scale the data\n",
    "diabetes_urine_metab_scaled = StandardScaler().fit_transform(diabetes_urine_metab.iloc[:, 6:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perform PCA and project the data\n",
    "pca_res = PCA(n_components=2).fit_transform(diabetes_urine_metab_scaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot two components of the projected data on a scatter plot\n",
    "sns.set_style(\"ticks\")\n",
    "sns.set_context(\"notebook\")\n",
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "p = sns.scatterplot(x=pca_res[:, 0], y=pca_res[:, 1], hue=diabetes_urine_metab[\"T2D\"])\n",
    "\n",
    "p.set_xlabel(\"PC1\")\n",
    "p.set_ylabel(\"PC2\")\n",
    "\n",
    "plt.title(\"PCA\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))\n",
    "\n",
    "sns.scatterplot(x=pca_res[:, 0], y=pca_res[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax1)\n",
    "ax1.set_title(\"PCA\")\n",
    "\n",
    "sns.scatterplot(x=W[:, 0], y=W[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax2)\n",
    "ax2.set_title(\"NMF\")\n",
    "\n",
    "sns.scatterplot(x=embedding_euclidean[:, 0], y=embedding_euclidean[:, 1], hue=diabetes_urine_metab[\"T2D\"], ax=ax3)\n",
    "ax3.set_title(\"MDS (metric)\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note - look at the axes: using NMF all weights are POSITIVE, unlike in PCA or MDS"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "b36f82fc6ec7da3c99303f5c6c1c64ad749da77112fc70d0beec9ca6a90b9819"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}