docs/notebooks/different_noise_models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Different noise models\n",
    "\n",
    "In this notebook we look at the different noise models.\n",
    "\n",
    "## Prepare train, test and side-info\n",
    "\n",
    "We first need to download and prepare the data files. This can be acomplished using this a built-in function is smurff. IC50 is a compound x protein matrix, The ECFP matrix as features as side information on the compounds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import smurff\n",
    "import logging\n",
    "\n",
    "logging.basicConfig(level = logging.INFO)\n",
    "\n",
    "ic50_train, ic50_test, ecfp = smurff.load_chembl()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fixed noise\n",
    "\n",
    "The noise model of observed data  can be annotated by calling `addTrainAndTest` with\n",
    "the optional parameter `noise_model`. The default for this parameter is `FixedNoise` with precision 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainSession = smurff.TrainSession(\n",
    "                            priors = ['normal', 'normal'],\n",
    "                            num_latent=32,\n",
    "                            burnin=100,\n",
    "                            nsamples=500)\n",
    "\n",
    "# the following line is equivalent to the default, not specifing noise_model\n",
    "trainSession.addTrainAndTest(ic50_train, ic50_test, smurff.FixedNoise(5.0))\n",
    "predictions = trainSession.run()\n",
    "print(\"RMSE = %.2f\" % smurff.calc_rmse(predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adaptive noise\n",
    "\n",
    "Instead of a fixed precision, we can also allow the model to automatically determine the precision of the noise by using `AdaptiveNoise`, with signal-to-noise ratio parameters `sn_init` and `sn_max`.\n",
    "\n",
    "- `sn_init` is an initial signal-to-noise ratio.\n",
    "- `sn_max`  is the maximum allowed signal-to-noise ratio. This means that if the updated precision would imply a higher signal-to-noise ratio than `sn_max`, then the precision value is set to `(sn_max + 1.0) / Yvar` where `Yvar` is the variance of the training dataset `Y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainSession = smurff.TrainSession(\n",
    "                            priors = ['normal', 'normal'],\n",
    "                            num_latent=32,\n",
    "                            burnin=100,\n",
    "                            nsamples=500)\n",
    "\n",
    "trainSession.addTrainAndTest(ic50_train, ic50_test, smurff.AdaptiveNoise(1.0, 10.))\n",
    "predictions = trainSession.run()\n",
    "print(\"RMSE = %.2f\" % smurff.calc_rmse(predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Binary matrices\n",
    "\n",
    "SMURFF can also factorize binary matrices (with or without side information).\n",
    "The input matrices can contain arbitrary values, and are converted to 0's and 1' by means of a threshold.\n",
    "To factorize them we employ probit noise model `ProbitNoise`, taking this\n",
    "`threshold` as a parameter.\n",
    "\n",
    "To evaluate binary factorization, we recommed to use *ROC AUC*, which can be enabled by providing\n",
    "a threshold also to the `TrainSession`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ic50_threshold = 6.\n",
    "trainSession = smurff.TrainSession(\n",
    "                            priors = ['normal', 'normal'],\n",
    "                            num_latent=32,\n",
    "                            burnin=100,\n",
    "                            nsamples=100,\n",
    "                            # Using threshold of 6. to calculate AUC on test data\n",
    "                            threshold=ic50_threshold)\n",
    "\n",
    "## using activity threshold pIC50 > 6. to binarize train data\n",
    "trainSession.addTrainAndTest(ic50_train, ic50_test, smurff.ProbitNoise(ic50_threshold))\n",
    "predictions = trainSession.run()\n",
    "print(\"RMSE = %.2f\" % smurff.calc_rmse(predictions))\n",
    "print(\"AUC = %.2f\" % smurff.calc_auc(predictions, ic50_threshold))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input train and test sets are converted to -1 and +1 values, if the original values are below or above the threshold (respectively). Similarly, the resulting predictions will be negative, if the model predicts the value to be below the threshold, or positive, if the model predicts the value to be above the threshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary matrices with Side Info\n",
    "\n",
    "It is possible to enhance the model for binary matrices by adding side information using the Macau algorithm.\n",
    "Note that the *binary* here refers to the train and test data, not to the side information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ic50_threshold = 6.\n",
    "trainSession = smurff.TrainSession(\n",
    "                            priors = ['macau', 'normal'],\n",
    "                            num_latent=32,\n",
    "                            burnin=100,\n",
    "                            nsamples=100,\n",
    "                            # Using threshold of 6. to calculate AUC on test data\n",
    "                            threshold=ic50_threshold)\n",
    "\n",
    "## using activity threshold pIC50 > 6. to binarize train data\n",
    "trainSession.addTrainAndTest(ic50_train, ic50_test, smurff.ProbitNoise(ic50_threshold))\n",
    "trainSession.addSideInfo(0, ecfp, direct = True)\n",
    "predictions = trainSession.run()\n",
    "print(\"RMSE = %.2f\" % smurff.calc_rmse(predictions))\n",
    "print(\"AUC = %.2f\" % smurff.calc_auc(predictions, ic50_threshold))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}