read_in_5_minutes.ipynb

write_in_5_minutes.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/mwalzer/6c881986bbb1fc126e54de000076d232/write_in_5_minutes.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IL3OJpGZoCoJ"
      },
      "source": [
        "# Welcome to the 5-Minute mzQC interactive guides with python!\n",
        "This python notebook will guide you through your first steps with writing your own mzQC in python. \n",
        "\n",
        "We will calculate a QC metric from our data, visualise it, put it in a controlled vocabulary  object, add some metadata about the ms-experiment the data came from, and finally create our first mzQC file! (We assume it is not the first time you get your feet wet with python, otherwise rather plan for 25 minutes.)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Q3PRPFooCoM"
      },
      "source": [
        "## Setting the scene\n",
        "First, we need to install the mzQC python library. When outside of the python notebook, find out [here](https://github.com/MS-Quality-hub/pymzqc) how to install locally (spoiler: usually just `pip install pymzqc`)."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install pymzqc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c_iK2GkCojkY",
        "outputId": "73b083ff-cd5f-4da2-e91c-9becc549eede"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pymzqc\n",
            "  Downloading pymzqc-1.0.0rc1-py3-none-any.whl (13 kB)\n",
            "Collecting requests>=2.27.1\n",
            "  Downloading requests-2.28.0-py3-none-any.whl (62 kB)\n",
            "\u001b[K     |████████████████████████████████| 62 kB 1.6 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from pymzqc) (1.21.6)\n",
            "Requirement already satisfied: pandas>=1.1.5 in /usr/local/lib/python3.7/dist-packages (from pymzqc) (1.3.5)\n",
            "Collecting pronto<2.2.1\n",
            "  Downloading pronto-2.2.0-py2.py3-none-any.whl (53 kB)\n",
            "\u001b[K     |████████████████████████████████| 53 kB 2.6 MB/s \n",
            "\u001b[?25hRequirement already satisfied: jsonschema>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from pymzqc) (4.3.3)\n",
            "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.2.0->pymzqc) (5.7.1)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.2.0->pymzqc) (4.11.4)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.2.0->pymzqc) (4.1.1)\n",
            "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.2.0->pymzqc) (21.4.0)\n",
            "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.2.0->pymzqc) (0.18.1)\n",
            "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.7/dist-packages (from importlib-resources>=1.4.0->jsonschema>=3.2.0->pymzqc) (3.8.0)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=1.1.5->pymzqc) (2022.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=1.1.5->pymzqc) (2.8.2)\n",
            "Requirement already satisfied: networkx~=2.3 in /usr/local/lib/python3.7/dist-packages (from pronto<2.2.1->pymzqc) (2.6.3)\n",
            "Requirement already satisfied: chardet~=3.0 in /usr/local/lib/python3.7/dist-packages (from pronto<2.2.1->pymzqc) (3.0.4)\n",
            "Collecting fastobo~=0.8.2\n",
            "  Downloading fastobo-0.8.2-cp37-cp37m-manylinux2010_x86_64.manylinux1_x86_64.whl (1.8 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.8 MB 47.4 MB/s \n",
            "\u001b[?25hCollecting frozendict~=1.2\n",
            "  Downloading frozendict-1.2.tar.gz (2.6 kB)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas>=1.1.5->pymzqc) (1.15.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.27.1->pymzqc) (2022.6.15)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.27.1->pymzqc) (2.10)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.7/dist-packages (from requests>=2.27.1->pymzqc) (2.0.12)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests>=2.27.1->pymzqc) (1.24.3)\n",
            "Building wheels for collected packages: frozendict\n",
            "  Building wheel for frozendict (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for frozendict: filename=frozendict-1.2-py3-none-any.whl size=3166 sha256=fccb38820a36c1431556bff63f8bc98b4e3b599b6618cb29e5c2fbd165d48f96\n",
            "  Stored in directory: /root/.cache/pip/wheels/68/17/69/ac196dd181e620bba5fae5488e4fd6366a7316dce13cf88776\n",
            "Successfully built frozendict\n",
            "Installing collected packages: frozendict, fastobo, requests, pronto, pymzqc\n",
            "  Attempting uninstall: requests\n",
            "    Found existing installation: requests 2.23.0\n",
            "    Uninstalling requests-2.23.0:\n",
            "      Successfully uninstalled requests-2.23.0\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "google-colab 1.0.0 requires requests~=2.23.0, but you have requests 2.28.0 which is incompatible.\n",
            "datascience 0.10.6 requires folium==0.2.1, but you have folium 0.8.3 which is incompatible.\u001b[0m\n",
            "Successfully installed fastobo-0.8.2 frozendict-1.2 pronto-2.2.0 pymzqc-1.0.0rc1 requests-2.28.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Then, we start right in by loading pymzqc (`from mzqc`). We'll also utilise some other libraries, too.\n",
        "For example, we will use `requests` to load some data from the web. This we will use as the computational data basis for the 'QC' metric value we are calculating and later visualise in this python notebook."
      ],
      "metadata": {
        "id": "2ykL5FmvqbsO"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Al3jW6O7oCoQ"
      },
      "outputs": [],
      "source": [
        "from mzqc import MZQCFile as qc\n",
        "import numpy as np\n",
        "from io import StringIO\n",
        "import requests\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Get some input data from the interwebs\n",
        "url = \"https://raw.githubusercontent.com/percolator/percolator/master/data/percolator/tab/percolatorTab\"\n",
        "r = requests.get(url)\n",
        "if r.ok:\n",
        "    data = r.content.decode('utf8')\n",
        "\n",
        "data = '\\n'.join(data.split('\\n')[2:])  # remove the nasty extra header row"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ERF94zUxoCoV"
      },
      "source": [
        "The data is identification data from a yeast digest 2h gradient run, just before you would subject your findings to [percolator](https://github.com/percolator/percolator). We will take a closer look at the mass discrepancies of the found PSMs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Iu2ZTcPOoCoX"
      },
      "outputs": [],
      "source": [
        "dm_source = np.loadtxt(StringIO(data), usecols=(2,3,4), delimiter='\\t', dtype={'names': ('ScanNr','ExpMass', 'CalcMass'), 'formats': ('i4', 'f4', 'f4')})\n",
        "dm = dm_source['CalcMass'] - dm_source['ExpMass']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tg1EVdy2oCoY"
      },
      "source": [
        "## Visualising our data\n",
        "It is good practice to have a look at the data with some basic visualisation. Next, we will plot the mass errors in a histogram."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "Wf3z_YY0oCoZ",
        "outputId": "07553fb5-354c-4075-de53-72be128a5f91"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Text(0, 0.5, 'Frequency'), Text(0.5, 1.0, 'Delta Mass Histogram')]"
            ]
          },
          "metadata": {},
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plt.hist(dm, bins=10)\n",
        "plt.gca().set(title='Delta Mass Histogram', ylabel='Frequency')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wi_3xmQAoCoa"
      },
      "source": [
        "The distribution seems centered around 0, which is good but the histogram has a rather wide bin setting, so we can check with another visualistation. Let's take a look at the violin plot of the absolute error."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "km1mA3_IoCob",
        "outputId": "6aaeb019-3a5a-43f1-bc3d-06c5aac86ae6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "fig,ax = plt.subplots(1)\n",
        "\n",
        "ax.violinplot(np.abs(dm))\n",
        "# plt.violinplot(dm)\n",
        "\n",
        "ax.set_ylabel('Mass error')\n",
        "ax.set_xlabel('Frequency')\n",
        "\n",
        "# Turn off x tick labels\n",
        "ax.set_xticklabels([])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Man0bIaXoCod"
      },
      "source": [
        "This looks suspicious, we better make some QC metrics to document that! We will describe the found distribution with $\\sigma,Q_1,Q_2,Q_3$ and put it in a mzQC file to share with others.\n",
        "\n",
        "## Creating our metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MtV7IYEloCof",
        "outputId": "29e2a3cd-b84b-402b-9570-d7b8fb92d4c5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mass error Q1=-0.0098876953125, Q2=0.0, Q3=0.00299072265625, sigma=0.008799662813544273\n"
          ]
        }
      ],
      "source": [
        "qm1 = qc.QualityMetric(accession=\"QC:0000000\", name=\"Mass error sigma\", value=np.std(dm))\n",
        "\n",
        "q1,q2,q3 = np.quantile(dm, [0.25,0.5,0.75])\n",
        "qm2 = qc.QualityMetric(accession=\"QC:0000000\", name=\"Mass error Q1, Q2, Q3\", value=(q1,q2,q3))\n",
        "\n",
        "print(\"Mass error Q1={}, Q2={}, Q3={}, sigma={}\".format(qm2.value[0],qm2.value[1],qm2.value[2],qm1.value))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WITYzB46oCoi"
      },
      "source": [
        "Creating a controlled vocabulary defined metric in mzQC is easy! Look for the fitting entry in [our ontology](https://github.com/HUPO-PSI/mzQC/blob/master/cv/qc-cv.obo) or request a [new one](https://github.com/HUPO-PSI/mzQC/issues/new?assignees=julianu&labels=request+for+new+CV+entry&template=request-for-new-cv-entry.md&title=%5BCV+request%5D). Note the name and the accession, then set them as the `QualityMetric`s name and accession. We also need to keep a reference from which ontology this metric came from, so we note this as 'QC'. We will provide details about the ontologies used later. \n",
        "Setting the actual value of a metric is easy, just collect the values you calculated. (They have to be appropriate to the definition of the metric, though.)\n",
        "\n",
        "## Keep track of your sources"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S5E1pYp2oCol"
      },
      "outputs": [],
      "source": [
        "infi_peak = qc.InputFile(name=\"file.raw\",location=\"file:///dev/null/file.raw\", \n",
        "                    fileFormat=qc.CvParameter(accession=\"MS:1000563\", name=\"Thermo RAW format\"), \n",
        "                    fileProperties=[qc.CvParameter(accession=\"MS:1000747\", \n",
        "                                                    name=\"completion time\", \n",
        "                                                    value=\"2015-10-03-T10:18:27Z\"),\n",
        "                            qc.CvParameter(accession=\"MS:1000569\", \n",
        "                                            name=\"SHA-1\", \n",
        "                                            value=\"76de62feccaaaadb608e89d897db57135e39ad87\"\n",
        "                            ),\n",
        "                            qc.CvParameter(accession=\"MS:1000031\", \n",
        "                                            name=\"instrument model\",\n",
        "                                            value=\"LTQ Orbitrap Velos\"\n",
        "                            )\n",
        "            ])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QP8tamiToCon"
      },
      "source": [
        "It is crucial to provide some more information apart from the metrics themselves. To put the metrics into context, it is essential to keep track of the peak file or acquisition file that constitutes the basis to later data. In our case it is a thermo raw file from which we did the identifications from which we calculated our metric. We need to keep some more information about the origins file apart from the name:\n",
        " * the completion time\n",
        " * the checksum\n",
        " * the instrument type "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i-naaHYBoCop"
      },
      "outputs": [],
      "source": [
        "infi_ids = qc.InputFile(name=\"afteridbeforepercolat.tsv\",location=\"file:///dev/null\", \n",
        "                    fileFormat=qc.CvParameter(accession=\"MS:1000914\", \n",
        "                                name=\"tab delimited text format\"), \n",
        "                    )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ApGE8mp7oCop"
      },
      "source": [
        "We also want at least to know about the software that was involved in the process of creating the metrics. In our case that is the software that produced the identifications - comet, which has a PSI-MS cv term we can use, and obviously this python notebook."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ny7Mi-TZoCoq"
      },
      "outputs": [],
      "source": [
        "anso_mzqc = qc.AnalysisSoftware(accession=\"MS:1002251\", \n",
        "                                name=\"Comet\",\n",
        "                                version=\"2018.01.1\", \n",
        "                                uri=\"http://proteomicsresource.washington.edu/sequest.php\")\n",
        "anso_nb = qc.AnalysisSoftware(version=\"0.1.2.3\", uri=\"file:///mylocal/jupyter/host\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R5aVDnhToCor"
      },
      "source": [
        "## Assemble a mzQC file (object)\n",
        "\n",
        "Now we have all the neccessary information in place to build a descriptive object of the experiment and analysis for the mzQC file:\n",
        "\n",
        "The `metadata`\n",
        "* inputFiles\n",
        "* analysisSoftware\n",
        "\n",
        "and our `qualityMetrics`\n",
        "* qm1\n",
        "* qm2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gXuAZP0voCos"
      },
      "outputs": [],
      "source": [
        "meta = qc.MetaDataParameters(inputFiles=[infi_peak, infi_ids],analysisSoftware=[anso_mzqc,anso_nb])\n",
        "\n",
        "rq = qc.RunQuality(metadata=meta, qualityMetrics=[qm1, qm2])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d96aE30-oCos"
      },
      "source": [
        "Now it is time to provide some more information about the ontologies which' terms we were using, so that the next one to read our file can look up the metric definitions, understand what the values mean, and use the data in further analysis."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O-C-braSoCot"
      },
      "outputs": [],
      "source": [
        "cv_qc = qc.ControlledVocabulary(name=\"Proteomics Standards Initiative Quality Control Ontology\",version=\"0.1.0\", uri=\"https://github.com/HUPO-PSI/qcML-development/blob/master/cv/v0_1_0/qc-cv.obo\")\n",
        "\n",
        "cv_ms = qc.ControlledVocabulary(name=\"Proteomics Standards Initiative Mass Spectrometry Ontology\",version=\"4.1.7\", uri=\"https://github.com/HUPO-PSI/psi-ms-CV/blob/master/psi-ms.obo\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "91pFCDGCoCot"
      },
      "source": [
        "Finally we can put the last pieces together and form a mzQC file. We also note the current time in _ISO 8601 format_, the version of the mzQC format, we were writing. And so we made our first mzQC file."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2YyQhSTSoCou"
      },
      "outputs": [],
      "source": [
        "from datetime import datetime\n",
        "mzqc = qc.MzQcFile(version=\"1.0.0\", creationDate=datetime.now().isoformat(), runQualities=[rq], setQualities=[], controlledVocabularies=[cv_qc, cv_ms])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6C3rvQToCov"
      },
      "source": [
        "With some extra python notebook _magic_, we can even download the fruit of our labour. (You need to execute all cells successfully in order to get the download link.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "id": "WPTkIetGoCox",
        "outputId": "552a7877-28b6-4227-b76a-6a0c0c067ac4"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<a download=\"first.mzQC\" href=\"data:application/json;base64,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\" target=\"_blank\">our first mzqc file</a>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "from IPython.display import HTML\n",
        "import base64\n",
        "def download_mzqc(mzqc, title, filename):\n",
        "    inmem_file = qc.JsonSerialisable.ToJson(mzqc)\n",
        "    mzqc_b64 = base64.b64encode(inmem_file.encode())\n",
        "    payload = mzqc_b64.decode()\n",
        "    html = '<a download=\"{filename}\" href=\"data:application/json;base64,{payload}\" target=\"_blank\">{title}</a>'\n",
        "    html = html.format(payload=payload,title=title,filename=filename)\n",
        "    return HTML(html)\n",
        "\n",
        "download_mzqc(mzqc, \"our first mzqc file\", \"first.mzQC\")"
      ]
    }
  ],
  "metadata": {
    "file_extension": ".py",
    "kernelspec": {
      "display_name": "Python 3.6.9 64-bit",
      "name": "python369jvsc74a57bd04cd7ab41f5fca4b9b44701077e38c5ffd31fe66a6cab21e0214b68d958d0e462"
    },
    "language_info": {
      "name": "python",
      "version": ""
    },
    "mimetype": "text/x-python",
    "name": "python",
    "npconvert_exporter": "python",
    "orig_nbformat": 2,
    "pygments_lexer": "ipython3",
    "version": 3,
    "colab": {
      "name": "read_in_5_minutes.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}